Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge branch 'devlink-finish-conversion-to-generated-split_ops'
Jiri Pirko says:
====================
devlink: finish conversion to generated split_ops
This patchset converts the remaining genetlink commands to generated
split_ops and removes the existing small_ops arrays entirely
alongside with shared netlink attribute policy.
Patches #1-#6 are just small preparations and small fixes on multiple
places. Note that couple of patches contain the "Fixes"
tag but no need to put them into -net tree.
Patch #7 is a simple rename preparation
Patch #8 is the main one in this set and adds actual definitions of cmds
in to yaml file.
Patches #9-#10 finalize the change removing bits that are no longer in
use.
====================
Link: https://lore.kernel.org/r/20231021112711.660606-1-jiri@resnulli.us
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
+9542
-558
+1
-1
Documentation/netlink/genetlink-legacy.yaml
+1
-1
Documentation/netlink/genetlink-legacy.yaml
···
192
192
type: string
193
193
type: &attr-type
194
194
description: The netlink attribute type
195
-
enum: [ unused, pad, flag, binary,
195
+
enum: [ unused, pad, flag, binary, bitfield32,
196
196
uint, sint, u8, u16, u32, u64, s32, s64,
197
197
string, nest, array-nest, nest-type-value ]
198
198
doc:
+1474
-84
Documentation/netlink/specs/devlink.yaml
+1474
-84
Documentation/netlink/specs/devlink.yaml
···
15
15
name: ingress
16
16
-
17
17
name: egress
18
+
-
19
+
type: enum
20
+
name: port-type
21
+
entries:
22
+
-
23
+
name: notset
24
+
-
25
+
name: auto
26
+
-
27
+
name: eth
28
+
-
29
+
name: ib
30
+
-
31
+
type: enum
32
+
name: port-flavour
33
+
entries:
34
+
-
35
+
name: physical
36
+
-
37
+
name: cpu
38
+
-
39
+
name: dsa
40
+
-
41
+
name: pci_pf
42
+
-
43
+
name: pci_vf
44
+
-
45
+
name: virtual
46
+
-
47
+
name: unused
48
+
-
49
+
name: pci_sf
50
+
-
51
+
type: enum
52
+
name: port-fn-state
53
+
entries:
54
+
-
55
+
name: inactive
56
+
-
57
+
name: active
58
+
-
59
+
type: enum
60
+
name: port-fn-opstate
61
+
entries:
62
+
-
63
+
name: detached
64
+
-
65
+
name: attached
66
+
-
67
+
type: enum
68
+
name: port-fn-attr-cap
69
+
entries:
70
+
-
71
+
name: roce-bit
72
+
-
73
+
name: migratable-bit
74
+
-
75
+
type: enum
76
+
name: sb-threshold-type
77
+
entries:
78
+
-
79
+
name: static
80
+
-
81
+
name: dynamic
82
+
-
83
+
type: enum
84
+
name: eswitch-mode
85
+
entries:
86
+
-
87
+
name: legacy
88
+
-
89
+
name: switchdev
90
+
-
91
+
type: enum
92
+
name: eswitch-inline-mode
93
+
entries:
94
+
-
95
+
name: none
96
+
-
97
+
name: link
98
+
-
99
+
name: network
100
+
-
101
+
name: transport
102
+
-
103
+
type: enum
104
+
name: eswitch-encap-mode
105
+
entries:
106
+
-
107
+
name: none
108
+
-
109
+
name: basic
110
+
-
111
+
type: enum
112
+
name: dpipe-match-type
113
+
entries:
114
+
-
115
+
name: field-exact
116
+
-
117
+
type: enum
118
+
name: dpipe-action-type
119
+
entries:
120
+
-
121
+
name: field-modify
122
+
-
123
+
type: enum
124
+
name: dpipe-field-mapping-type
125
+
entries:
126
+
-
127
+
name: none
128
+
-
129
+
name: ifindex
130
+
-
131
+
type: enum
132
+
name: resource-unit
133
+
entries:
134
+
-
135
+
name: entry
136
+
-
137
+
type: enum
138
+
name: reload-action
139
+
entries:
140
+
-
141
+
name: driver-reinit
142
+
value: 1
143
+
-
144
+
name: fw-activate
145
+
-
146
+
type: enum
147
+
name: param-cmode
148
+
entries:
149
+
-
150
+
name: runtime
151
+
-
152
+
name: driverinit
153
+
-
154
+
name: permanent
155
+
-
156
+
type: enum
157
+
name: flash-overwrite
158
+
entries:
159
+
-
160
+
name: settings-bit
161
+
-
162
+
name: identifiers-bit
163
+
-
164
+
type: enum
165
+
name: trap-action
166
+
entries:
167
+
-
168
+
name: drop
169
+
-
170
+
name: trap
171
+
-
172
+
name: mirror
18
173
19
174
attribute-sets:
20
175
-
···
186
31
-
187
32
name: port-index
188
33
type: u32
34
+
-
35
+
name: port-type
36
+
type: u16
37
+
enum: port-type
38
+
39
+
# TODO: fill in the attributes in between
40
+
41
+
-
42
+
name: port-split-count
43
+
type: u32
44
+
value: 9
189
45
190
46
# TODO: fill in the attributes in between
191
47
···
211
45
name: sb-pool-index
212
46
type: u16
213
47
value: 17
214
-
215
48
-
216
49
name: sb-pool-type
217
50
type: u8
218
51
enum: sb-pool-type
219
-
220
-
# TODO: fill in the attributes in between
221
-
52
+
-
53
+
name: sb-pool-size
54
+
type: u32
55
+
-
56
+
name: sb-pool-threshold-type
57
+
type: u8
58
+
enum: sb-threshold-type
59
+
-
60
+
name: sb-threshold
61
+
type: u32
222
62
-
223
63
name: sb-tc-index
224
64
type: u16
225
65
value: 22
66
+
67
+
# TODO: fill in the attributes in between
68
+
69
+
-
70
+
name: eswitch-mode
71
+
type: u16
72
+
value: 25
73
+
enum: eswitch-mode
74
+
75
+
-
76
+
name: eswitch-inline-mode
77
+
type: u16
78
+
enum: eswitch-inline-mode
79
+
-
80
+
name: dpipe-tables
81
+
type: nest
82
+
nested-attributes: dl-dpipe-tables
83
+
-
84
+
name: dpipe-table
85
+
type: nest
86
+
multi-attr: true
87
+
nested-attributes: dl-dpipe-table
88
+
-
89
+
name: dpipe-table-name
90
+
type: string
91
+
-
92
+
name: dpipe-table-size
93
+
type: u64
94
+
-
95
+
name: dpipe-table-matches
96
+
type: nest
97
+
nested-attributes: dl-dpipe-table-matches
98
+
-
99
+
name: dpipe-table-actions
100
+
type: nest
101
+
nested-attributes: dl-dpipe-table-actions
102
+
-
103
+
name: dpipe-table-counters-enabled
104
+
type: u8
105
+
-
106
+
name: dpipe-entries
107
+
type: nest
108
+
nested-attributes: dl-dpipe-entries
109
+
-
110
+
name: dpipe-entry
111
+
type: nest
112
+
multi-attr: true
113
+
nested-attributes: dl-dpipe-entry
114
+
-
115
+
name: dpipe-entry-index
116
+
type: u64
117
+
-
118
+
name: dpipe-entry-match-values
119
+
type: nest
120
+
nested-attributes: dl-dpipe-entry-match-values
121
+
-
122
+
name: dpipe-entry-action-values
123
+
type: nest
124
+
nested-attributes: dl-dpipe-entry-action-values
125
+
-
126
+
name: dpipe-entry-counter
127
+
type: u64
128
+
-
129
+
name: dpipe-match
130
+
type: nest
131
+
multi-attr: true
132
+
nested-attributes: dl-dpipe-match
133
+
-
134
+
name: dpipe-match-value
135
+
type: nest
136
+
multi-attr: true
137
+
nested-attributes: dl-dpipe-match-value
138
+
-
139
+
name: dpipe-match-type
140
+
type: u32
141
+
enum: dpipe-match-type
142
+
-
143
+
name: dpipe-action
144
+
type: nest
145
+
multi-attr: true
146
+
nested-attributes: dl-dpipe-action
147
+
-
148
+
name: dpipe-action-value
149
+
type: nest
150
+
multi-attr: true
151
+
nested-attributes: dl-dpipe-action-value
152
+
-
153
+
name: dpipe-action-type
154
+
type: u32
155
+
enum: dpipe-action-type
156
+
-
157
+
name: dpipe-value
158
+
type: binary
159
+
-
160
+
name: dpipe-value-mask
161
+
type: binary
162
+
-
163
+
name: dpipe-value-mapping
164
+
type: u32
165
+
-
166
+
name: dpipe-headers
167
+
type: nest
168
+
nested-attributes: dl-dpipe-headers
169
+
-
170
+
name: dpipe-header
171
+
type: nest
172
+
multi-attr: true
173
+
nested-attributes: dl-dpipe-header
174
+
-
175
+
name: dpipe-header-name
176
+
type: string
177
+
-
178
+
name: dpipe-header-id
179
+
type: u32
180
+
-
181
+
name: dpipe-header-fields
182
+
type: nest
183
+
nested-attributes: dl-dpipe-header-fields
184
+
-
185
+
name: dpipe-header-global
186
+
type: u8
187
+
-
188
+
name: dpipe-header-index
189
+
type: u32
190
+
-
191
+
name: dpipe-field
192
+
type: nest
193
+
multi-attr: true
194
+
nested-attributes: dl-dpipe-field
195
+
-
196
+
name: dpipe-field-name
197
+
type: string
198
+
-
199
+
name: dpipe-field-id
200
+
type: u32
201
+
-
202
+
name: dpipe-field-bitwidth
203
+
type: u32
204
+
-
205
+
name: dpipe-field-mapping-type
206
+
type: u32
207
+
enum: dpipe-field-mapping-type
208
+
-
209
+
name: pad
210
+
type: pad
211
+
-
212
+
name: eswitch-encap-mode
213
+
type: u8
214
+
value: 62
215
+
enum: eswitch-encap-mode
216
+
-
217
+
name: resource-list
218
+
type: nest
219
+
nested-attributes: dl-resource-list
220
+
-
221
+
name: resource
222
+
type: nest
223
+
multi-attr: true
224
+
nested-attributes: dl-resource
225
+
-
226
+
name: resource-name
227
+
type: string
228
+
-
229
+
name: resource-id
230
+
type: u64
231
+
-
232
+
name: resource-size
233
+
type: u64
234
+
-
235
+
name: resource-size-new
236
+
type: u64
237
+
-
238
+
name: resource-size-valid
239
+
type: u8
240
+
-
241
+
name: resource-size-min
242
+
type: u64
243
+
-
244
+
name: resource-size-max
245
+
type: u64
246
+
-
247
+
name: resource-size-gran
248
+
type: u64
249
+
-
250
+
name: resource-unit
251
+
type: u8
252
+
enum: resource-unit
253
+
-
254
+
name: resource-occ
255
+
type: u64
256
+
-
257
+
name: dpipe-table-resource-id
258
+
type: u64
259
+
-
260
+
name: dpipe-table-resource-units
261
+
type: u64
262
+
-
263
+
name: port-flavour
264
+
type: u16
265
+
enum: port-flavour
226
266
227
267
# TODO: fill in the attributes in between
228
268
···
440
68
# TODO: fill in the attributes in between
441
69
442
70
-
443
-
name: region-name
444
-
type: string
445
-
value: 88
71
+
name: param-type
72
+
type: u8
73
+
value: 83
446
74
447
75
# TODO: fill in the attributes in between
448
76
449
77
-
78
+
name: param-value-cmode
79
+
type: u8
80
+
enum: param-cmode
81
+
value: 87
82
+
-
83
+
name: region-name
84
+
type: string
85
+
86
+
# TODO: fill in the attributes in between
87
+
88
+
-
89
+
name: region-snapshot-id
90
+
type: u32
91
+
value: 92
92
+
93
+
# TODO: fill in the attributes in between
94
+
95
+
-
96
+
name: region-chunk-addr
97
+
type: u64
98
+
value: 96
99
+
-
100
+
name: region-chunk-len
101
+
type: u64
102
+
-
450
103
name: info-driver-name
451
104
type: string
452
-
value: 98
453
105
-
454
106
name: info-serial-number
455
107
type: string
···
502
106
# TODO: fill in the attributes in between
503
107
504
108
-
109
+
name: fmsg
110
+
type: nest
111
+
nested-attributes: dl-fmsg
112
+
value: 106
113
+
-
114
+
name: fmsg-obj-nest-start
115
+
type: flag
116
+
-
117
+
name: fmsg-pair-nest-start
118
+
type: flag
119
+
-
120
+
name: fmsg-arr-nest-start
121
+
type: flag
122
+
-
123
+
name: fmsg-nest-end
124
+
type: flag
125
+
-
126
+
name: fmsg-obj-name
127
+
type: string
128
+
129
+
# TODO: fill in the attributes in between
130
+
131
+
-
505
132
name: health-reporter-name
506
133
type: string
507
134
value: 115
···
532
113
# TODO: fill in the attributes in between
533
114
534
115
-
116
+
name: health-reporter-graceful-period
117
+
type: u64
118
+
value: 120
119
+
-
120
+
name: health-reporter-auto-recover
121
+
type: u8
122
+
-
123
+
name: flash-update-file-name
124
+
type: string
125
+
-
126
+
name: flash-update-component
127
+
type: string
128
+
129
+
# TODO: fill in the attributes in between
130
+
131
+
-
132
+
name: port-pci-pf-number
133
+
type: u16
134
+
value: 127
135
+
136
+
# TODO: fill in the attributes in between
137
+
138
+
-
535
139
name: trap-name
536
140
type: string
537
141
value: 130
142
+
-
143
+
name: trap-action
144
+
type: u8
145
+
enum: trap-action
538
146
539
147
# TODO: fill in the attributes in between
540
148
···
577
131
# TODO: fill in the attributes in between
578
132
579
133
-
580
-
name: trap-policer-id
134
+
name: netns-fd
581
135
type: u32
582
-
value: 142
136
+
value: 138
137
+
-
138
+
name: netns-pid
139
+
type: u32
140
+
-
141
+
name: netns-id
142
+
type: u32
583
143
584
144
# TODO: fill in the attributes in between
585
145
146
+
-
147
+
name: health-reporter-auto-dump
148
+
type: u8
149
+
value: 141
150
+
-
151
+
name: trap-policer-id
152
+
type: u32
153
+
-
154
+
name: trap-policer-rate
155
+
type: u64
156
+
-
157
+
name: trap-policer-burst
158
+
type: u64
159
+
-
160
+
name: port-function
161
+
type: nest
162
+
nested-attributes: dl-port-function
163
+
164
+
# TODO: fill in the attributes in between
165
+
166
+
-
167
+
name: port-controller-number
168
+
type: u32
169
+
value: 150
170
+
171
+
# TODO: fill in the attributes in between
172
+
173
+
-
174
+
name: flash-update-overwrite-mask
175
+
type: bitfield32
176
+
enum: flash-overwrite
177
+
enum-as-flags: True
178
+
value: 152
586
179
-
587
180
name: reload-action
588
181
type: u8
589
-
value: 153
590
-
591
-
# TODO: fill in the attributes in between
592
-
182
+
enum: reload-action
183
+
-
184
+
name: reload-actions-performed
185
+
type: bitfield32
186
+
enum: reload-action
187
+
enum-as-flags: True
188
+
-
189
+
name: reload-limits
190
+
type: bitfield32
191
+
enum: reload-action
192
+
enum-as-flags: True
593
193
-
594
194
name: dev-stats
595
195
type: nest
596
-
value: 156
597
196
nested-attributes: dl-dev-stats
598
197
-
599
198
name: reload-stats
···
673
182
# TODO: fill in the attributes in between
674
183
675
184
-
185
+
name: port-pci-sf-number
186
+
type: u32
187
+
value: 164
188
+
189
+
# TODO: fill in the attributes in between
190
+
191
+
-
192
+
name: rate-tx-share
193
+
type: u64
194
+
value: 166
195
+
-
196
+
name: rate-tx-max
197
+
type: u64
198
+
-
676
199
name: rate-node-name
677
200
type: string
678
-
value: 168
201
+
-
202
+
name: rate-parent-node-name
203
+
type: string
679
204
680
205
# TODO: fill in the attributes in between
681
206
···
699
192
name: linecard-index
700
193
type: u32
701
194
value: 171
195
+
196
+
# TODO: fill in the attributes in between
197
+
198
+
-
199
+
name: linecard-type
200
+
type: string
201
+
value: 173
202
+
203
+
# TODO: fill in the attributes in between
204
+
205
+
-
206
+
name: selftests
207
+
type: nest
208
+
value: 176
209
+
nested-attributes: dl-selftest-id
210
+
-
211
+
name: rate-tx-priority
212
+
type: u32
213
+
-
214
+
name: rate-tx-weight
215
+
type: u32
216
+
-
217
+
name: region-direct
218
+
type: flag
702
219
703
220
-
704
221
name: dl-dev-stats
···
768
237
name: info-version-name
769
238
-
770
239
name: info-version-value
240
+
-
241
+
name: dl-port-function
242
+
name-prefix: devlink-port-fn-attr-
243
+
attr-max-name: devlink-port-function-attr-max
244
+
attributes:
245
+
-
246
+
name-prefix: devlink-port-function-attr-
247
+
name: hw-addr
248
+
type: binary
249
+
value: 1
250
+
-
251
+
name: state
252
+
type: u8
253
+
enum: port-fn-state
254
+
-
255
+
name: opstate
256
+
type: u8
257
+
enum: port-fn-opstate
258
+
-
259
+
name: caps
260
+
type: bitfield32
261
+
enum: port-fn-attr-cap
262
+
enum-as-flags: True
263
+
264
+
-
265
+
name: dl-dpipe-tables
266
+
subset-of: devlink
267
+
attributes:
268
+
-
269
+
name: dpipe-table
270
+
271
+
-
272
+
name: dl-dpipe-table
273
+
subset-of: devlink
274
+
attributes:
275
+
-
276
+
name: dpipe-table-name
277
+
-
278
+
name: dpipe-table-size
279
+
-
280
+
name: dpipe-table-name
281
+
-
282
+
name: dpipe-table-size
283
+
-
284
+
name: dpipe-table-matches
285
+
-
286
+
name: dpipe-table-actions
287
+
-
288
+
name: dpipe-table-counters-enabled
289
+
-
290
+
name: dpipe-table-resource-id
291
+
-
292
+
name: dpipe-table-resource-units
293
+
294
+
-
295
+
name: dl-dpipe-table-matches
296
+
subset-of: devlink
297
+
attributes:
298
+
-
299
+
name: dpipe-match
300
+
301
+
-
302
+
name: dl-dpipe-table-actions
303
+
subset-of: devlink
304
+
attributes:
305
+
-
306
+
name: dpipe-action
307
+
308
+
-
309
+
name: dl-dpipe-entries
310
+
subset-of: devlink
311
+
attributes:
312
+
-
313
+
name: dpipe-entry
314
+
315
+
-
316
+
name: dl-dpipe-entry
317
+
subset-of: devlink
318
+
attributes:
319
+
-
320
+
name: dpipe-entry-index
321
+
-
322
+
name: dpipe-entry-match-values
323
+
-
324
+
name: dpipe-entry-action-values
325
+
-
326
+
name: dpipe-entry-counter
327
+
328
+
-
329
+
name: dl-dpipe-entry-match-values
330
+
subset-of: devlink
331
+
attributes:
332
+
-
333
+
name: dpipe-match-value
334
+
335
+
-
336
+
name: dl-dpipe-entry-action-values
337
+
subset-of: devlink
338
+
attributes:
339
+
-
340
+
name: dpipe-action-value
341
+
342
+
-
343
+
name: dl-dpipe-match
344
+
subset-of: devlink
345
+
attributes:
346
+
-
347
+
name: dpipe-match-type
348
+
-
349
+
name: dpipe-header-id
350
+
-
351
+
name: dpipe-header-global
352
+
-
353
+
name: dpipe-header-index
354
+
-
355
+
name: dpipe-field-id
356
+
357
+
-
358
+
name: dl-dpipe-match-value
359
+
subset-of: devlink
360
+
attributes:
361
+
-
362
+
name: dpipe-match
363
+
-
364
+
name: dpipe-value
365
+
-
366
+
name: dpipe-value-mask
367
+
-
368
+
name: dpipe-value-mapping
369
+
370
+
-
371
+
name: dl-dpipe-action
372
+
subset-of: devlink
373
+
attributes:
374
+
-
375
+
name: dpipe-action-type
376
+
-
377
+
name: dpipe-header-id
378
+
-
379
+
name: dpipe-header-global
380
+
-
381
+
name: dpipe-header-index
382
+
-
383
+
name: dpipe-field-id
384
+
385
+
-
386
+
name: dl-dpipe-action-value
387
+
subset-of: devlink
388
+
attributes:
389
+
-
390
+
name: dpipe-action
391
+
-
392
+
name: dpipe-value
393
+
-
394
+
name: dpipe-value-mask
395
+
-
396
+
name: dpipe-value-mapping
397
+
398
+
-
399
+
name: dl-dpipe-headers
400
+
subset-of: devlink
401
+
attributes:
402
+
-
403
+
name: dpipe-header
404
+
405
+
-
406
+
name: dl-dpipe-header
407
+
subset-of: devlink
408
+
attributes:
409
+
-
410
+
name: dpipe-header-name
411
+
-
412
+
name: dpipe-header-id
413
+
-
414
+
name: dpipe-header-global
415
+
-
416
+
name: dpipe-header-fields
417
+
418
+
-
419
+
name: dl-dpipe-header-fields
420
+
subset-of: devlink
421
+
attributes:
422
+
-
423
+
name: dpipe-field
424
+
425
+
-
426
+
name: dl-dpipe-field
427
+
subset-of: devlink
428
+
attributes:
429
+
-
430
+
name: dpipe-field-name
431
+
-
432
+
name: dpipe-field-id
433
+
-
434
+
name: dpipe-field-bitwidth
435
+
-
436
+
name: dpipe-field-mapping-type
437
+
438
+
-
439
+
name: dl-resource
440
+
subset-of: devlink
441
+
attributes:
442
+
# -
443
+
# name: resource-list
444
+
# This is currently unsupported due to circular dependency
445
+
-
446
+
name: resource-name
447
+
-
448
+
name: resource-id
449
+
-
450
+
name: resource-size
451
+
-
452
+
name: resource-size-new
453
+
-
454
+
name: resource-size-valid
455
+
-
456
+
name: resource-size-min
457
+
-
458
+
name: resource-size-max
459
+
-
460
+
name: resource-size-gran
461
+
-
462
+
name: resource-unit
463
+
-
464
+
name: resource-occ
465
+
466
+
-
467
+
name: dl-resource-list
468
+
subset-of: devlink
469
+
attributes:
470
+
-
471
+
name: resource
472
+
473
+
-
474
+
name: dl-fmsg
475
+
subset-of: devlink
476
+
attributes:
477
+
-
478
+
name: fmsg-obj-nest-start
479
+
-
480
+
name: fmsg-pair-nest-start
481
+
-
482
+
name: fmsg-arr-nest-start
483
+
-
484
+
name: fmsg-nest-end
485
+
-
486
+
name: fmsg-obj-name
487
+
488
+
-
489
+
name: dl-selftest-id
490
+
name-prefix: devlink-attr-selftest-id-
491
+
attributes:
492
+
-
493
+
name: flash
494
+
type: flag
771
495
772
496
operations:
773
497
enum-model: directional
···
1031
245
name: get
1032
246
doc: Get devlink instances.
1033
247
attribute-set: devlink
1034
-
dont-validate:
1035
-
- strict
1036
-
- dump
1037
-
248
+
dont-validate: [ strict, dump ]
1038
249
do:
1039
250
pre: devlink-nl-pre-doit
1040
251
post: devlink-nl-post-doit
···
1046
263
- bus-name
1047
264
- dev-name
1048
265
- reload-failed
1049
-
- reload-action
1050
266
- dev-stats
1051
267
dump:
1052
268
reply: *get-reply
···
1054
272
name: port-get
1055
273
doc: Get devlink port instances.
1056
274
attribute-set: devlink
1057
-
dont-validate:
1058
-
- strict
1059
-
275
+
dont-validate: [ strict ]
1060
276
do:
1061
277
pre: devlink-nl-pre-doit-port
1062
278
post: devlink-nl-post-doit
···
1073
293
reply:
1074
294
value: 3 # due to a bug, port dump returns DEVLINK_CMD_NEW
1075
295
attributes: *port-id-attrs
296
+
-
297
+
name: port-set
298
+
doc: Set devlink port instances.
299
+
attribute-set: devlink
300
+
dont-validate: [ strict ]
301
+
flags: [ admin-perm ]
302
+
do:
303
+
pre: devlink-nl-pre-doit-port
304
+
post: devlink-nl-post-doit
305
+
request:
306
+
attributes:
307
+
- bus-name
308
+
- dev-name
309
+
- port-index
310
+
- port-type
311
+
- port-function
1076
312
1077
-
# TODO: fill in the operations in between
313
+
-
314
+
name: port-new
315
+
doc: Create devlink port instances.
316
+
attribute-set: devlink
317
+
dont-validate: [ strict ]
318
+
flags: [ admin-perm ]
319
+
do:
320
+
pre: devlink-nl-pre-doit
321
+
post: devlink-nl-post-doit
322
+
request:
323
+
attributes:
324
+
- bus-name
325
+
- dev-name
326
+
- port-index
327
+
- port-flavour
328
+
- port-pci-pf-number
329
+
- port-pci-sf-number
330
+
- port-controller-number
331
+
reply:
332
+
value: 7
333
+
attributes: *port-id-attrs
334
+
335
+
-
336
+
name: port-del
337
+
doc: Delete devlink port instances.
338
+
attribute-set: devlink
339
+
dont-validate: [ strict ]
340
+
flags: [ admin-perm ]
341
+
do:
342
+
pre: devlink-nl-pre-doit-port
343
+
post: devlink-nl-post-doit
344
+
request:
345
+
attributes: *port-id-attrs
346
+
347
+
-
348
+
name: port-split
349
+
doc: Split devlink port instances.
350
+
attribute-set: devlink
351
+
dont-validate: [ strict ]
352
+
flags: [ admin-perm ]
353
+
do:
354
+
pre: devlink-nl-pre-doit-port
355
+
post: devlink-nl-post-doit
356
+
request:
357
+
attributes:
358
+
- bus-name
359
+
- dev-name
360
+
- port-index
361
+
- port-split-count
362
+
363
+
-
364
+
name: port-unsplit
365
+
doc: Unplit devlink port instances.
366
+
attribute-set: devlink
367
+
dont-validate: [ strict ]
368
+
flags: [ admin-perm ]
369
+
do:
370
+
pre: devlink-nl-pre-doit-port
371
+
post: devlink-nl-post-doit
372
+
request:
373
+
attributes: *port-id-attrs
1078
374
1079
375
-
1080
376
name: sb-get
1081
377
doc: Get shared buffer instances.
1082
378
attribute-set: devlink
1083
-
dont-validate:
1084
-
- strict
1085
-
379
+
dont-validate: [ strict ]
1086
380
do:
1087
381
pre: devlink-nl-pre-doit
1088
382
post: devlink-nl-post-doit
···
1174
320
attributes: *dev-id-attrs
1175
321
reply: *sb-get-reply
1176
322
1177
-
# TODO: fill in the operations in between
1178
-
1179
323
-
1180
324
name: sb-pool-get
1181
325
doc: Get shared buffer pool instances.
1182
326
attribute-set: devlink
1183
-
dont-validate:
1184
-
- strict
1185
-
327
+
dont-validate: [ strict ]
1186
328
do:
1187
329
pre: devlink-nl-pre-doit
1188
330
post: devlink-nl-post-doit
···
1197
347
attributes: *dev-id-attrs
1198
348
reply: *sb-pool-get-reply
1199
349
1200
-
# TODO: fill in the operations in between
350
+
-
351
+
name: sb-pool-set
352
+
doc: Set shared buffer pool instances.
353
+
attribute-set: devlink
354
+
dont-validate: [ strict ]
355
+
flags: [ admin-perm ]
356
+
do:
357
+
pre: devlink-nl-pre-doit
358
+
post: devlink-nl-post-doit
359
+
request:
360
+
attributes:
361
+
- bus-name
362
+
- dev-name
363
+
- sb-index
364
+
- sb-pool-index
365
+
- sb-pool-threshold-type
366
+
- sb-pool-size
1201
367
1202
368
-
1203
369
name: sb-port-pool-get
1204
370
doc: Get shared buffer port-pool combinations and threshold.
1205
371
attribute-set: devlink
1206
-
dont-validate:
1207
-
- strict
1208
-
372
+
dont-validate: [ strict ]
1209
373
do:
1210
374
pre: devlink-nl-pre-doit-port
1211
375
post: devlink-nl-post-doit
···
1239
375
attributes: *dev-id-attrs
1240
376
reply: *sb-port-pool-get-reply
1241
377
1242
-
# TODO: fill in the operations in between
378
+
-
379
+
name: sb-port-pool-set
380
+
doc: Set shared buffer port-pool combinations and threshold.
381
+
attribute-set: devlink
382
+
dont-validate: [ strict ]
383
+
flags: [ admin-perm ]
384
+
do:
385
+
pre: devlink-nl-pre-doit-port
386
+
post: devlink-nl-post-doit
387
+
request:
388
+
attributes:
389
+
- bus-name
390
+
- dev-name
391
+
- port-index
392
+
- sb-index
393
+
- sb-pool-index
394
+
- sb-threshold
1243
395
1244
396
-
1245
397
name: sb-tc-pool-bind-get
1246
398
doc: Get shared buffer port-TC to pool bindings and threshold.
1247
399
attribute-set: devlink
1248
-
dont-validate:
1249
-
- strict
1250
-
400
+
dont-validate: [ strict ]
1251
401
do:
1252
402
pre: devlink-nl-pre-doit-port
1253
403
post: devlink-nl-post-doit
···
1282
404
attributes: *dev-id-attrs
1283
405
reply: *sb-tc-pool-bind-get-reply
1284
406
1285
-
# TODO: fill in the operations in between
407
+
-
408
+
name: sb-tc-pool-bind-set
409
+
doc: Set shared buffer port-TC to pool bindings and threshold.
410
+
attribute-set: devlink
411
+
dont-validate: [ strict ]
412
+
flags: [ admin-perm ]
413
+
do:
414
+
pre: devlink-nl-pre-doit-port
415
+
post: devlink-nl-post-doit
416
+
request:
417
+
attributes:
418
+
- bus-name
419
+
- dev-name
420
+
- port-index
421
+
- sb-index
422
+
- sb-pool-index
423
+
- sb-pool-type
424
+
- sb-tc-index
425
+
- sb-threshold
426
+
427
+
-
428
+
name: sb-occ-snapshot
429
+
doc: Take occupancy snapshot of shared buffer.
430
+
attribute-set: devlink
431
+
dont-validate: [ strict ]
432
+
flags: [ admin-perm ]
433
+
do:
434
+
pre: devlink-nl-pre-doit
435
+
post: devlink-nl-post-doit
436
+
request:
437
+
value: 27
438
+
attributes:
439
+
- bus-name
440
+
- dev-name
441
+
- sb-index
442
+
443
+
-
444
+
name: sb-occ-max-clear
445
+
doc: Clear occupancy watermarks of shared buffer.
446
+
attribute-set: devlink
447
+
dont-validate: [ strict ]
448
+
flags: [ admin-perm ]
449
+
do:
450
+
pre: devlink-nl-pre-doit
451
+
post: devlink-nl-post-doit
452
+
request:
453
+
attributes:
454
+
- bus-name
455
+
- dev-name
456
+
- sb-index
457
+
458
+
-
459
+
name: eswitch-get
460
+
doc: Get eswitch attributes.
461
+
attribute-set: devlink
462
+
dont-validate: [ strict ]
463
+
flags: [ admin-perm ]
464
+
do:
465
+
pre: devlink-nl-pre-doit
466
+
post: devlink-nl-post-doit
467
+
request:
468
+
attributes: *dev-id-attrs
469
+
reply:
470
+
value: 29
471
+
attributes: &eswitch-attrs
472
+
- bus-name
473
+
- dev-name
474
+
- eswitch-mode
475
+
- eswitch-inline-mode
476
+
- eswitch-encap-mode
477
+
478
+
-
479
+
name: eswitch-set
480
+
doc: Set eswitch attributes.
481
+
attribute-set: devlink
482
+
dont-validate: [ strict ]
483
+
flags: [ admin-perm ]
484
+
do:
485
+
pre: devlink-nl-pre-doit
486
+
post: devlink-nl-post-doit
487
+
request:
488
+
attributes: *eswitch-attrs
489
+
490
+
-
491
+
name: dpipe-table-get
492
+
doc: Get dpipe table attributes.
493
+
attribute-set: devlink
494
+
dont-validate: [ strict ]
495
+
do:
496
+
pre: devlink-nl-pre-doit
497
+
post: devlink-nl-post-doit
498
+
request:
499
+
attributes:
500
+
- bus-name
501
+
- dev-name
502
+
- dpipe-table-name
503
+
reply:
504
+
value: 31
505
+
attributes:
506
+
- bus-name
507
+
- dev-name
508
+
- dpipe-tables
509
+
510
+
-
511
+
name: dpipe-entries-get
512
+
doc: Get dpipe entries attributes.
513
+
attribute-set: devlink
514
+
dont-validate: [ strict ]
515
+
do:
516
+
pre: devlink-nl-pre-doit
517
+
post: devlink-nl-post-doit
518
+
request:
519
+
attributes:
520
+
- bus-name
521
+
- dev-name
522
+
- dpipe-table-name
523
+
reply:
524
+
attributes:
525
+
- bus-name
526
+
- dev-name
527
+
- dpipe-entries
528
+
529
+
-
530
+
name: dpipe-headers-get
531
+
doc: Get dpipe headers attributes.
532
+
attribute-set: devlink
533
+
dont-validate: [ strict ]
534
+
do:
535
+
pre: devlink-nl-pre-doit
536
+
post: devlink-nl-post-doit
537
+
request:
538
+
attributes:
539
+
- bus-name
540
+
- dev-name
541
+
reply:
542
+
attributes:
543
+
- bus-name
544
+
- dev-name
545
+
- dpipe-headers
546
+
547
+
-
548
+
name: dpipe-table-counters-set
549
+
doc: Set dpipe counter attributes.
550
+
attribute-set: devlink
551
+
dont-validate: [ strict ]
552
+
flags: [ admin-perm ]
553
+
do:
554
+
pre: devlink-nl-pre-doit
555
+
post: devlink-nl-post-doit
556
+
request:
557
+
attributes:
558
+
- bus-name
559
+
- dev-name
560
+
- dpipe-table-name
561
+
- dpipe-table-counters-enabled
562
+
563
+
-
564
+
name: resource-set
565
+
doc: Set resource attributes.
566
+
attribute-set: devlink
567
+
dont-validate: [ strict ]
568
+
flags: [ admin-perm ]
569
+
do:
570
+
pre: devlink-nl-pre-doit
571
+
post: devlink-nl-post-doit
572
+
request:
573
+
attributes:
574
+
- bus-name
575
+
- dev-name
576
+
- resource-id
577
+
- resource-size
578
+
579
+
-
580
+
name: resource-dump
581
+
doc: Get resource attributes.
582
+
attribute-set: devlink
583
+
dont-validate: [ strict ]
584
+
do:
585
+
pre: devlink-nl-pre-doit
586
+
post: devlink-nl-post-doit
587
+
request:
588
+
attributes:
589
+
- bus-name
590
+
- dev-name
591
+
reply:
592
+
value: 36
593
+
attributes:
594
+
- bus-name
595
+
- dev-name
596
+
- resource-list
597
+
598
+
-
599
+
name: reload
600
+
doc: Reload devlink.
601
+
attribute-set: devlink
602
+
dont-validate: [ strict ]
603
+
flags: [ admin-perm ]
604
+
do:
605
+
pre: devlink-nl-pre-doit
606
+
post: devlink-nl-post-doit
607
+
request:
608
+
attributes:
609
+
- bus-name
610
+
- dev-name
611
+
- reload-action
612
+
- reload-limits
613
+
- netns-pid
614
+
- netns-fd
615
+
- netns-id
616
+
reply:
617
+
attributes:
618
+
- bus-name
619
+
- dev-name
620
+
- reload-actions-performed
1286
621
1287
622
-
1288
623
name: param-get
1289
624
doc: Get param instances.
1290
625
attribute-set: devlink
1291
-
dont-validate:
1292
-
- strict
1293
-
626
+
dont-validate: [ strict ]
1294
627
do:
1295
628
pre: devlink-nl-pre-doit
1296
629
post: devlink-nl-post-doit
1297
630
request:
1298
-
value: 38
1299
631
attributes: ¶m-id-attrs
1300
632
- bus-name
1301
633
- dev-name
1302
634
- param-name
1303
635
reply: ¶m-get-reply
1304
-
value: 38
1305
636
attributes: *param-id-attrs
1306
637
dump:
1307
638
request:
1308
639
attributes: *dev-id-attrs
1309
640
reply: *param-get-reply
1310
641
1311
-
# TODO: fill in the operations in between
642
+
-
643
+
name: param-set
644
+
doc: Set param instances.
645
+
attribute-set: devlink
646
+
dont-validate: [ strict ]
647
+
flags: [ admin-perm ]
648
+
do:
649
+
pre: devlink-nl-pre-doit
650
+
post: devlink-nl-post-doit
651
+
request:
652
+
attributes:
653
+
- bus-name
654
+
- dev-name
655
+
- param-name
656
+
- param-type
657
+
# param-value-data is missing here as the type is variable
658
+
- param-value-cmode
1312
659
1313
660
-
1314
661
name: region-get
1315
662
doc: Get region instances.
1316
663
attribute-set: devlink
1317
-
dont-validate:
1318
-
- strict
1319
-
664
+
dont-validate: [ strict ]
1320
665
do:
1321
666
pre: devlink-nl-pre-doit-port-optional
1322
667
post: devlink-nl-post-doit
···
1558
457
attributes: *dev-id-attrs
1559
458
reply: *region-get-reply
1560
459
1561
-
# TODO: fill in the operations in between
460
+
-
461
+
name: region-new
462
+
doc: Create region snapshot.
463
+
attribute-set: devlink
464
+
dont-validate: [ strict ]
465
+
flags: [ admin-perm ]
466
+
do:
467
+
pre: devlink-nl-pre-doit-port-optional
468
+
post: devlink-nl-post-doit
469
+
request:
470
+
value: 44
471
+
attributes: ®ion-snapshot-id-attrs
472
+
- bus-name
473
+
- dev-name
474
+
- port-index
475
+
- region-name
476
+
- region-snapshot-id
477
+
reply:
478
+
value: 44
479
+
attributes: *region-snapshot-id-attrs
480
+
481
+
-
482
+
name: region-del
483
+
doc: Delete region snapshot.
484
+
attribute-set: devlink
485
+
dont-validate: [ strict ]
486
+
flags: [ admin-perm ]
487
+
do:
488
+
pre: devlink-nl-pre-doit-port-optional
489
+
post: devlink-nl-post-doit
490
+
request:
491
+
attributes: *region-snapshot-id-attrs
492
+
493
+
-
494
+
name: region-read
495
+
doc: Read region data.
496
+
attribute-set: devlink
497
+
dont-validate: [ dump-strict ]
498
+
flags: [ admin-perm ]
499
+
dump:
500
+
request:
501
+
attributes:
502
+
- bus-name
503
+
- dev-name
504
+
- port-index
505
+
- region-name
506
+
- region-snapshot-id
507
+
- region-direct
508
+
- region-chunk-addr
509
+
- region-chunk-len
510
+
reply:
511
+
value: 46
512
+
attributes:
513
+
- bus-name
514
+
- dev-name
515
+
- port-index
516
+
- region-name
517
+
518
+
-
519
+
name: port-param-get
520
+
doc: Get port param instances.
521
+
attribute-set: devlink
522
+
dont-validate: [ strict, dump-strict ]
523
+
do:
524
+
pre: devlink-nl-pre-doit-port
525
+
post: devlink-nl-post-doit
526
+
request:
527
+
attributes: *port-id-attrs
528
+
reply:
529
+
attributes: *port-id-attrs
530
+
dump:
531
+
reply:
532
+
attributes: *port-id-attrs
533
+
534
+
-
535
+
name: port-param-set
536
+
doc: Set port param instances.
537
+
attribute-set: devlink
538
+
dont-validate: [ strict ]
539
+
flags: [ admin-perm ]
540
+
do:
541
+
pre: devlink-nl-pre-doit-port
542
+
post: devlink-nl-post-doit
543
+
request:
544
+
attributes: *port-id-attrs
1562
545
1563
546
-
1564
547
name: info-get
1565
548
doc: Get device information, like driver name, hardware and firmware versions etc.
1566
549
attribute-set: devlink
1567
-
dont-validate:
1568
-
- strict
1569
-
- dump
1570
-
550
+
dont-validate: [ strict, dump ]
1571
551
do:
1572
552
pre: devlink-nl-pre-doit
1573
553
post: devlink-nl-post-doit
···
1672
490
name: health-reporter-get
1673
491
doc: Get health reporter instances.
1674
492
attribute-set: devlink
1675
-
dont-validate:
1676
-
- strict
1677
-
493
+
dont-validate: [ strict ]
1678
494
do:
1679
495
pre: devlink-nl-pre-doit-port-optional
1680
496
post: devlink-nl-post-doit
···
1689
509
attributes: *port-id-attrs
1690
510
reply: *health-reporter-get-reply
1691
511
1692
-
# TODO: fill in the operations in between
512
+
-
513
+
name: health-reporter-set
514
+
doc: Set health reporter instances.
515
+
attribute-set: devlink
516
+
dont-validate: [ strict ]
517
+
flags: [ admin-perm ]
518
+
do:
519
+
pre: devlink-nl-pre-doit-port-optional
520
+
post: devlink-nl-post-doit
521
+
request:
522
+
attributes:
523
+
- bus-name
524
+
- dev-name
525
+
- port-index
526
+
- health-reporter-name
527
+
- health-reporter-graceful-period
528
+
- health-reporter-auto-recover
529
+
- health-reporter-auto-dump
530
+
531
+
-
532
+
name: health-reporter-recover
533
+
doc: Recover health reporter instances.
534
+
attribute-set: devlink
535
+
dont-validate: [ strict ]
536
+
flags: [ admin-perm ]
537
+
do:
538
+
pre: devlink-nl-pre-doit-port-optional
539
+
post: devlink-nl-post-doit
540
+
request:
541
+
attributes: *health-reporter-id-attrs
542
+
543
+
-
544
+
name: health-reporter-diagnose
545
+
doc: Diagnose health reporter instances.
546
+
attribute-set: devlink
547
+
dont-validate: [ strict ]
548
+
flags: [ admin-perm ]
549
+
do:
550
+
pre: devlink-nl-pre-doit-port-optional
551
+
post: devlink-nl-post-doit
552
+
request:
553
+
attributes: *health-reporter-id-attrs
554
+
555
+
-
556
+
name: health-reporter-dump-get
557
+
doc: Dump health reporter instances.
558
+
attribute-set: devlink
559
+
dont-validate: [ dump-strict ]
560
+
flags: [ admin-perm ]
561
+
dump:
562
+
request:
563
+
attributes: *health-reporter-id-attrs
564
+
reply:
565
+
value: 56
566
+
attributes:
567
+
- fmsg
568
+
569
+
-
570
+
name: health-reporter-dump-clear
571
+
doc: Clear dump of health reporter instances.
572
+
attribute-set: devlink
573
+
dont-validate: [ strict ]
574
+
flags: [ admin-perm ]
575
+
do:
576
+
pre: devlink-nl-pre-doit-port-optional
577
+
post: devlink-nl-post-doit
578
+
request:
579
+
attributes: *health-reporter-id-attrs
580
+
581
+
-
582
+
name: flash-update
583
+
doc: Flash update devlink instances.
584
+
attribute-set: devlink
585
+
dont-validate: [ strict ]
586
+
flags: [ admin-perm ]
587
+
do:
588
+
pre: devlink-nl-pre-doit
589
+
post: devlink-nl-post-doit
590
+
request:
591
+
attributes:
592
+
- bus-name
593
+
- dev-name
594
+
- flash-update-file-name
595
+
- flash-update-component
596
+
- flash-update-overwrite-mask
1693
597
1694
598
-
1695
599
name: trap-get
1696
600
doc: Get trap instances.
1697
601
attribute-set: devlink
1698
-
dont-validate:
1699
-
- strict
1700
-
602
+
dont-validate: [ strict ]
1701
603
do:
1702
604
pre: devlink-nl-pre-doit
1703
605
post: devlink-nl-post-doit
···
1797
535
attributes: *dev-id-attrs
1798
536
reply: *trap-get-reply
1799
537
1800
-
# TODO: fill in the operations in between
538
+
-
539
+
name: trap-set
540
+
doc: Set trap instances.
541
+
attribute-set: devlink
542
+
dont-validate: [ strict ]
543
+
flags: [ admin-perm ]
544
+
do:
545
+
pre: devlink-nl-pre-doit
546
+
post: devlink-nl-post-doit
547
+
request:
548
+
attributes:
549
+
- bus-name
550
+
- dev-name
551
+
- trap-name
552
+
- trap-action
1801
553
1802
554
-
1803
555
name: trap-group-get
1804
556
doc: Get trap group instances.
1805
557
attribute-set: devlink
1806
-
dont-validate:
1807
-
- strict
1808
-
558
+
dont-validate: [ strict ]
1809
559
do:
1810
560
pre: devlink-nl-pre-doit
1811
561
post: devlink-nl-post-doit
···
1835
561
attributes: *dev-id-attrs
1836
562
reply: *trap-group-get-reply
1837
563
1838
-
# TODO: fill in the operations in between
564
+
-
565
+
name: trap-group-set
566
+
doc: Set trap group instances.
567
+
attribute-set: devlink
568
+
dont-validate: [ strict ]
569
+
flags: [ admin-perm ]
570
+
do:
571
+
pre: devlink-nl-pre-doit
572
+
post: devlink-nl-post-doit
573
+
request:
574
+
attributes:
575
+
- bus-name
576
+
- dev-name
577
+
- trap-group-name
578
+
- trap-action
579
+
- trap-policer-id
1839
580
1840
581
-
1841
582
name: trap-policer-get
1842
583
doc: Get trap policer instances.
1843
584
attribute-set: devlink
1844
-
dont-validate:
1845
-
- strict
1846
-
585
+
dont-validate: [ strict ]
1847
586
do:
1848
587
pre: devlink-nl-pre-doit
1849
588
post: devlink-nl-post-doit
···
1874
587
attributes: *dev-id-attrs
1875
588
reply: *trap-policer-get-reply
1876
589
1877
-
# TODO: fill in the operations in between
590
+
-
591
+
name: trap-policer-set
592
+
doc: Get trap policer instances.
593
+
attribute-set: devlink
594
+
dont-validate: [ strict ]
595
+
flags: [ admin-perm ]
596
+
do:
597
+
pre: devlink-nl-pre-doit
598
+
post: devlink-nl-post-doit
599
+
request:
600
+
attributes:
601
+
- bus-name
602
+
- dev-name
603
+
- trap-policer-id
604
+
- trap-policer-rate
605
+
- trap-policer-burst
606
+
607
+
-
608
+
name: health-reporter-test
609
+
doc: Test health reporter instances.
610
+
attribute-set: devlink
611
+
dont-validate: [ strict ]
612
+
flags: [ admin-perm ]
613
+
do:
614
+
pre: devlink-nl-pre-doit-port-optional
615
+
post: devlink-nl-post-doit
616
+
request:
617
+
value: 73
618
+
attributes: *health-reporter-id-attrs
1878
619
1879
620
-
1880
621
name: rate-get
1881
622
doc: Get rate instances.
1882
623
attribute-set: devlink
1883
-
dont-validate:
1884
-
- strict
1885
-
624
+
dont-validate: [ strict ]
1886
625
do:
1887
626
pre: devlink-nl-pre-doit
1888
627
post: devlink-nl-post-doit
···
1927
614
attributes: *dev-id-attrs
1928
615
reply: *rate-get-reply
1929
616
1930
-
# TODO: fill in the operations in between
617
+
-
618
+
name: rate-set
619
+
doc: Set rate instances.
620
+
attribute-set: devlink
621
+
dont-validate: [ strict ]
622
+
flags: [ admin-perm ]
623
+
do:
624
+
pre: devlink-nl-pre-doit
625
+
post: devlink-nl-post-doit
626
+
request:
627
+
attributes:
628
+
- bus-name
629
+
- dev-name
630
+
- rate-node-name
631
+
- rate-tx-share
632
+
- rate-tx-max
633
+
- rate-tx-priority
634
+
- rate-tx-weight
635
+
- rate-parent-node-name
636
+
637
+
-
638
+
name: rate-new
639
+
doc: Create rate instances.
640
+
attribute-set: devlink
641
+
dont-validate: [ strict ]
642
+
flags: [ admin-perm ]
643
+
do:
644
+
pre: devlink-nl-pre-doit
645
+
post: devlink-nl-post-doit
646
+
request:
647
+
attributes:
648
+
- bus-name
649
+
- dev-name
650
+
- rate-node-name
651
+
- rate-tx-share
652
+
- rate-tx-max
653
+
- rate-tx-priority
654
+
- rate-tx-weight
655
+
- rate-parent-node-name
656
+
657
+
-
658
+
name: rate-del
659
+
doc: Delete rate instances.
660
+
attribute-set: devlink
661
+
dont-validate: [ strict ]
662
+
flags: [ admin-perm ]
663
+
do:
664
+
pre: devlink-nl-pre-doit
665
+
post: devlink-nl-post-doit
666
+
request:
667
+
attributes:
668
+
- bus-name
669
+
- dev-name
670
+
- rate-node-name
1931
671
1932
672
-
1933
673
name: linecard-get
1934
674
doc: Get line card instances.
1935
675
attribute-set: devlink
1936
-
dont-validate:
1937
-
- strict
1938
-
676
+
dont-validate: [ strict ]
1939
677
do:
1940
678
pre: devlink-nl-pre-doit
1941
679
post: devlink-nl-post-doit
···
2004
640
attributes: *dev-id-attrs
2005
641
reply: *linecard-get-reply
2006
642
2007
-
# TODO: fill in the operations in between
643
+
-
644
+
name: linecard-set
645
+
doc: Set line card instances.
646
+
attribute-set: devlink
647
+
dont-validate: [ strict ]
648
+
flags: [ admin-perm ]
649
+
do:
650
+
pre: devlink-nl-pre-doit
651
+
post: devlink-nl-post-doit
652
+
request:
653
+
attributes:
654
+
- bus-name
655
+
- dev-name
656
+
- linecard-index
657
+
- linecard-type
2008
658
2009
659
-
2010
660
name: selftests-get
2011
661
doc: Get device selftest instances.
2012
662
attribute-set: devlink
2013
-
dont-validate:
2014
-
- strict
2015
-
- dump
2016
-
663
+
dont-validate: [ strict, dump ]
2017
664
do:
2018
665
pre: devlink-nl-pre-doit
2019
666
post: devlink-nl-post-doit
···
2036
661
attributes: *dev-id-attrs
2037
662
dump:
2038
663
reply: *selftests-get-reply
664
+
665
+
-
666
+
name: selftests-run
667
+
doc: Run device selftest instances.
668
+
attribute-set: devlink
669
+
dont-validate: [ strict ]
670
+
flags: [ admin-perm ]
671
+
do:
672
+
pre: devlink-nl-pre-doit
673
+
post: devlink-nl-post-doit
674
+
request:
675
+
attributes:
676
+
- bus-name
677
+
- dev-name
678
+
- selftests
+1
-1
Documentation/userspace-api/netlink/genetlink-legacy.rst
+1
-1
Documentation/userspace-api/netlink/genetlink-legacy.rst
···
182
182
183
183
- ``name`` - The attribute name of the struct member
184
184
- ``type`` - One of the scalar types ``u8``, ``u16``, ``u32``, ``u64``, ``s8``,
185
-
``s16``, ``s32``, ``s64``, ``string`` or ``binary``.
185
+
``s16``, ``s32``, ``s64``, ``string``, ``binary`` or ``bitfield32``.
186
186
- ``byte-order`` - ``big-endian`` or ``little-endian``
187
187
- ``doc``, ``enum``, ``enum-as-flags``, ``display-hint`` - Same as for
188
188
:ref:`attribute definitions <attribute_properties>`
+1
-1
include/uapi/linux/devlink.h
+1
-1
include/uapi/linux/devlink.h
+5
-5
net/devlink/dev.c
+5
-5
net/devlink/dev.c
···
492
492
return -EMSGSIZE;
493
493
}
494
494
495
-
int devlink_nl_cmd_reload(struct sk_buff *skb, struct genl_info *info)
495
+
int devlink_nl_reload_doit(struct sk_buff *skb, struct genl_info *info)
496
496
{
497
497
struct devlink *devlink = info->user_ptr[0];
498
498
enum devlink_reload_action action;
···
658
658
return err;
659
659
}
660
660
661
-
int devlink_nl_cmd_eswitch_get_doit(struct sk_buff *skb, struct genl_info *info)
661
+
int devlink_nl_eswitch_get_doit(struct sk_buff *skb, struct genl_info *info)
662
662
{
663
663
struct devlink *devlink = info->user_ptr[0];
664
664
struct sk_buff *msg;
···
679
679
return genlmsg_reply(msg, info);
680
680
}
681
681
682
-
int devlink_nl_cmd_eswitch_set_doit(struct sk_buff *skb, struct genl_info *info)
682
+
int devlink_nl_eswitch_set_doit(struct sk_buff *skb, struct genl_info *info)
683
683
{
684
684
struct devlink *devlink = info->user_ptr[0];
685
685
const struct devlink_ops *ops = devlink->ops;
···
1108
1108
return 0;
1109
1109
}
1110
1110
1111
-
int devlink_nl_cmd_flash_update(struct sk_buff *skb, struct genl_info *info)
1111
+
int devlink_nl_flash_update_doit(struct sk_buff *skb, struct genl_info *info)
1112
1112
{
1113
1113
struct nlattr *nla_overwrite_mask, *nla_file_name;
1114
1114
struct devlink_flash_update_params params = {};
···
1351
1351
[DEVLINK_ATTR_SELFTEST_ID_FLASH] = { .type = NLA_FLAG },
1352
1352
};
1353
1353
1354
-
int devlink_nl_cmd_selftests_run(struct sk_buff *skb, struct genl_info *info)
1354
+
int devlink_nl_selftests_run_doit(struct sk_buff *skb, struct genl_info *info)
1355
1355
{
1356
1356
struct nlattr *tb[DEVLINK_ATTR_SELFTEST_ID_MAX + 1];
1357
1357
struct devlink *devlink = info->user_ptr[0];
-64
net/devlink/devl_internal.h
-64
net/devlink/devl_internal.h
···
227
227
228
228
/* Linecards */
229
229
unsigned int devlink_linecard_index(struct devlink_linecard *linecard);
230
-
231
-
/* Devlink nl cmds */
232
-
int devlink_nl_cmd_reload(struct sk_buff *skb, struct genl_info *info);
233
-
int devlink_nl_cmd_eswitch_get_doit(struct sk_buff *skb, struct genl_info *info);
234
-
int devlink_nl_cmd_eswitch_set_doit(struct sk_buff *skb, struct genl_info *info);
235
-
int devlink_nl_cmd_flash_update(struct sk_buff *skb, struct genl_info *info);
236
-
int devlink_nl_cmd_selftests_run(struct sk_buff *skb, struct genl_info *info);
237
-
int devlink_nl_cmd_port_set_doit(struct sk_buff *skb, struct genl_info *info);
238
-
int devlink_nl_cmd_port_split_doit(struct sk_buff *skb, struct genl_info *info);
239
-
int devlink_nl_cmd_port_unsplit_doit(struct sk_buff *skb,
240
-
struct genl_info *info);
241
-
int devlink_nl_cmd_port_new_doit(struct sk_buff *skb, struct genl_info *info);
242
-
int devlink_nl_cmd_port_del_doit(struct sk_buff *skb, struct genl_info *info);
243
-
int devlink_nl_cmd_sb_pool_set_doit(struct sk_buff *skb, struct genl_info *info);
244
-
int devlink_nl_cmd_sb_port_pool_set_doit(struct sk_buff *skb,
245
-
struct genl_info *info);
246
-
int devlink_nl_cmd_sb_tc_pool_bind_set_doit(struct sk_buff *skb,
247
-
struct genl_info *info);
248
-
int devlink_nl_cmd_sb_occ_snapshot_doit(struct sk_buff *skb,
249
-
struct genl_info *info);
250
-
int devlink_nl_cmd_sb_occ_max_clear_doit(struct sk_buff *skb,
251
-
struct genl_info *info);
252
-
int devlink_nl_cmd_dpipe_table_get(struct sk_buff *skb, struct genl_info *info);
253
-
int devlink_nl_cmd_dpipe_entries_get(struct sk_buff *skb,
254
-
struct genl_info *info);
255
-
int devlink_nl_cmd_dpipe_headers_get(struct sk_buff *skb,
256
-
struct genl_info *info);
257
-
int devlink_nl_cmd_dpipe_table_counters_set(struct sk_buff *skb,
258
-
struct genl_info *info);
259
-
int devlink_nl_cmd_resource_set(struct sk_buff *skb, struct genl_info *info);
260
-
int devlink_nl_cmd_resource_dump(struct sk_buff *skb, struct genl_info *info);
261
-
int devlink_nl_cmd_param_set_doit(struct sk_buff *skb, struct genl_info *info);
262
-
int devlink_nl_cmd_port_param_get_dumpit(struct sk_buff *msg,
263
-
struct netlink_callback *cb);
264
-
int devlink_nl_cmd_port_param_get_doit(struct sk_buff *skb,
265
-
struct genl_info *info);
266
-
int devlink_nl_cmd_port_param_set_doit(struct sk_buff *skb,
267
-
struct genl_info *info);
268
-
int devlink_nl_cmd_region_new(struct sk_buff *skb, struct genl_info *info);
269
-
int devlink_nl_cmd_region_del(struct sk_buff *skb, struct genl_info *info);
270
-
int devlink_nl_cmd_region_read_dumpit(struct sk_buff *skb,
271
-
struct netlink_callback *cb);
272
-
int devlink_nl_cmd_health_reporter_set_doit(struct sk_buff *skb,
273
-
struct genl_info *info);
274
-
int devlink_nl_cmd_health_reporter_recover_doit(struct sk_buff *skb,
275
-
struct genl_info *info);
276
-
int devlink_nl_cmd_health_reporter_diagnose_doit(struct sk_buff *skb,
277
-
struct genl_info *info);
278
-
int devlink_nl_cmd_health_reporter_dump_get_dumpit(struct sk_buff *skb,
279
-
struct netlink_callback *cb);
280
-
int devlink_nl_cmd_health_reporter_dump_clear_doit(struct sk_buff *skb,
281
-
struct genl_info *info);
282
-
int devlink_nl_cmd_health_reporter_test_doit(struct sk_buff *skb,
283
-
struct genl_info *info);
284
-
int devlink_nl_cmd_trap_set_doit(struct sk_buff *skb, struct genl_info *info);
285
-
int devlink_nl_cmd_trap_group_set_doit(struct sk_buff *skb,
286
-
struct genl_info *info);
287
-
int devlink_nl_cmd_trap_policer_set_doit(struct sk_buff *skb,
288
-
struct genl_info *info);
289
-
int devlink_nl_cmd_rate_set_doit(struct sk_buff *skb, struct genl_info *info);
290
-
int devlink_nl_cmd_rate_new_doit(struct sk_buff *skb, struct genl_info *info);
291
-
int devlink_nl_cmd_rate_del_doit(struct sk_buff *skb, struct genl_info *info);
292
-
int devlink_nl_cmd_linecard_set_doit(struct sk_buff *skb,
293
-
struct genl_info *info);
+7
-7
net/devlink/dpipe.c
+7
-7
net/devlink/dpipe.c
···
289
289
return err;
290
290
}
291
291
292
-
int devlink_nl_cmd_dpipe_table_get(struct sk_buff *skb, struct genl_info *info)
292
+
int devlink_nl_dpipe_table_get_doit(struct sk_buff *skb, struct genl_info *info)
293
293
{
294
294
struct devlink *devlink = info->user_ptr[0];
295
295
const char *table_name = NULL;
···
562
562
return genlmsg_reply(dump_ctx.skb, info);
563
563
}
564
564
565
-
int devlink_nl_cmd_dpipe_entries_get(struct sk_buff *skb,
566
-
struct genl_info *info)
565
+
int devlink_nl_dpipe_entries_get_doit(struct sk_buff *skb,
566
+
struct genl_info *info)
567
567
{
568
568
struct devlink *devlink = info->user_ptr[0];
569
569
struct devlink_dpipe_table *table;
···
712
712
return err;
713
713
}
714
714
715
-
int devlink_nl_cmd_dpipe_headers_get(struct sk_buff *skb,
716
-
struct genl_info *info)
715
+
int devlink_nl_dpipe_headers_get_doit(struct sk_buff *skb,
716
+
struct genl_info *info)
717
717
{
718
718
struct devlink *devlink = info->user_ptr[0];
719
719
···
746
746
return 0;
747
747
}
748
748
749
-
int devlink_nl_cmd_dpipe_table_counters_set(struct sk_buff *skb,
750
-
struct genl_info *info)
749
+
int devlink_nl_dpipe_table_counters_set_doit(struct sk_buff *skb,
750
+
struct genl_info *info)
751
751
{
752
752
struct devlink *devlink = info->user_ptr[0];
753
753
const char *table_name;
+12
-12
net/devlink/health.c
+12
-12
net/devlink/health.c
···
452
452
devlink_nl_health_reporter_get_dump_one);
453
453
}
454
454
455
-
int devlink_nl_cmd_health_reporter_set_doit(struct sk_buff *skb,
456
-
struct genl_info *info)
455
+
int devlink_nl_health_reporter_set_doit(struct sk_buff *skb,
456
+
struct genl_info *info)
457
457
{
458
458
struct devlink *devlink = info->user_ptr[0];
459
459
struct devlink_health_reporter *reporter;
···
655
655
}
656
656
EXPORT_SYMBOL_GPL(devlink_health_reporter_state_update);
657
657
658
-
int devlink_nl_cmd_health_reporter_recover_doit(struct sk_buff *skb,
659
-
struct genl_info *info)
658
+
int devlink_nl_health_reporter_recover_doit(struct sk_buff *skb,
659
+
struct genl_info *info)
660
660
{
661
661
struct devlink *devlink = info->user_ptr[0];
662
662
struct devlink_health_reporter *reporter;
···
1108
1108
return err;
1109
1109
}
1110
1110
1111
-
int devlink_nl_cmd_health_reporter_diagnose_doit(struct sk_buff *skb,
1112
-
struct genl_info *info)
1111
+
int devlink_nl_health_reporter_diagnose_doit(struct sk_buff *skb,
1112
+
struct genl_info *info)
1113
1113
{
1114
1114
struct devlink *devlink = info->user_ptr[0];
1115
1115
struct devlink_health_reporter *reporter;
···
1163
1163
return reporter;
1164
1164
}
1165
1165
1166
-
int devlink_nl_cmd_health_reporter_dump_get_dumpit(struct sk_buff *skb,
1167
-
struct netlink_callback *cb)
1166
+
int devlink_nl_health_reporter_dump_get_dumpit(struct sk_buff *skb,
1167
+
struct netlink_callback *cb)
1168
1168
{
1169
1169
struct devlink_nl_dump_state *state = devlink_dump_state(cb);
1170
1170
struct devlink_health_reporter *reporter;
···
1202
1202
return err;
1203
1203
}
1204
1204
1205
-
int devlink_nl_cmd_health_reporter_dump_clear_doit(struct sk_buff *skb,
1206
-
struct genl_info *info)
1205
+
int devlink_nl_health_reporter_dump_clear_doit(struct sk_buff *skb,
1206
+
struct genl_info *info)
1207
1207
{
1208
1208
struct devlink *devlink = info->user_ptr[0];
1209
1209
struct devlink_health_reporter *reporter;
···
1219
1219
return 0;
1220
1220
}
1221
1221
1222
-
int devlink_nl_cmd_health_reporter_test_doit(struct sk_buff *skb,
1223
-
struct genl_info *info)
1222
+
int devlink_nl_health_reporter_test_doit(struct sk_buff *skb,
1223
+
struct genl_info *info)
1224
1224
{
1225
1225
struct devlink *devlink = info->user_ptr[0];
1226
1226
struct devlink_health_reporter *reporter;
+1
-2
net/devlink/linecard.c
+1
-2
net/devlink/linecard.c
···
369
369
return err;
370
370
}
371
371
372
-
int devlink_nl_cmd_linecard_set_doit(struct sk_buff *skb,
373
-
struct genl_info *info)
372
+
int devlink_nl_linecard_set_doit(struct sk_buff *skb, struct genl_info *info)
374
373
{
375
374
struct netlink_ext_ack *extack = info->extack;
376
375
struct devlink *devlink = info->user_ptr[0];
+1
-327
net/devlink/netlink.c
+1
-327
net/devlink/netlink.c
···
13
13
[DEVLINK_MCGRP_CONFIG] = { .name = DEVLINK_GENL_MCGRP_CONFIG_NAME },
14
14
};
15
15
16
-
static const struct nla_policy devlink_nl_policy[DEVLINK_ATTR_MAX + 1] = {
17
-
[DEVLINK_ATTR_UNSPEC] = { .strict_start_type =
18
-
DEVLINK_ATTR_TRAP_POLICER_ID },
19
-
[DEVLINK_ATTR_BUS_NAME] = { .type = NLA_NUL_STRING },
20
-
[DEVLINK_ATTR_DEV_NAME] = { .type = NLA_NUL_STRING },
21
-
[DEVLINK_ATTR_PORT_INDEX] = { .type = NLA_U32 },
22
-
[DEVLINK_ATTR_PORT_TYPE] = NLA_POLICY_RANGE(NLA_U16, DEVLINK_PORT_TYPE_AUTO,
23
-
DEVLINK_PORT_TYPE_IB),
24
-
[DEVLINK_ATTR_PORT_SPLIT_COUNT] = { .type = NLA_U32 },
25
-
[DEVLINK_ATTR_SB_INDEX] = { .type = NLA_U32 },
26
-
[DEVLINK_ATTR_SB_POOL_INDEX] = { .type = NLA_U16 },
27
-
[DEVLINK_ATTR_SB_POOL_TYPE] = { .type = NLA_U8 },
28
-
[DEVLINK_ATTR_SB_POOL_SIZE] = { .type = NLA_U32 },
29
-
[DEVLINK_ATTR_SB_POOL_THRESHOLD_TYPE] = { .type = NLA_U8 },
30
-
[DEVLINK_ATTR_SB_THRESHOLD] = { .type = NLA_U32 },
31
-
[DEVLINK_ATTR_SB_TC_INDEX] = { .type = NLA_U16 },
32
-
[DEVLINK_ATTR_ESWITCH_MODE] = NLA_POLICY_RANGE(NLA_U16, DEVLINK_ESWITCH_MODE_LEGACY,
33
-
DEVLINK_ESWITCH_MODE_SWITCHDEV),
34
-
[DEVLINK_ATTR_ESWITCH_INLINE_MODE] = { .type = NLA_U8 },
35
-
[DEVLINK_ATTR_ESWITCH_ENCAP_MODE] = { .type = NLA_U8 },
36
-
[DEVLINK_ATTR_DPIPE_TABLE_NAME] = { .type = NLA_NUL_STRING },
37
-
[DEVLINK_ATTR_DPIPE_TABLE_COUNTERS_ENABLED] = { .type = NLA_U8 },
38
-
[DEVLINK_ATTR_RESOURCE_ID] = { .type = NLA_U64},
39
-
[DEVLINK_ATTR_RESOURCE_SIZE] = { .type = NLA_U64},
40
-
[DEVLINK_ATTR_PARAM_NAME] = { .type = NLA_NUL_STRING },
41
-
[DEVLINK_ATTR_PARAM_TYPE] = { .type = NLA_U8 },
42
-
[DEVLINK_ATTR_PARAM_VALUE_CMODE] = { .type = NLA_U8 },
43
-
[DEVLINK_ATTR_REGION_NAME] = { .type = NLA_NUL_STRING },
44
-
[DEVLINK_ATTR_REGION_SNAPSHOT_ID] = { .type = NLA_U32 },
45
-
[DEVLINK_ATTR_REGION_CHUNK_ADDR] = { .type = NLA_U64 },
46
-
[DEVLINK_ATTR_REGION_CHUNK_LEN] = { .type = NLA_U64 },
47
-
[DEVLINK_ATTR_HEALTH_REPORTER_NAME] = { .type = NLA_NUL_STRING },
48
-
[DEVLINK_ATTR_HEALTH_REPORTER_GRACEFUL_PERIOD] = { .type = NLA_U64 },
49
-
[DEVLINK_ATTR_HEALTH_REPORTER_AUTO_RECOVER] = { .type = NLA_U8 },
50
-
[DEVLINK_ATTR_FLASH_UPDATE_FILE_NAME] = { .type = NLA_NUL_STRING },
51
-
[DEVLINK_ATTR_FLASH_UPDATE_COMPONENT] = { .type = NLA_NUL_STRING },
52
-
[DEVLINK_ATTR_FLASH_UPDATE_OVERWRITE_MASK] =
53
-
NLA_POLICY_BITFIELD32(DEVLINK_SUPPORTED_FLASH_OVERWRITE_SECTIONS),
54
-
[DEVLINK_ATTR_TRAP_NAME] = { .type = NLA_NUL_STRING },
55
-
[DEVLINK_ATTR_TRAP_ACTION] = { .type = NLA_U8 },
56
-
[DEVLINK_ATTR_TRAP_GROUP_NAME] = { .type = NLA_NUL_STRING },
57
-
[DEVLINK_ATTR_NETNS_PID] = { .type = NLA_U32 },
58
-
[DEVLINK_ATTR_NETNS_FD] = { .type = NLA_U32 },
59
-
[DEVLINK_ATTR_NETNS_ID] = { .type = NLA_U32 },
60
-
[DEVLINK_ATTR_HEALTH_REPORTER_AUTO_DUMP] = { .type = NLA_U8 },
61
-
[DEVLINK_ATTR_TRAP_POLICER_ID] = { .type = NLA_U32 },
62
-
[DEVLINK_ATTR_TRAP_POLICER_RATE] = { .type = NLA_U64 },
63
-
[DEVLINK_ATTR_TRAP_POLICER_BURST] = { .type = NLA_U64 },
64
-
[DEVLINK_ATTR_PORT_FUNCTION] = { .type = NLA_NESTED },
65
-
[DEVLINK_ATTR_RELOAD_ACTION] = NLA_POLICY_RANGE(NLA_U8, DEVLINK_RELOAD_ACTION_DRIVER_REINIT,
66
-
DEVLINK_RELOAD_ACTION_MAX),
67
-
[DEVLINK_ATTR_RELOAD_LIMITS] = NLA_POLICY_BITFIELD32(DEVLINK_RELOAD_LIMITS_VALID_MASK),
68
-
[DEVLINK_ATTR_PORT_FLAVOUR] = { .type = NLA_U16 },
69
-
[DEVLINK_ATTR_PORT_PCI_PF_NUMBER] = { .type = NLA_U16 },
70
-
[DEVLINK_ATTR_PORT_PCI_SF_NUMBER] = { .type = NLA_U32 },
71
-
[DEVLINK_ATTR_PORT_CONTROLLER_NUMBER] = { .type = NLA_U32 },
72
-
[DEVLINK_ATTR_RATE_TYPE] = { .type = NLA_U16 },
73
-
[DEVLINK_ATTR_RATE_TX_SHARE] = { .type = NLA_U64 },
74
-
[DEVLINK_ATTR_RATE_TX_MAX] = { .type = NLA_U64 },
75
-
[DEVLINK_ATTR_RATE_NODE_NAME] = { .type = NLA_NUL_STRING },
76
-
[DEVLINK_ATTR_RATE_PARENT_NODE_NAME] = { .type = NLA_NUL_STRING },
77
-
[DEVLINK_ATTR_LINECARD_INDEX] = { .type = NLA_U32 },
78
-
[DEVLINK_ATTR_LINECARD_TYPE] = { .type = NLA_NUL_STRING },
79
-
[DEVLINK_ATTR_SELFTESTS] = { .type = NLA_NESTED },
80
-
[DEVLINK_ATTR_RATE_TX_PRIORITY] = { .type = NLA_U32 },
81
-
[DEVLINK_ATTR_RATE_TX_WEIGHT] = { .type = NLA_U32 },
82
-
[DEVLINK_ATTR_REGION_DIRECT] = { .type = NLA_FLAG },
83
-
};
84
-
85
16
int devlink_nl_put_nested_handle(struct sk_buff *msg, struct net *net,
86
17
struct devlink *devlink, int attrtype)
87
18
{
···
122
191
int devlink_nl_pre_doit(const struct genl_split_ops *ops,
123
192
struct sk_buff *skb, struct genl_info *info)
124
193
{
125
-
return __devlink_nl_pre_doit(skb, info, ops->internal_flags);
194
+
return __devlink_nl_pre_doit(skb, info, 0);
126
195
}
127
196
128
197
int devlink_nl_pre_doit_port(const struct genl_split_ops *ops,
···
218
287
return devlink_nl_inst_iter_dumpit(msg, cb, flags, dump_one);
219
288
}
220
289
221
-
static const struct genl_small_ops devlink_nl_small_ops[40] = {
222
-
{
223
-
.cmd = DEVLINK_CMD_PORT_SET,
224
-
.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
225
-
.doit = devlink_nl_cmd_port_set_doit,
226
-
.flags = GENL_ADMIN_PERM,
227
-
.internal_flags = DEVLINK_NL_FLAG_NEED_PORT,
228
-
},
229
-
{
230
-
.cmd = DEVLINK_CMD_RATE_SET,
231
-
.doit = devlink_nl_cmd_rate_set_doit,
232
-
.flags = GENL_ADMIN_PERM,
233
-
},
234
-
{
235
-
.cmd = DEVLINK_CMD_RATE_NEW,
236
-
.doit = devlink_nl_cmd_rate_new_doit,
237
-
.flags = GENL_ADMIN_PERM,
238
-
},
239
-
{
240
-
.cmd = DEVLINK_CMD_RATE_DEL,
241
-
.doit = devlink_nl_cmd_rate_del_doit,
242
-
.flags = GENL_ADMIN_PERM,
243
-
},
244
-
{
245
-
.cmd = DEVLINK_CMD_PORT_SPLIT,
246
-
.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
247
-
.doit = devlink_nl_cmd_port_split_doit,
248
-
.flags = GENL_ADMIN_PERM,
249
-
.internal_flags = DEVLINK_NL_FLAG_NEED_PORT,
250
-
},
251
-
{
252
-
.cmd = DEVLINK_CMD_PORT_UNSPLIT,
253
-
.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
254
-
.doit = devlink_nl_cmd_port_unsplit_doit,
255
-
.flags = GENL_ADMIN_PERM,
256
-
.internal_flags = DEVLINK_NL_FLAG_NEED_PORT,
257
-
},
258
-
{
259
-
.cmd = DEVLINK_CMD_PORT_NEW,
260
-
.doit = devlink_nl_cmd_port_new_doit,
261
-
.flags = GENL_ADMIN_PERM,
262
-
},
263
-
{
264
-
.cmd = DEVLINK_CMD_PORT_DEL,
265
-
.doit = devlink_nl_cmd_port_del_doit,
266
-
.flags = GENL_ADMIN_PERM,
267
-
.internal_flags = DEVLINK_NL_FLAG_NEED_PORT,
268
-
},
269
-
270
-
{
271
-
.cmd = DEVLINK_CMD_LINECARD_SET,
272
-
.doit = devlink_nl_cmd_linecard_set_doit,
273
-
.flags = GENL_ADMIN_PERM,
274
-
},
275
-
{
276
-
.cmd = DEVLINK_CMD_SB_POOL_SET,
277
-
.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
278
-
.doit = devlink_nl_cmd_sb_pool_set_doit,
279
-
.flags = GENL_ADMIN_PERM,
280
-
},
281
-
{
282
-
.cmd = DEVLINK_CMD_SB_PORT_POOL_SET,
283
-
.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
284
-
.doit = devlink_nl_cmd_sb_port_pool_set_doit,
285
-
.flags = GENL_ADMIN_PERM,
286
-
.internal_flags = DEVLINK_NL_FLAG_NEED_PORT,
287
-
},
288
-
{
289
-
.cmd = DEVLINK_CMD_SB_TC_POOL_BIND_SET,
290
-
.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
291
-
.doit = devlink_nl_cmd_sb_tc_pool_bind_set_doit,
292
-
.flags = GENL_ADMIN_PERM,
293
-
.internal_flags = DEVLINK_NL_FLAG_NEED_PORT,
294
-
},
295
-
{
296
-
.cmd = DEVLINK_CMD_SB_OCC_SNAPSHOT,
297
-
.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
298
-
.doit = devlink_nl_cmd_sb_occ_snapshot_doit,
299
-
.flags = GENL_ADMIN_PERM,
300
-
},
301
-
{
302
-
.cmd = DEVLINK_CMD_SB_OCC_MAX_CLEAR,
303
-
.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
304
-
.doit = devlink_nl_cmd_sb_occ_max_clear_doit,
305
-
.flags = GENL_ADMIN_PERM,
306
-
},
307
-
{
308
-
.cmd = DEVLINK_CMD_ESWITCH_GET,
309
-
.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
310
-
.doit = devlink_nl_cmd_eswitch_get_doit,
311
-
.flags = GENL_ADMIN_PERM,
312
-
},
313
-
{
314
-
.cmd = DEVLINK_CMD_ESWITCH_SET,
315
-
.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
316
-
.doit = devlink_nl_cmd_eswitch_set_doit,
317
-
.flags = GENL_ADMIN_PERM,
318
-
},
319
-
{
320
-
.cmd = DEVLINK_CMD_DPIPE_TABLE_GET,
321
-
.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
322
-
.doit = devlink_nl_cmd_dpipe_table_get,
323
-
/* can be retrieved by unprivileged users */
324
-
},
325
-
{
326
-
.cmd = DEVLINK_CMD_DPIPE_ENTRIES_GET,
327
-
.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
328
-
.doit = devlink_nl_cmd_dpipe_entries_get,
329
-
/* can be retrieved by unprivileged users */
330
-
},
331
-
{
332
-
.cmd = DEVLINK_CMD_DPIPE_HEADERS_GET,
333
-
.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
334
-
.doit = devlink_nl_cmd_dpipe_headers_get,
335
-
/* can be retrieved by unprivileged users */
336
-
},
337
-
{
338
-
.cmd = DEVLINK_CMD_DPIPE_TABLE_COUNTERS_SET,
339
-
.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
340
-
.doit = devlink_nl_cmd_dpipe_table_counters_set,
341
-
.flags = GENL_ADMIN_PERM,
342
-
},
343
-
{
344
-
.cmd = DEVLINK_CMD_RESOURCE_SET,
345
-
.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
346
-
.doit = devlink_nl_cmd_resource_set,
347
-
.flags = GENL_ADMIN_PERM,
348
-
},
349
-
{
350
-
.cmd = DEVLINK_CMD_RESOURCE_DUMP,
351
-
.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
352
-
.doit = devlink_nl_cmd_resource_dump,
353
-
/* can be retrieved by unprivileged users */
354
-
},
355
-
{
356
-
.cmd = DEVLINK_CMD_RELOAD,
357
-
.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
358
-
.doit = devlink_nl_cmd_reload,
359
-
.flags = GENL_ADMIN_PERM,
360
-
},
361
-
{
362
-
.cmd = DEVLINK_CMD_PARAM_SET,
363
-
.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
364
-
.doit = devlink_nl_cmd_param_set_doit,
365
-
.flags = GENL_ADMIN_PERM,
366
-
},
367
-
{
368
-
.cmd = DEVLINK_CMD_PORT_PARAM_GET,
369
-
.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
370
-
.doit = devlink_nl_cmd_port_param_get_doit,
371
-
.dumpit = devlink_nl_cmd_port_param_get_dumpit,
372
-
.internal_flags = DEVLINK_NL_FLAG_NEED_PORT,
373
-
/* can be retrieved by unprivileged users */
374
-
},
375
-
{
376
-
.cmd = DEVLINK_CMD_PORT_PARAM_SET,
377
-
.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
378
-
.doit = devlink_nl_cmd_port_param_set_doit,
379
-
.flags = GENL_ADMIN_PERM,
380
-
.internal_flags = DEVLINK_NL_FLAG_NEED_PORT,
381
-
},
382
-
{
383
-
.cmd = DEVLINK_CMD_REGION_NEW,
384
-
.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
385
-
.doit = devlink_nl_cmd_region_new,
386
-
.flags = GENL_ADMIN_PERM,
387
-
},
388
-
{
389
-
.cmd = DEVLINK_CMD_REGION_DEL,
390
-
.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
391
-
.doit = devlink_nl_cmd_region_del,
392
-
.flags = GENL_ADMIN_PERM,
393
-
},
394
-
{
395
-
.cmd = DEVLINK_CMD_REGION_READ,
396
-
.validate = GENL_DONT_VALIDATE_STRICT |
397
-
GENL_DONT_VALIDATE_DUMP_STRICT,
398
-
.dumpit = devlink_nl_cmd_region_read_dumpit,
399
-
.flags = GENL_ADMIN_PERM,
400
-
},
401
-
{
402
-
.cmd = DEVLINK_CMD_HEALTH_REPORTER_SET,
403
-
.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
404
-
.doit = devlink_nl_cmd_health_reporter_set_doit,
405
-
.flags = GENL_ADMIN_PERM,
406
-
.internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK_OR_PORT,
407
-
},
408
-
{
409
-
.cmd = DEVLINK_CMD_HEALTH_REPORTER_RECOVER,
410
-
.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
411
-
.doit = devlink_nl_cmd_health_reporter_recover_doit,
412
-
.flags = GENL_ADMIN_PERM,
413
-
.internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK_OR_PORT,
414
-
},
415
-
{
416
-
.cmd = DEVLINK_CMD_HEALTH_REPORTER_DIAGNOSE,
417
-
.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
418
-
.doit = devlink_nl_cmd_health_reporter_diagnose_doit,
419
-
.flags = GENL_ADMIN_PERM,
420
-
.internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK_OR_PORT,
421
-
},
422
-
{
423
-
.cmd = DEVLINK_CMD_HEALTH_REPORTER_DUMP_GET,
424
-
.validate = GENL_DONT_VALIDATE_STRICT |
425
-
GENL_DONT_VALIDATE_DUMP_STRICT,
426
-
.dumpit = devlink_nl_cmd_health_reporter_dump_get_dumpit,
427
-
.flags = GENL_ADMIN_PERM,
428
-
},
429
-
{
430
-
.cmd = DEVLINK_CMD_HEALTH_REPORTER_DUMP_CLEAR,
431
-
.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
432
-
.doit = devlink_nl_cmd_health_reporter_dump_clear_doit,
433
-
.flags = GENL_ADMIN_PERM,
434
-
.internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK_OR_PORT,
435
-
},
436
-
{
437
-
.cmd = DEVLINK_CMD_HEALTH_REPORTER_TEST,
438
-
.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
439
-
.doit = devlink_nl_cmd_health_reporter_test_doit,
440
-
.flags = GENL_ADMIN_PERM,
441
-
.internal_flags = DEVLINK_NL_FLAG_NEED_DEVLINK_OR_PORT,
442
-
},
443
-
{
444
-
.cmd = DEVLINK_CMD_FLASH_UPDATE,
445
-
.validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
446
-
.doit = devlink_nl_cmd_flash_update,
447
-
.flags = GENL_ADMIN_PERM,
448
-
},
449
-
{
450
-
.cmd = DEVLINK_CMD_TRAP_SET,
451
-
.doit = devlink_nl_cmd_trap_set_doit,
452
-
.flags = GENL_ADMIN_PERM,
453
-
},
454
-
{
455
-
.cmd = DEVLINK_CMD_TRAP_GROUP_SET,
456
-
.doit = devlink_nl_cmd_trap_group_set_doit,
457
-
.flags = GENL_ADMIN_PERM,
458
-
},
459
-
{
460
-
.cmd = DEVLINK_CMD_TRAP_POLICER_SET,
461
-
.doit = devlink_nl_cmd_trap_policer_set_doit,
462
-
.flags = GENL_ADMIN_PERM,
463
-
},
464
-
{
465
-
.cmd = DEVLINK_CMD_SELFTESTS_RUN,
466
-
.doit = devlink_nl_cmd_selftests_run,
467
-
.flags = GENL_ADMIN_PERM,
468
-
},
469
-
/* -- No new ops here! Use split ops going forward! -- */
470
-
};
471
-
472
290
struct genl_family devlink_nl_family __ro_after_init = {
473
291
.name = DEVLINK_GENL_NAME,
474
292
.version = DEVLINK_GENL_VERSION,
475
-
.maxattr = DEVLINK_ATTR_MAX,
476
-
.policy = devlink_nl_policy,
477
293
.netnsok = true,
478
294
.parallel_ops = true,
479
-
.pre_doit = devlink_nl_pre_doit,
480
-
.post_doit = devlink_nl_post_doit,
481
295
.module = THIS_MODULE,
482
-
.small_ops = devlink_nl_small_ops,
483
-
.n_small_ops = ARRAY_SIZE(devlink_nl_small_ops),
484
296
.split_ops = devlink_nl_ops,
485
297
.n_split_ops = ARRAY_SIZE(devlink_nl_ops),
486
298
.resv_start_op = DEVLINK_CMD_SELFTESTS_RUN + 1,
+756
-1
net/devlink/netlink_gen.c
+756
-1
net/devlink/netlink_gen.c
···
10
10
11
11
#include <uapi/linux/devlink.h>
12
12
13
+
/* Common nested types */
14
+
const struct nla_policy devlink_dl_port_function_nl_policy[DEVLINK_PORT_FN_ATTR_CAPS + 1] = {
15
+
[DEVLINK_PORT_FUNCTION_ATTR_HW_ADDR] = { .type = NLA_BINARY, },
16
+
[DEVLINK_PORT_FN_ATTR_STATE] = NLA_POLICY_MAX(NLA_U8, 1),
17
+
[DEVLINK_PORT_FN_ATTR_OPSTATE] = NLA_POLICY_MAX(NLA_U8, 1),
18
+
[DEVLINK_PORT_FN_ATTR_CAPS] = NLA_POLICY_BITFIELD32(3),
19
+
};
20
+
21
+
const struct nla_policy devlink_dl_selftest_id_nl_policy[DEVLINK_ATTR_SELFTEST_ID_FLASH + 1] = {
22
+
[DEVLINK_ATTR_SELFTEST_ID_FLASH] = { .type = NLA_FLAG, },
23
+
};
24
+
13
25
/* DEVLINK_CMD_GET - do */
14
26
static const struct nla_policy devlink_get_nl_policy[DEVLINK_ATTR_DEV_NAME + 1] = {
15
27
[DEVLINK_ATTR_BUS_NAME] = { .type = NLA_NUL_STRING, },
···
39
27
static const struct nla_policy devlink_port_get_dump_nl_policy[DEVLINK_ATTR_DEV_NAME + 1] = {
40
28
[DEVLINK_ATTR_BUS_NAME] = { .type = NLA_NUL_STRING, },
41
29
[DEVLINK_ATTR_DEV_NAME] = { .type = NLA_NUL_STRING, },
30
+
};
31
+
32
+
/* DEVLINK_CMD_PORT_SET - do */
33
+
static const struct nla_policy devlink_port_set_nl_policy[DEVLINK_ATTR_PORT_FUNCTION + 1] = {
34
+
[DEVLINK_ATTR_BUS_NAME] = { .type = NLA_NUL_STRING, },
35
+
[DEVLINK_ATTR_DEV_NAME] = { .type = NLA_NUL_STRING, },
36
+
[DEVLINK_ATTR_PORT_INDEX] = { .type = NLA_U32, },
37
+
[DEVLINK_ATTR_PORT_TYPE] = NLA_POLICY_MAX(NLA_U16, 3),
38
+
[DEVLINK_ATTR_PORT_FUNCTION] = NLA_POLICY_NESTED(devlink_dl_port_function_nl_policy),
39
+
};
40
+
41
+
/* DEVLINK_CMD_PORT_NEW - do */
42
+
static const struct nla_policy devlink_port_new_nl_policy[DEVLINK_ATTR_PORT_PCI_SF_NUMBER + 1] = {
43
+
[DEVLINK_ATTR_BUS_NAME] = { .type = NLA_NUL_STRING, },
44
+
[DEVLINK_ATTR_DEV_NAME] = { .type = NLA_NUL_STRING, },
45
+
[DEVLINK_ATTR_PORT_INDEX] = { .type = NLA_U32, },
46
+
[DEVLINK_ATTR_PORT_FLAVOUR] = NLA_POLICY_MAX(NLA_U16, 7),
47
+
[DEVLINK_ATTR_PORT_PCI_PF_NUMBER] = { .type = NLA_U16, },
48
+
[DEVLINK_ATTR_PORT_PCI_SF_NUMBER] = { .type = NLA_U32, },
49
+
[DEVLINK_ATTR_PORT_CONTROLLER_NUMBER] = { .type = NLA_U32, },
50
+
};
51
+
52
+
/* DEVLINK_CMD_PORT_DEL - do */
53
+
static const struct nla_policy devlink_port_del_nl_policy[DEVLINK_ATTR_PORT_INDEX + 1] = {
54
+
[DEVLINK_ATTR_BUS_NAME] = { .type = NLA_NUL_STRING, },
55
+
[DEVLINK_ATTR_DEV_NAME] = { .type = NLA_NUL_STRING, },
56
+
[DEVLINK_ATTR_PORT_INDEX] = { .type = NLA_U32, },
57
+
};
58
+
59
+
/* DEVLINK_CMD_PORT_SPLIT - do */
60
+
static const struct nla_policy devlink_port_split_nl_policy[DEVLINK_ATTR_PORT_SPLIT_COUNT + 1] = {
61
+
[DEVLINK_ATTR_BUS_NAME] = { .type = NLA_NUL_STRING, },
62
+
[DEVLINK_ATTR_DEV_NAME] = { .type = NLA_NUL_STRING, },
63
+
[DEVLINK_ATTR_PORT_INDEX] = { .type = NLA_U32, },
64
+
[DEVLINK_ATTR_PORT_SPLIT_COUNT] = { .type = NLA_U32, },
65
+
};
66
+
67
+
/* DEVLINK_CMD_PORT_UNSPLIT - do */
68
+
static const struct nla_policy devlink_port_unsplit_nl_policy[DEVLINK_ATTR_PORT_INDEX + 1] = {
69
+
[DEVLINK_ATTR_BUS_NAME] = { .type = NLA_NUL_STRING, },
70
+
[DEVLINK_ATTR_DEV_NAME] = { .type = NLA_NUL_STRING, },
71
+
[DEVLINK_ATTR_PORT_INDEX] = { .type = NLA_U32, },
42
72
};
43
73
44
74
/* DEVLINK_CMD_SB_GET - do */
···
110
56
[DEVLINK_ATTR_DEV_NAME] = { .type = NLA_NUL_STRING, },
111
57
};
112
58
59
+
/* DEVLINK_CMD_SB_POOL_SET - do */
60
+
static const struct nla_policy devlink_sb_pool_set_nl_policy[DEVLINK_ATTR_SB_POOL_THRESHOLD_TYPE + 1] = {
61
+
[DEVLINK_ATTR_BUS_NAME] = { .type = NLA_NUL_STRING, },
62
+
[DEVLINK_ATTR_DEV_NAME] = { .type = NLA_NUL_STRING, },
63
+
[DEVLINK_ATTR_SB_INDEX] = { .type = NLA_U32, },
64
+
[DEVLINK_ATTR_SB_POOL_INDEX] = { .type = NLA_U16, },
65
+
[DEVLINK_ATTR_SB_POOL_THRESHOLD_TYPE] = NLA_POLICY_MAX(NLA_U8, 1),
66
+
[DEVLINK_ATTR_SB_POOL_SIZE] = { .type = NLA_U32, },
67
+
};
68
+
113
69
/* DEVLINK_CMD_SB_PORT_POOL_GET - do */
114
70
static const struct nla_policy devlink_sb_port_pool_get_do_nl_policy[DEVLINK_ATTR_SB_POOL_INDEX + 1] = {
115
71
[DEVLINK_ATTR_BUS_NAME] = { .type = NLA_NUL_STRING, },
···
133
69
static const struct nla_policy devlink_sb_port_pool_get_dump_nl_policy[DEVLINK_ATTR_DEV_NAME + 1] = {
134
70
[DEVLINK_ATTR_BUS_NAME] = { .type = NLA_NUL_STRING, },
135
71
[DEVLINK_ATTR_DEV_NAME] = { .type = NLA_NUL_STRING, },
72
+
};
73
+
74
+
/* DEVLINK_CMD_SB_PORT_POOL_SET - do */
75
+
static const struct nla_policy devlink_sb_port_pool_set_nl_policy[DEVLINK_ATTR_SB_THRESHOLD + 1] = {
76
+
[DEVLINK_ATTR_BUS_NAME] = { .type = NLA_NUL_STRING, },
77
+
[DEVLINK_ATTR_DEV_NAME] = { .type = NLA_NUL_STRING, },
78
+
[DEVLINK_ATTR_PORT_INDEX] = { .type = NLA_U32, },
79
+
[DEVLINK_ATTR_SB_INDEX] = { .type = NLA_U32, },
80
+
[DEVLINK_ATTR_SB_POOL_INDEX] = { .type = NLA_U16, },
81
+
[DEVLINK_ATTR_SB_THRESHOLD] = { .type = NLA_U32, },
136
82
};
137
83
138
84
/* DEVLINK_CMD_SB_TC_POOL_BIND_GET - do */
···
161
87
[DEVLINK_ATTR_DEV_NAME] = { .type = NLA_NUL_STRING, },
162
88
};
163
89
90
+
/* DEVLINK_CMD_SB_TC_POOL_BIND_SET - do */
91
+
static const struct nla_policy devlink_sb_tc_pool_bind_set_nl_policy[DEVLINK_ATTR_SB_TC_INDEX + 1] = {
92
+
[DEVLINK_ATTR_BUS_NAME] = { .type = NLA_NUL_STRING, },
93
+
[DEVLINK_ATTR_DEV_NAME] = { .type = NLA_NUL_STRING, },
94
+
[DEVLINK_ATTR_PORT_INDEX] = { .type = NLA_U32, },
95
+
[DEVLINK_ATTR_SB_INDEX] = { .type = NLA_U32, },
96
+
[DEVLINK_ATTR_SB_POOL_INDEX] = { .type = NLA_U16, },
97
+
[DEVLINK_ATTR_SB_POOL_TYPE] = NLA_POLICY_MAX(NLA_U8, 1),
98
+
[DEVLINK_ATTR_SB_TC_INDEX] = { .type = NLA_U16, },
99
+
[DEVLINK_ATTR_SB_THRESHOLD] = { .type = NLA_U32, },
100
+
};
101
+
102
+
/* DEVLINK_CMD_SB_OCC_SNAPSHOT - do */
103
+
static const struct nla_policy devlink_sb_occ_snapshot_nl_policy[DEVLINK_ATTR_SB_INDEX + 1] = {
104
+
[DEVLINK_ATTR_BUS_NAME] = { .type = NLA_NUL_STRING, },
105
+
[DEVLINK_ATTR_DEV_NAME] = { .type = NLA_NUL_STRING, },
106
+
[DEVLINK_ATTR_SB_INDEX] = { .type = NLA_U32, },
107
+
};
108
+
109
+
/* DEVLINK_CMD_SB_OCC_MAX_CLEAR - do */
110
+
static const struct nla_policy devlink_sb_occ_max_clear_nl_policy[DEVLINK_ATTR_SB_INDEX + 1] = {
111
+
[DEVLINK_ATTR_BUS_NAME] = { .type = NLA_NUL_STRING, },
112
+
[DEVLINK_ATTR_DEV_NAME] = { .type = NLA_NUL_STRING, },
113
+
[DEVLINK_ATTR_SB_INDEX] = { .type = NLA_U32, },
114
+
};
115
+
116
+
/* DEVLINK_CMD_ESWITCH_GET - do */
117
+
static const struct nla_policy devlink_eswitch_get_nl_policy[DEVLINK_ATTR_DEV_NAME + 1] = {
118
+
[DEVLINK_ATTR_BUS_NAME] = { .type = NLA_NUL_STRING, },
119
+
[DEVLINK_ATTR_DEV_NAME] = { .type = NLA_NUL_STRING, },
120
+
};
121
+
122
+
/* DEVLINK_CMD_ESWITCH_SET - do */
123
+
static const struct nla_policy devlink_eswitch_set_nl_policy[DEVLINK_ATTR_ESWITCH_ENCAP_MODE + 1] = {
124
+
[DEVLINK_ATTR_BUS_NAME] = { .type = NLA_NUL_STRING, },
125
+
[DEVLINK_ATTR_DEV_NAME] = { .type = NLA_NUL_STRING, },
126
+
[DEVLINK_ATTR_ESWITCH_MODE] = NLA_POLICY_MAX(NLA_U16, 1),
127
+
[DEVLINK_ATTR_ESWITCH_INLINE_MODE] = NLA_POLICY_MAX(NLA_U16, 3),
128
+
[DEVLINK_ATTR_ESWITCH_ENCAP_MODE] = NLA_POLICY_MAX(NLA_U8, 1),
129
+
};
130
+
131
+
/* DEVLINK_CMD_DPIPE_TABLE_GET - do */
132
+
static const struct nla_policy devlink_dpipe_table_get_nl_policy[DEVLINK_ATTR_DPIPE_TABLE_NAME + 1] = {
133
+
[DEVLINK_ATTR_BUS_NAME] = { .type = NLA_NUL_STRING, },
134
+
[DEVLINK_ATTR_DEV_NAME] = { .type = NLA_NUL_STRING, },
135
+
[DEVLINK_ATTR_DPIPE_TABLE_NAME] = { .type = NLA_NUL_STRING, },
136
+
};
137
+
138
+
/* DEVLINK_CMD_DPIPE_ENTRIES_GET - do */
139
+
static const struct nla_policy devlink_dpipe_entries_get_nl_policy[DEVLINK_ATTR_DPIPE_TABLE_NAME + 1] = {
140
+
[DEVLINK_ATTR_BUS_NAME] = { .type = NLA_NUL_STRING, },
141
+
[DEVLINK_ATTR_DEV_NAME] = { .type = NLA_NUL_STRING, },
142
+
[DEVLINK_ATTR_DPIPE_TABLE_NAME] = { .type = NLA_NUL_STRING, },
143
+
};
144
+
145
+
/* DEVLINK_CMD_DPIPE_HEADERS_GET - do */
146
+
static const struct nla_policy devlink_dpipe_headers_get_nl_policy[DEVLINK_ATTR_DEV_NAME + 1] = {
147
+
[DEVLINK_ATTR_BUS_NAME] = { .type = NLA_NUL_STRING, },
148
+
[DEVLINK_ATTR_DEV_NAME] = { .type = NLA_NUL_STRING, },
149
+
};
150
+
151
+
/* DEVLINK_CMD_DPIPE_TABLE_COUNTERS_SET - do */
152
+
static const struct nla_policy devlink_dpipe_table_counters_set_nl_policy[DEVLINK_ATTR_DPIPE_TABLE_COUNTERS_ENABLED + 1] = {
153
+
[DEVLINK_ATTR_BUS_NAME] = { .type = NLA_NUL_STRING, },
154
+
[DEVLINK_ATTR_DEV_NAME] = { .type = NLA_NUL_STRING, },
155
+
[DEVLINK_ATTR_DPIPE_TABLE_NAME] = { .type = NLA_NUL_STRING, },
156
+
[DEVLINK_ATTR_DPIPE_TABLE_COUNTERS_ENABLED] = { .type = NLA_U8, },
157
+
};
158
+
159
+
/* DEVLINK_CMD_RESOURCE_SET - do */
160
+
static const struct nla_policy devlink_resource_set_nl_policy[DEVLINK_ATTR_RESOURCE_SIZE + 1] = {
161
+
[DEVLINK_ATTR_BUS_NAME] = { .type = NLA_NUL_STRING, },
162
+
[DEVLINK_ATTR_DEV_NAME] = { .type = NLA_NUL_STRING, },
163
+
[DEVLINK_ATTR_RESOURCE_ID] = { .type = NLA_U64, },
164
+
[DEVLINK_ATTR_RESOURCE_SIZE] = { .type = NLA_U64, },
165
+
};
166
+
167
+
/* DEVLINK_CMD_RESOURCE_DUMP - do */
168
+
static const struct nla_policy devlink_resource_dump_nl_policy[DEVLINK_ATTR_DEV_NAME + 1] = {
169
+
[DEVLINK_ATTR_BUS_NAME] = { .type = NLA_NUL_STRING, },
170
+
[DEVLINK_ATTR_DEV_NAME] = { .type = NLA_NUL_STRING, },
171
+
};
172
+
173
+
/* DEVLINK_CMD_RELOAD - do */
174
+
static const struct nla_policy devlink_reload_nl_policy[DEVLINK_ATTR_RELOAD_LIMITS + 1] = {
175
+
[DEVLINK_ATTR_BUS_NAME] = { .type = NLA_NUL_STRING, },
176
+
[DEVLINK_ATTR_DEV_NAME] = { .type = NLA_NUL_STRING, },
177
+
[DEVLINK_ATTR_RELOAD_ACTION] = NLA_POLICY_RANGE(NLA_U8, 1, 2),
178
+
[DEVLINK_ATTR_RELOAD_LIMITS] = NLA_POLICY_BITFIELD32(6),
179
+
[DEVLINK_ATTR_NETNS_PID] = { .type = NLA_U32, },
180
+
[DEVLINK_ATTR_NETNS_FD] = { .type = NLA_U32, },
181
+
[DEVLINK_ATTR_NETNS_ID] = { .type = NLA_U32, },
182
+
};
183
+
164
184
/* DEVLINK_CMD_PARAM_GET - do */
165
185
static const struct nla_policy devlink_param_get_do_nl_policy[DEVLINK_ATTR_PARAM_NAME + 1] = {
166
186
[DEVLINK_ATTR_BUS_NAME] = { .type = NLA_NUL_STRING, },
···
266
98
static const struct nla_policy devlink_param_get_dump_nl_policy[DEVLINK_ATTR_DEV_NAME + 1] = {
267
99
[DEVLINK_ATTR_BUS_NAME] = { .type = NLA_NUL_STRING, },
268
100
[DEVLINK_ATTR_DEV_NAME] = { .type = NLA_NUL_STRING, },
101
+
};
102
+
103
+
/* DEVLINK_CMD_PARAM_SET - do */
104
+
static const struct nla_policy devlink_param_set_nl_policy[DEVLINK_ATTR_PARAM_VALUE_CMODE + 1] = {
105
+
[DEVLINK_ATTR_BUS_NAME] = { .type = NLA_NUL_STRING, },
106
+
[DEVLINK_ATTR_DEV_NAME] = { .type = NLA_NUL_STRING, },
107
+
[DEVLINK_ATTR_PARAM_NAME] = { .type = NLA_NUL_STRING, },
108
+
[DEVLINK_ATTR_PARAM_TYPE] = { .type = NLA_U8, },
109
+
[DEVLINK_ATTR_PARAM_VALUE_CMODE] = NLA_POLICY_MAX(NLA_U8, 2),
269
110
};
270
111
271
112
/* DEVLINK_CMD_REGION_GET - do */
···
289
112
static const struct nla_policy devlink_region_get_dump_nl_policy[DEVLINK_ATTR_DEV_NAME + 1] = {
290
113
[DEVLINK_ATTR_BUS_NAME] = { .type = NLA_NUL_STRING, },
291
114
[DEVLINK_ATTR_DEV_NAME] = { .type = NLA_NUL_STRING, },
115
+
};
116
+
117
+
/* DEVLINK_CMD_REGION_NEW - do */
118
+
static const struct nla_policy devlink_region_new_nl_policy[DEVLINK_ATTR_REGION_SNAPSHOT_ID + 1] = {
119
+
[DEVLINK_ATTR_BUS_NAME] = { .type = NLA_NUL_STRING, },
120
+
[DEVLINK_ATTR_DEV_NAME] = { .type = NLA_NUL_STRING, },
121
+
[DEVLINK_ATTR_PORT_INDEX] = { .type = NLA_U32, },
122
+
[DEVLINK_ATTR_REGION_NAME] = { .type = NLA_NUL_STRING, },
123
+
[DEVLINK_ATTR_REGION_SNAPSHOT_ID] = { .type = NLA_U32, },
124
+
};
125
+
126
+
/* DEVLINK_CMD_REGION_DEL - do */
127
+
static const struct nla_policy devlink_region_del_nl_policy[DEVLINK_ATTR_REGION_SNAPSHOT_ID + 1] = {
128
+
[DEVLINK_ATTR_BUS_NAME] = { .type = NLA_NUL_STRING, },
129
+
[DEVLINK_ATTR_DEV_NAME] = { .type = NLA_NUL_STRING, },
130
+
[DEVLINK_ATTR_PORT_INDEX] = { .type = NLA_U32, },
131
+
[DEVLINK_ATTR_REGION_NAME] = { .type = NLA_NUL_STRING, },
132
+
[DEVLINK_ATTR_REGION_SNAPSHOT_ID] = { .type = NLA_U32, },
133
+
};
134
+
135
+
/* DEVLINK_CMD_REGION_READ - dump */
136
+
static const struct nla_policy devlink_region_read_nl_policy[DEVLINK_ATTR_REGION_DIRECT + 1] = {
137
+
[DEVLINK_ATTR_BUS_NAME] = { .type = NLA_NUL_STRING, },
138
+
[DEVLINK_ATTR_DEV_NAME] = { .type = NLA_NUL_STRING, },
139
+
[DEVLINK_ATTR_PORT_INDEX] = { .type = NLA_U32, },
140
+
[DEVLINK_ATTR_REGION_NAME] = { .type = NLA_NUL_STRING, },
141
+
[DEVLINK_ATTR_REGION_SNAPSHOT_ID] = { .type = NLA_U32, },
142
+
[DEVLINK_ATTR_REGION_DIRECT] = { .type = NLA_FLAG, },
143
+
[DEVLINK_ATTR_REGION_CHUNK_ADDR] = { .type = NLA_U64, },
144
+
[DEVLINK_ATTR_REGION_CHUNK_LEN] = { .type = NLA_U64, },
145
+
};
146
+
147
+
/* DEVLINK_CMD_PORT_PARAM_GET - do */
148
+
static const struct nla_policy devlink_port_param_get_nl_policy[DEVLINK_ATTR_PORT_INDEX + 1] = {
149
+
[DEVLINK_ATTR_BUS_NAME] = { .type = NLA_NUL_STRING, },
150
+
[DEVLINK_ATTR_DEV_NAME] = { .type = NLA_NUL_STRING, },
151
+
[DEVLINK_ATTR_PORT_INDEX] = { .type = NLA_U32, },
152
+
};
153
+
154
+
/* DEVLINK_CMD_PORT_PARAM_SET - do */
155
+
static const struct nla_policy devlink_port_param_set_nl_policy[DEVLINK_ATTR_PORT_INDEX + 1] = {
156
+
[DEVLINK_ATTR_BUS_NAME] = { .type = NLA_NUL_STRING, },
157
+
[DEVLINK_ATTR_DEV_NAME] = { .type = NLA_NUL_STRING, },
158
+
[DEVLINK_ATTR_PORT_INDEX] = { .type = NLA_U32, },
292
159
};
293
160
294
161
/* DEVLINK_CMD_INFO_GET - do */
···
356
135
[DEVLINK_ATTR_PORT_INDEX] = { .type = NLA_U32, },
357
136
};
358
137
138
+
/* DEVLINK_CMD_HEALTH_REPORTER_SET - do */
139
+
static const struct nla_policy devlink_health_reporter_set_nl_policy[DEVLINK_ATTR_HEALTH_REPORTER_AUTO_DUMP + 1] = {
140
+
[DEVLINK_ATTR_BUS_NAME] = { .type = NLA_NUL_STRING, },
141
+
[DEVLINK_ATTR_DEV_NAME] = { .type = NLA_NUL_STRING, },
142
+
[DEVLINK_ATTR_PORT_INDEX] = { .type = NLA_U32, },
143
+
[DEVLINK_ATTR_HEALTH_REPORTER_NAME] = { .type = NLA_NUL_STRING, },
144
+
[DEVLINK_ATTR_HEALTH_REPORTER_GRACEFUL_PERIOD] = { .type = NLA_U64, },
145
+
[DEVLINK_ATTR_HEALTH_REPORTER_AUTO_RECOVER] = { .type = NLA_U8, },
146
+
[DEVLINK_ATTR_HEALTH_REPORTER_AUTO_DUMP] = { .type = NLA_U8, },
147
+
};
148
+
149
+
/* DEVLINK_CMD_HEALTH_REPORTER_RECOVER - do */
150
+
static const struct nla_policy devlink_health_reporter_recover_nl_policy[DEVLINK_ATTR_HEALTH_REPORTER_NAME + 1] = {
151
+
[DEVLINK_ATTR_BUS_NAME] = { .type = NLA_NUL_STRING, },
152
+
[DEVLINK_ATTR_DEV_NAME] = { .type = NLA_NUL_STRING, },
153
+
[DEVLINK_ATTR_PORT_INDEX] = { .type = NLA_U32, },
154
+
[DEVLINK_ATTR_HEALTH_REPORTER_NAME] = { .type = NLA_NUL_STRING, },
155
+
};
156
+
157
+
/* DEVLINK_CMD_HEALTH_REPORTER_DIAGNOSE - do */
158
+
static const struct nla_policy devlink_health_reporter_diagnose_nl_policy[DEVLINK_ATTR_HEALTH_REPORTER_NAME + 1] = {
159
+
[DEVLINK_ATTR_BUS_NAME] = { .type = NLA_NUL_STRING, },
160
+
[DEVLINK_ATTR_DEV_NAME] = { .type = NLA_NUL_STRING, },
161
+
[DEVLINK_ATTR_PORT_INDEX] = { .type = NLA_U32, },
162
+
[DEVLINK_ATTR_HEALTH_REPORTER_NAME] = { .type = NLA_NUL_STRING, },
163
+
};
164
+
165
+
/* DEVLINK_CMD_HEALTH_REPORTER_DUMP_GET - dump */
166
+
static const struct nla_policy devlink_health_reporter_dump_get_nl_policy[DEVLINK_ATTR_HEALTH_REPORTER_NAME + 1] = {
167
+
[DEVLINK_ATTR_BUS_NAME] = { .type = NLA_NUL_STRING, },
168
+
[DEVLINK_ATTR_DEV_NAME] = { .type = NLA_NUL_STRING, },
169
+
[DEVLINK_ATTR_PORT_INDEX] = { .type = NLA_U32, },
170
+
[DEVLINK_ATTR_HEALTH_REPORTER_NAME] = { .type = NLA_NUL_STRING, },
171
+
};
172
+
173
+
/* DEVLINK_CMD_HEALTH_REPORTER_DUMP_CLEAR - do */
174
+
static const struct nla_policy devlink_health_reporter_dump_clear_nl_policy[DEVLINK_ATTR_HEALTH_REPORTER_NAME + 1] = {
175
+
[DEVLINK_ATTR_BUS_NAME] = { .type = NLA_NUL_STRING, },
176
+
[DEVLINK_ATTR_DEV_NAME] = { .type = NLA_NUL_STRING, },
177
+
[DEVLINK_ATTR_PORT_INDEX] = { .type = NLA_U32, },
178
+
[DEVLINK_ATTR_HEALTH_REPORTER_NAME] = { .type = NLA_NUL_STRING, },
179
+
};
180
+
181
+
/* DEVLINK_CMD_FLASH_UPDATE - do */
182
+
static const struct nla_policy devlink_flash_update_nl_policy[DEVLINK_ATTR_FLASH_UPDATE_OVERWRITE_MASK + 1] = {
183
+
[DEVLINK_ATTR_BUS_NAME] = { .type = NLA_NUL_STRING, },
184
+
[DEVLINK_ATTR_DEV_NAME] = { .type = NLA_NUL_STRING, },
185
+
[DEVLINK_ATTR_FLASH_UPDATE_FILE_NAME] = { .type = NLA_NUL_STRING, },
186
+
[DEVLINK_ATTR_FLASH_UPDATE_COMPONENT] = { .type = NLA_NUL_STRING, },
187
+
[DEVLINK_ATTR_FLASH_UPDATE_OVERWRITE_MASK] = NLA_POLICY_BITFIELD32(3),
188
+
};
189
+
359
190
/* DEVLINK_CMD_TRAP_GET - do */
360
191
static const struct nla_policy devlink_trap_get_do_nl_policy[DEVLINK_ATTR_TRAP_NAME + 1] = {
361
192
[DEVLINK_ATTR_BUS_NAME] = { .type = NLA_NUL_STRING, },
···
419
146
static const struct nla_policy devlink_trap_get_dump_nl_policy[DEVLINK_ATTR_DEV_NAME + 1] = {
420
147
[DEVLINK_ATTR_BUS_NAME] = { .type = NLA_NUL_STRING, },
421
148
[DEVLINK_ATTR_DEV_NAME] = { .type = NLA_NUL_STRING, },
149
+
};
150
+
151
+
/* DEVLINK_CMD_TRAP_SET - do */
152
+
static const struct nla_policy devlink_trap_set_nl_policy[DEVLINK_ATTR_TRAP_ACTION + 1] = {
153
+
[DEVLINK_ATTR_BUS_NAME] = { .type = NLA_NUL_STRING, },
154
+
[DEVLINK_ATTR_DEV_NAME] = { .type = NLA_NUL_STRING, },
155
+
[DEVLINK_ATTR_TRAP_NAME] = { .type = NLA_NUL_STRING, },
156
+
[DEVLINK_ATTR_TRAP_ACTION] = NLA_POLICY_MAX(NLA_U8, 2),
422
157
};
423
158
424
159
/* DEVLINK_CMD_TRAP_GROUP_GET - do */
···
442
161
[DEVLINK_ATTR_DEV_NAME] = { .type = NLA_NUL_STRING, },
443
162
};
444
163
164
+
/* DEVLINK_CMD_TRAP_GROUP_SET - do */
165
+
static const struct nla_policy devlink_trap_group_set_nl_policy[DEVLINK_ATTR_TRAP_POLICER_ID + 1] = {
166
+
[DEVLINK_ATTR_BUS_NAME] = { .type = NLA_NUL_STRING, },
167
+
[DEVLINK_ATTR_DEV_NAME] = { .type = NLA_NUL_STRING, },
168
+
[DEVLINK_ATTR_TRAP_GROUP_NAME] = { .type = NLA_NUL_STRING, },
169
+
[DEVLINK_ATTR_TRAP_ACTION] = NLA_POLICY_MAX(NLA_U8, 2),
170
+
[DEVLINK_ATTR_TRAP_POLICER_ID] = { .type = NLA_U32, },
171
+
};
172
+
445
173
/* DEVLINK_CMD_TRAP_POLICER_GET - do */
446
174
static const struct nla_policy devlink_trap_policer_get_do_nl_policy[DEVLINK_ATTR_TRAP_POLICER_ID + 1] = {
447
175
[DEVLINK_ATTR_BUS_NAME] = { .type = NLA_NUL_STRING, },
···
462
172
static const struct nla_policy devlink_trap_policer_get_dump_nl_policy[DEVLINK_ATTR_DEV_NAME + 1] = {
463
173
[DEVLINK_ATTR_BUS_NAME] = { .type = NLA_NUL_STRING, },
464
174
[DEVLINK_ATTR_DEV_NAME] = { .type = NLA_NUL_STRING, },
175
+
};
176
+
177
+
/* DEVLINK_CMD_TRAP_POLICER_SET - do */
178
+
static const struct nla_policy devlink_trap_policer_set_nl_policy[DEVLINK_ATTR_TRAP_POLICER_BURST + 1] = {
179
+
[DEVLINK_ATTR_BUS_NAME] = { .type = NLA_NUL_STRING, },
180
+
[DEVLINK_ATTR_DEV_NAME] = { .type = NLA_NUL_STRING, },
181
+
[DEVLINK_ATTR_TRAP_POLICER_ID] = { .type = NLA_U32, },
182
+
[DEVLINK_ATTR_TRAP_POLICER_RATE] = { .type = NLA_U64, },
183
+
[DEVLINK_ATTR_TRAP_POLICER_BURST] = { .type = NLA_U64, },
184
+
};
185
+
186
+
/* DEVLINK_CMD_HEALTH_REPORTER_TEST - do */
187
+
static const struct nla_policy devlink_health_reporter_test_nl_policy[DEVLINK_ATTR_HEALTH_REPORTER_NAME + 1] = {
188
+
[DEVLINK_ATTR_BUS_NAME] = { .type = NLA_NUL_STRING, },
189
+
[DEVLINK_ATTR_DEV_NAME] = { .type = NLA_NUL_STRING, },
190
+
[DEVLINK_ATTR_PORT_INDEX] = { .type = NLA_U32, },
191
+
[DEVLINK_ATTR_HEALTH_REPORTER_NAME] = { .type = NLA_NUL_STRING, },
465
192
};
466
193
467
194
/* DEVLINK_CMD_RATE_GET - do */
···
495
188
[DEVLINK_ATTR_DEV_NAME] = { .type = NLA_NUL_STRING, },
496
189
};
497
190
191
+
/* DEVLINK_CMD_RATE_SET - do */
192
+
static const struct nla_policy devlink_rate_set_nl_policy[DEVLINK_ATTR_RATE_TX_WEIGHT + 1] = {
193
+
[DEVLINK_ATTR_BUS_NAME] = { .type = NLA_NUL_STRING, },
194
+
[DEVLINK_ATTR_DEV_NAME] = { .type = NLA_NUL_STRING, },
195
+
[DEVLINK_ATTR_RATE_NODE_NAME] = { .type = NLA_NUL_STRING, },
196
+
[DEVLINK_ATTR_RATE_TX_SHARE] = { .type = NLA_U64, },
197
+
[DEVLINK_ATTR_RATE_TX_MAX] = { .type = NLA_U64, },
198
+
[DEVLINK_ATTR_RATE_TX_PRIORITY] = { .type = NLA_U32, },
199
+
[DEVLINK_ATTR_RATE_TX_WEIGHT] = { .type = NLA_U32, },
200
+
[DEVLINK_ATTR_RATE_PARENT_NODE_NAME] = { .type = NLA_NUL_STRING, },
201
+
};
202
+
203
+
/* DEVLINK_CMD_RATE_NEW - do */
204
+
static const struct nla_policy devlink_rate_new_nl_policy[DEVLINK_ATTR_RATE_TX_WEIGHT + 1] = {
205
+
[DEVLINK_ATTR_BUS_NAME] = { .type = NLA_NUL_STRING, },
206
+
[DEVLINK_ATTR_DEV_NAME] = { .type = NLA_NUL_STRING, },
207
+
[DEVLINK_ATTR_RATE_NODE_NAME] = { .type = NLA_NUL_STRING, },
208
+
[DEVLINK_ATTR_RATE_TX_SHARE] = { .type = NLA_U64, },
209
+
[DEVLINK_ATTR_RATE_TX_MAX] = { .type = NLA_U64, },
210
+
[DEVLINK_ATTR_RATE_TX_PRIORITY] = { .type = NLA_U32, },
211
+
[DEVLINK_ATTR_RATE_TX_WEIGHT] = { .type = NLA_U32, },
212
+
[DEVLINK_ATTR_RATE_PARENT_NODE_NAME] = { .type = NLA_NUL_STRING, },
213
+
};
214
+
215
+
/* DEVLINK_CMD_RATE_DEL - do */
216
+
static const struct nla_policy devlink_rate_del_nl_policy[DEVLINK_ATTR_RATE_NODE_NAME + 1] = {
217
+
[DEVLINK_ATTR_BUS_NAME] = { .type = NLA_NUL_STRING, },
218
+
[DEVLINK_ATTR_DEV_NAME] = { .type = NLA_NUL_STRING, },
219
+
[DEVLINK_ATTR_RATE_NODE_NAME] = { .type = NLA_NUL_STRING, },
220
+
};
221
+
498
222
/* DEVLINK_CMD_LINECARD_GET - do */
499
223
static const struct nla_policy devlink_linecard_get_do_nl_policy[DEVLINK_ATTR_LINECARD_INDEX + 1] = {
500
224
[DEVLINK_ATTR_BUS_NAME] = { .type = NLA_NUL_STRING, },
···
539
201
[DEVLINK_ATTR_DEV_NAME] = { .type = NLA_NUL_STRING, },
540
202
};
541
203
204
+
/* DEVLINK_CMD_LINECARD_SET - do */
205
+
static const struct nla_policy devlink_linecard_set_nl_policy[DEVLINK_ATTR_LINECARD_TYPE + 1] = {
206
+
[DEVLINK_ATTR_BUS_NAME] = { .type = NLA_NUL_STRING, },
207
+
[DEVLINK_ATTR_DEV_NAME] = { .type = NLA_NUL_STRING, },
208
+
[DEVLINK_ATTR_LINECARD_INDEX] = { .type = NLA_U32, },
209
+
[DEVLINK_ATTR_LINECARD_TYPE] = { .type = NLA_NUL_STRING, },
210
+
};
211
+
542
212
/* DEVLINK_CMD_SELFTESTS_GET - do */
543
213
static const struct nla_policy devlink_selftests_get_nl_policy[DEVLINK_ATTR_DEV_NAME + 1] = {
544
214
[DEVLINK_ATTR_BUS_NAME] = { .type = NLA_NUL_STRING, },
545
215
[DEVLINK_ATTR_DEV_NAME] = { .type = NLA_NUL_STRING, },
546
216
};
547
217
218
+
/* DEVLINK_CMD_SELFTESTS_RUN - do */
219
+
static const struct nla_policy devlink_selftests_run_nl_policy[DEVLINK_ATTR_SELFTESTS + 1] = {
220
+
[DEVLINK_ATTR_BUS_NAME] = { .type = NLA_NUL_STRING, },
221
+
[DEVLINK_ATTR_DEV_NAME] = { .type = NLA_NUL_STRING, },
222
+
[DEVLINK_ATTR_SELFTESTS] = NLA_POLICY_NESTED(devlink_dl_selftest_id_nl_policy),
223
+
};
224
+
548
225
/* Ops table for devlink */
549
-
const struct genl_split_ops devlink_nl_ops[32] = {
226
+
const struct genl_split_ops devlink_nl_ops[73] = {
550
227
{
551
228
.cmd = DEVLINK_CMD_GET,
552
229
.validate = GENL_DONT_VALIDATE_STRICT,
···
594
241
.policy = devlink_port_get_dump_nl_policy,
595
242
.maxattr = DEVLINK_ATTR_DEV_NAME,
596
243
.flags = GENL_CMD_CAP_DUMP,
244
+
},
245
+
{
246
+
.cmd = DEVLINK_CMD_PORT_SET,
247
+
.validate = GENL_DONT_VALIDATE_STRICT,
248
+
.pre_doit = devlink_nl_pre_doit_port,
249
+
.doit = devlink_nl_port_set_doit,
250
+
.post_doit = devlink_nl_post_doit,
251
+
.policy = devlink_port_set_nl_policy,
252
+
.maxattr = DEVLINK_ATTR_PORT_FUNCTION,
253
+
.flags = GENL_ADMIN_PERM | GENL_CMD_CAP_DO,
254
+
},
255
+
{
256
+
.cmd = DEVLINK_CMD_PORT_NEW,
257
+
.validate = GENL_DONT_VALIDATE_STRICT,
258
+
.pre_doit = devlink_nl_pre_doit,
259
+
.doit = devlink_nl_port_new_doit,
260
+
.post_doit = devlink_nl_post_doit,
261
+
.policy = devlink_port_new_nl_policy,
262
+
.maxattr = DEVLINK_ATTR_PORT_PCI_SF_NUMBER,
263
+
.flags = GENL_ADMIN_PERM | GENL_CMD_CAP_DO,
264
+
},
265
+
{
266
+
.cmd = DEVLINK_CMD_PORT_DEL,
267
+
.validate = GENL_DONT_VALIDATE_STRICT,
268
+
.pre_doit = devlink_nl_pre_doit_port,
269
+
.doit = devlink_nl_port_del_doit,
270
+
.post_doit = devlink_nl_post_doit,
271
+
.policy = devlink_port_del_nl_policy,
272
+
.maxattr = DEVLINK_ATTR_PORT_INDEX,
273
+
.flags = GENL_ADMIN_PERM | GENL_CMD_CAP_DO,
274
+
},
275
+
{
276
+
.cmd = DEVLINK_CMD_PORT_SPLIT,
277
+
.validate = GENL_DONT_VALIDATE_STRICT,
278
+
.pre_doit = devlink_nl_pre_doit_port,
279
+
.doit = devlink_nl_port_split_doit,
280
+
.post_doit = devlink_nl_post_doit,
281
+
.policy = devlink_port_split_nl_policy,
282
+
.maxattr = DEVLINK_ATTR_PORT_SPLIT_COUNT,
283
+
.flags = GENL_ADMIN_PERM | GENL_CMD_CAP_DO,
284
+
},
285
+
{
286
+
.cmd = DEVLINK_CMD_PORT_UNSPLIT,
287
+
.validate = GENL_DONT_VALIDATE_STRICT,
288
+
.pre_doit = devlink_nl_pre_doit_port,
289
+
.doit = devlink_nl_port_unsplit_doit,
290
+
.post_doit = devlink_nl_post_doit,
291
+
.policy = devlink_port_unsplit_nl_policy,
292
+
.maxattr = DEVLINK_ATTR_PORT_INDEX,
293
+
.flags = GENL_ADMIN_PERM | GENL_CMD_CAP_DO,
597
294
},
598
295
{
599
296
.cmd = DEVLINK_CMD_SB_GET,
···
680
277
.flags = GENL_CMD_CAP_DUMP,
681
278
},
682
279
{
280
+
.cmd = DEVLINK_CMD_SB_POOL_SET,
281
+
.validate = GENL_DONT_VALIDATE_STRICT,
282
+
.pre_doit = devlink_nl_pre_doit,
283
+
.doit = devlink_nl_sb_pool_set_doit,
284
+
.post_doit = devlink_nl_post_doit,
285
+
.policy = devlink_sb_pool_set_nl_policy,
286
+
.maxattr = DEVLINK_ATTR_SB_POOL_THRESHOLD_TYPE,
287
+
.flags = GENL_ADMIN_PERM | GENL_CMD_CAP_DO,
288
+
},
289
+
{
683
290
.cmd = DEVLINK_CMD_SB_PORT_POOL_GET,
684
291
.validate = GENL_DONT_VALIDATE_STRICT,
685
292
.pre_doit = devlink_nl_pre_doit_port,
···
705
292
.policy = devlink_sb_port_pool_get_dump_nl_policy,
706
293
.maxattr = DEVLINK_ATTR_DEV_NAME,
707
294
.flags = GENL_CMD_CAP_DUMP,
295
+
},
296
+
{
297
+
.cmd = DEVLINK_CMD_SB_PORT_POOL_SET,
298
+
.validate = GENL_DONT_VALIDATE_STRICT,
299
+
.pre_doit = devlink_nl_pre_doit_port,
300
+
.doit = devlink_nl_sb_port_pool_set_doit,
301
+
.post_doit = devlink_nl_post_doit,
302
+
.policy = devlink_sb_port_pool_set_nl_policy,
303
+
.maxattr = DEVLINK_ATTR_SB_THRESHOLD,
304
+
.flags = GENL_ADMIN_PERM | GENL_CMD_CAP_DO,
708
305
},
709
306
{
710
307
.cmd = DEVLINK_CMD_SB_TC_POOL_BIND_GET,
···
734
311
.flags = GENL_CMD_CAP_DUMP,
735
312
},
736
313
{
314
+
.cmd = DEVLINK_CMD_SB_TC_POOL_BIND_SET,
315
+
.validate = GENL_DONT_VALIDATE_STRICT,
316
+
.pre_doit = devlink_nl_pre_doit_port,
317
+
.doit = devlink_nl_sb_tc_pool_bind_set_doit,
318
+
.post_doit = devlink_nl_post_doit,
319
+
.policy = devlink_sb_tc_pool_bind_set_nl_policy,
320
+
.maxattr = DEVLINK_ATTR_SB_TC_INDEX,
321
+
.flags = GENL_ADMIN_PERM | GENL_CMD_CAP_DO,
322
+
},
323
+
{
324
+
.cmd = DEVLINK_CMD_SB_OCC_SNAPSHOT,
325
+
.validate = GENL_DONT_VALIDATE_STRICT,
326
+
.pre_doit = devlink_nl_pre_doit,
327
+
.doit = devlink_nl_sb_occ_snapshot_doit,
328
+
.post_doit = devlink_nl_post_doit,
329
+
.policy = devlink_sb_occ_snapshot_nl_policy,
330
+
.maxattr = DEVLINK_ATTR_SB_INDEX,
331
+
.flags = GENL_ADMIN_PERM | GENL_CMD_CAP_DO,
332
+
},
333
+
{
334
+
.cmd = DEVLINK_CMD_SB_OCC_MAX_CLEAR,
335
+
.validate = GENL_DONT_VALIDATE_STRICT,
336
+
.pre_doit = devlink_nl_pre_doit,
337
+
.doit = devlink_nl_sb_occ_max_clear_doit,
338
+
.post_doit = devlink_nl_post_doit,
339
+
.policy = devlink_sb_occ_max_clear_nl_policy,
340
+
.maxattr = DEVLINK_ATTR_SB_INDEX,
341
+
.flags = GENL_ADMIN_PERM | GENL_CMD_CAP_DO,
342
+
},
343
+
{
344
+
.cmd = DEVLINK_CMD_ESWITCH_GET,
345
+
.validate = GENL_DONT_VALIDATE_STRICT,
346
+
.pre_doit = devlink_nl_pre_doit,
347
+
.doit = devlink_nl_eswitch_get_doit,
348
+
.post_doit = devlink_nl_post_doit,
349
+
.policy = devlink_eswitch_get_nl_policy,
350
+
.maxattr = DEVLINK_ATTR_DEV_NAME,
351
+
.flags = GENL_ADMIN_PERM | GENL_CMD_CAP_DO,
352
+
},
353
+
{
354
+
.cmd = DEVLINK_CMD_ESWITCH_SET,
355
+
.validate = GENL_DONT_VALIDATE_STRICT,
356
+
.pre_doit = devlink_nl_pre_doit,
357
+
.doit = devlink_nl_eswitch_set_doit,
358
+
.post_doit = devlink_nl_post_doit,
359
+
.policy = devlink_eswitch_set_nl_policy,
360
+
.maxattr = DEVLINK_ATTR_ESWITCH_ENCAP_MODE,
361
+
.flags = GENL_ADMIN_PERM | GENL_CMD_CAP_DO,
362
+
},
363
+
{
364
+
.cmd = DEVLINK_CMD_DPIPE_TABLE_GET,
365
+
.validate = GENL_DONT_VALIDATE_STRICT,
366
+
.pre_doit = devlink_nl_pre_doit,
367
+
.doit = devlink_nl_dpipe_table_get_doit,
368
+
.post_doit = devlink_nl_post_doit,
369
+
.policy = devlink_dpipe_table_get_nl_policy,
370
+
.maxattr = DEVLINK_ATTR_DPIPE_TABLE_NAME,
371
+
.flags = GENL_CMD_CAP_DO,
372
+
},
373
+
{
374
+
.cmd = DEVLINK_CMD_DPIPE_ENTRIES_GET,
375
+
.validate = GENL_DONT_VALIDATE_STRICT,
376
+
.pre_doit = devlink_nl_pre_doit,
377
+
.doit = devlink_nl_dpipe_entries_get_doit,
378
+
.post_doit = devlink_nl_post_doit,
379
+
.policy = devlink_dpipe_entries_get_nl_policy,
380
+
.maxattr = DEVLINK_ATTR_DPIPE_TABLE_NAME,
381
+
.flags = GENL_CMD_CAP_DO,
382
+
},
383
+
{
384
+
.cmd = DEVLINK_CMD_DPIPE_HEADERS_GET,
385
+
.validate = GENL_DONT_VALIDATE_STRICT,
386
+
.pre_doit = devlink_nl_pre_doit,
387
+
.doit = devlink_nl_dpipe_headers_get_doit,
388
+
.post_doit = devlink_nl_post_doit,
389
+
.policy = devlink_dpipe_headers_get_nl_policy,
390
+
.maxattr = DEVLINK_ATTR_DEV_NAME,
391
+
.flags = GENL_CMD_CAP_DO,
392
+
},
393
+
{
394
+
.cmd = DEVLINK_CMD_DPIPE_TABLE_COUNTERS_SET,
395
+
.validate = GENL_DONT_VALIDATE_STRICT,
396
+
.pre_doit = devlink_nl_pre_doit,
397
+
.doit = devlink_nl_dpipe_table_counters_set_doit,
398
+
.post_doit = devlink_nl_post_doit,
399
+
.policy = devlink_dpipe_table_counters_set_nl_policy,
400
+
.maxattr = DEVLINK_ATTR_DPIPE_TABLE_COUNTERS_ENABLED,
401
+
.flags = GENL_ADMIN_PERM | GENL_CMD_CAP_DO,
402
+
},
403
+
{
404
+
.cmd = DEVLINK_CMD_RESOURCE_SET,
405
+
.validate = GENL_DONT_VALIDATE_STRICT,
406
+
.pre_doit = devlink_nl_pre_doit,
407
+
.doit = devlink_nl_resource_set_doit,
408
+
.post_doit = devlink_nl_post_doit,
409
+
.policy = devlink_resource_set_nl_policy,
410
+
.maxattr = DEVLINK_ATTR_RESOURCE_SIZE,
411
+
.flags = GENL_ADMIN_PERM | GENL_CMD_CAP_DO,
412
+
},
413
+
{
414
+
.cmd = DEVLINK_CMD_RESOURCE_DUMP,
415
+
.validate = GENL_DONT_VALIDATE_STRICT,
416
+
.pre_doit = devlink_nl_pre_doit,
417
+
.doit = devlink_nl_resource_dump_doit,
418
+
.post_doit = devlink_nl_post_doit,
419
+
.policy = devlink_resource_dump_nl_policy,
420
+
.maxattr = DEVLINK_ATTR_DEV_NAME,
421
+
.flags = GENL_CMD_CAP_DO,
422
+
},
423
+
{
424
+
.cmd = DEVLINK_CMD_RELOAD,
425
+
.validate = GENL_DONT_VALIDATE_STRICT,
426
+
.pre_doit = devlink_nl_pre_doit,
427
+
.doit = devlink_nl_reload_doit,
428
+
.post_doit = devlink_nl_post_doit,
429
+
.policy = devlink_reload_nl_policy,
430
+
.maxattr = DEVLINK_ATTR_RELOAD_LIMITS,
431
+
.flags = GENL_ADMIN_PERM | GENL_CMD_CAP_DO,
432
+
},
433
+
{
737
434
.cmd = DEVLINK_CMD_PARAM_GET,
738
435
.validate = GENL_DONT_VALIDATE_STRICT,
739
436
.pre_doit = devlink_nl_pre_doit,
···
871
328
.flags = GENL_CMD_CAP_DUMP,
872
329
},
873
330
{
331
+
.cmd = DEVLINK_CMD_PARAM_SET,
332
+
.validate = GENL_DONT_VALIDATE_STRICT,
333
+
.pre_doit = devlink_nl_pre_doit,
334
+
.doit = devlink_nl_param_set_doit,
335
+
.post_doit = devlink_nl_post_doit,
336
+
.policy = devlink_param_set_nl_policy,
337
+
.maxattr = DEVLINK_ATTR_PARAM_VALUE_CMODE,
338
+
.flags = GENL_ADMIN_PERM | GENL_CMD_CAP_DO,
339
+
},
340
+
{
874
341
.cmd = DEVLINK_CMD_REGION_GET,
875
342
.validate = GENL_DONT_VALIDATE_STRICT,
876
343
.pre_doit = devlink_nl_pre_doit_port_optional,
···
896
343
.policy = devlink_region_get_dump_nl_policy,
897
344
.maxattr = DEVLINK_ATTR_DEV_NAME,
898
345
.flags = GENL_CMD_CAP_DUMP,
346
+
},
347
+
{
348
+
.cmd = DEVLINK_CMD_REGION_NEW,
349
+
.validate = GENL_DONT_VALIDATE_STRICT,
350
+
.pre_doit = devlink_nl_pre_doit_port_optional,
351
+
.doit = devlink_nl_region_new_doit,
352
+
.post_doit = devlink_nl_post_doit,
353
+
.policy = devlink_region_new_nl_policy,
354
+
.maxattr = DEVLINK_ATTR_REGION_SNAPSHOT_ID,
355
+
.flags = GENL_ADMIN_PERM | GENL_CMD_CAP_DO,
356
+
},
357
+
{
358
+
.cmd = DEVLINK_CMD_REGION_DEL,
359
+
.validate = GENL_DONT_VALIDATE_STRICT,
360
+
.pre_doit = devlink_nl_pre_doit_port_optional,
361
+
.doit = devlink_nl_region_del_doit,
362
+
.post_doit = devlink_nl_post_doit,
363
+
.policy = devlink_region_del_nl_policy,
364
+
.maxattr = DEVLINK_ATTR_REGION_SNAPSHOT_ID,
365
+
.flags = GENL_ADMIN_PERM | GENL_CMD_CAP_DO,
366
+
},
367
+
{
368
+
.cmd = DEVLINK_CMD_REGION_READ,
369
+
.validate = GENL_DONT_VALIDATE_DUMP_STRICT,
370
+
.dumpit = devlink_nl_region_read_dumpit,
371
+
.policy = devlink_region_read_nl_policy,
372
+
.maxattr = DEVLINK_ATTR_REGION_DIRECT,
373
+
.flags = GENL_ADMIN_PERM | GENL_CMD_CAP_DUMP,
374
+
},
375
+
{
376
+
.cmd = DEVLINK_CMD_PORT_PARAM_GET,
377
+
.validate = GENL_DONT_VALIDATE_STRICT,
378
+
.pre_doit = devlink_nl_pre_doit_port,
379
+
.doit = devlink_nl_port_param_get_doit,
380
+
.post_doit = devlink_nl_post_doit,
381
+
.policy = devlink_port_param_get_nl_policy,
382
+
.maxattr = DEVLINK_ATTR_PORT_INDEX,
383
+
.flags = GENL_CMD_CAP_DO,
384
+
},
385
+
{
386
+
.cmd = DEVLINK_CMD_PORT_PARAM_GET,
387
+
.validate = GENL_DONT_VALIDATE_DUMP_STRICT,
388
+
.dumpit = devlink_nl_port_param_get_dumpit,
389
+
.flags = GENL_CMD_CAP_DUMP,
390
+
},
391
+
{
392
+
.cmd = DEVLINK_CMD_PORT_PARAM_SET,
393
+
.validate = GENL_DONT_VALIDATE_STRICT,
394
+
.pre_doit = devlink_nl_pre_doit_port,
395
+
.doit = devlink_nl_port_param_set_doit,
396
+
.post_doit = devlink_nl_post_doit,
397
+
.policy = devlink_port_param_set_nl_policy,
398
+
.maxattr = DEVLINK_ATTR_PORT_INDEX,
399
+
.flags = GENL_ADMIN_PERM | GENL_CMD_CAP_DO,
899
400
},
900
401
{
901
402
.cmd = DEVLINK_CMD_INFO_GET,
···
985
378
.flags = GENL_CMD_CAP_DUMP,
986
379
},
987
380
{
381
+
.cmd = DEVLINK_CMD_HEALTH_REPORTER_SET,
382
+
.validate = GENL_DONT_VALIDATE_STRICT,
383
+
.pre_doit = devlink_nl_pre_doit_port_optional,
384
+
.doit = devlink_nl_health_reporter_set_doit,
385
+
.post_doit = devlink_nl_post_doit,
386
+
.policy = devlink_health_reporter_set_nl_policy,
387
+
.maxattr = DEVLINK_ATTR_HEALTH_REPORTER_AUTO_DUMP,
388
+
.flags = GENL_ADMIN_PERM | GENL_CMD_CAP_DO,
389
+
},
390
+
{
391
+
.cmd = DEVLINK_CMD_HEALTH_REPORTER_RECOVER,
392
+
.validate = GENL_DONT_VALIDATE_STRICT,
393
+
.pre_doit = devlink_nl_pre_doit_port_optional,
394
+
.doit = devlink_nl_health_reporter_recover_doit,
395
+
.post_doit = devlink_nl_post_doit,
396
+
.policy = devlink_health_reporter_recover_nl_policy,
397
+
.maxattr = DEVLINK_ATTR_HEALTH_REPORTER_NAME,
398
+
.flags = GENL_ADMIN_PERM | GENL_CMD_CAP_DO,
399
+
},
400
+
{
401
+
.cmd = DEVLINK_CMD_HEALTH_REPORTER_DIAGNOSE,
402
+
.validate = GENL_DONT_VALIDATE_STRICT,
403
+
.pre_doit = devlink_nl_pre_doit_port_optional,
404
+
.doit = devlink_nl_health_reporter_diagnose_doit,
405
+
.post_doit = devlink_nl_post_doit,
406
+
.policy = devlink_health_reporter_diagnose_nl_policy,
407
+
.maxattr = DEVLINK_ATTR_HEALTH_REPORTER_NAME,
408
+
.flags = GENL_ADMIN_PERM | GENL_CMD_CAP_DO,
409
+
},
410
+
{
411
+
.cmd = DEVLINK_CMD_HEALTH_REPORTER_DUMP_GET,
412
+
.validate = GENL_DONT_VALIDATE_DUMP_STRICT,
413
+
.dumpit = devlink_nl_health_reporter_dump_get_dumpit,
414
+
.policy = devlink_health_reporter_dump_get_nl_policy,
415
+
.maxattr = DEVLINK_ATTR_HEALTH_REPORTER_NAME,
416
+
.flags = GENL_ADMIN_PERM | GENL_CMD_CAP_DUMP,
417
+
},
418
+
{
419
+
.cmd = DEVLINK_CMD_HEALTH_REPORTER_DUMP_CLEAR,
420
+
.validate = GENL_DONT_VALIDATE_STRICT,
421
+
.pre_doit = devlink_nl_pre_doit_port_optional,
422
+
.doit = devlink_nl_health_reporter_dump_clear_doit,
423
+
.post_doit = devlink_nl_post_doit,
424
+
.policy = devlink_health_reporter_dump_clear_nl_policy,
425
+
.maxattr = DEVLINK_ATTR_HEALTH_REPORTER_NAME,
426
+
.flags = GENL_ADMIN_PERM | GENL_CMD_CAP_DO,
427
+
},
428
+
{
429
+
.cmd = DEVLINK_CMD_FLASH_UPDATE,
430
+
.validate = GENL_DONT_VALIDATE_STRICT,
431
+
.pre_doit = devlink_nl_pre_doit,
432
+
.doit = devlink_nl_flash_update_doit,
433
+
.post_doit = devlink_nl_post_doit,
434
+
.policy = devlink_flash_update_nl_policy,
435
+
.maxattr = DEVLINK_ATTR_FLASH_UPDATE_OVERWRITE_MASK,
436
+
.flags = GENL_ADMIN_PERM | GENL_CMD_CAP_DO,
437
+
},
438
+
{
988
439
.cmd = DEVLINK_CMD_TRAP_GET,
989
440
.validate = GENL_DONT_VALIDATE_STRICT,
990
441
.pre_doit = devlink_nl_pre_doit,
···
1058
393
.policy = devlink_trap_get_dump_nl_policy,
1059
394
.maxattr = DEVLINK_ATTR_DEV_NAME,
1060
395
.flags = GENL_CMD_CAP_DUMP,
396
+
},
397
+
{
398
+
.cmd = DEVLINK_CMD_TRAP_SET,
399
+
.validate = GENL_DONT_VALIDATE_STRICT,
400
+
.pre_doit = devlink_nl_pre_doit,
401
+
.doit = devlink_nl_trap_set_doit,
402
+
.post_doit = devlink_nl_post_doit,
403
+
.policy = devlink_trap_set_nl_policy,
404
+
.maxattr = DEVLINK_ATTR_TRAP_ACTION,
405
+
.flags = GENL_ADMIN_PERM | GENL_CMD_CAP_DO,
1061
406
},
1062
407
{
1063
408
.cmd = DEVLINK_CMD_TRAP_GROUP_GET,
···
1087
412
.flags = GENL_CMD_CAP_DUMP,
1088
413
},
1089
414
{
415
+
.cmd = DEVLINK_CMD_TRAP_GROUP_SET,
416
+
.validate = GENL_DONT_VALIDATE_STRICT,
417
+
.pre_doit = devlink_nl_pre_doit,
418
+
.doit = devlink_nl_trap_group_set_doit,
419
+
.post_doit = devlink_nl_post_doit,
420
+
.policy = devlink_trap_group_set_nl_policy,
421
+
.maxattr = DEVLINK_ATTR_TRAP_POLICER_ID,
422
+
.flags = GENL_ADMIN_PERM | GENL_CMD_CAP_DO,
423
+
},
424
+
{
1090
425
.cmd = DEVLINK_CMD_TRAP_POLICER_GET,
1091
426
.validate = GENL_DONT_VALIDATE_STRICT,
1092
427
.pre_doit = devlink_nl_pre_doit,
···
1112
427
.policy = devlink_trap_policer_get_dump_nl_policy,
1113
428
.maxattr = DEVLINK_ATTR_DEV_NAME,
1114
429
.flags = GENL_CMD_CAP_DUMP,
430
+
},
431
+
{
432
+
.cmd = DEVLINK_CMD_TRAP_POLICER_SET,
433
+
.validate = GENL_DONT_VALIDATE_STRICT,
434
+
.pre_doit = devlink_nl_pre_doit,
435
+
.doit = devlink_nl_trap_policer_set_doit,
436
+
.post_doit = devlink_nl_post_doit,
437
+
.policy = devlink_trap_policer_set_nl_policy,
438
+
.maxattr = DEVLINK_ATTR_TRAP_POLICER_BURST,
439
+
.flags = GENL_ADMIN_PERM | GENL_CMD_CAP_DO,
440
+
},
441
+
{
442
+
.cmd = DEVLINK_CMD_HEALTH_REPORTER_TEST,
443
+
.validate = GENL_DONT_VALIDATE_STRICT,
444
+
.pre_doit = devlink_nl_pre_doit_port_optional,
445
+
.doit = devlink_nl_health_reporter_test_doit,
446
+
.post_doit = devlink_nl_post_doit,
447
+
.policy = devlink_health_reporter_test_nl_policy,
448
+
.maxattr = DEVLINK_ATTR_HEALTH_REPORTER_NAME,
449
+
.flags = GENL_ADMIN_PERM | GENL_CMD_CAP_DO,
1115
450
},
1116
451
{
1117
452
.cmd = DEVLINK_CMD_RATE_GET,
···
1151
446
.flags = GENL_CMD_CAP_DUMP,
1152
447
},
1153
448
{
449
+
.cmd = DEVLINK_CMD_RATE_SET,
450
+
.validate = GENL_DONT_VALIDATE_STRICT,
451
+
.pre_doit = devlink_nl_pre_doit,
452
+
.doit = devlink_nl_rate_set_doit,
453
+
.post_doit = devlink_nl_post_doit,
454
+
.policy = devlink_rate_set_nl_policy,
455
+
.maxattr = DEVLINK_ATTR_RATE_TX_WEIGHT,
456
+
.flags = GENL_ADMIN_PERM | GENL_CMD_CAP_DO,
457
+
},
458
+
{
459
+
.cmd = DEVLINK_CMD_RATE_NEW,
460
+
.validate = GENL_DONT_VALIDATE_STRICT,
461
+
.pre_doit = devlink_nl_pre_doit,
462
+
.doit = devlink_nl_rate_new_doit,
463
+
.post_doit = devlink_nl_post_doit,
464
+
.policy = devlink_rate_new_nl_policy,
465
+
.maxattr = DEVLINK_ATTR_RATE_TX_WEIGHT,
466
+
.flags = GENL_ADMIN_PERM | GENL_CMD_CAP_DO,
467
+
},
468
+
{
469
+
.cmd = DEVLINK_CMD_RATE_DEL,
470
+
.validate = GENL_DONT_VALIDATE_STRICT,
471
+
.pre_doit = devlink_nl_pre_doit,
472
+
.doit = devlink_nl_rate_del_doit,
473
+
.post_doit = devlink_nl_post_doit,
474
+
.policy = devlink_rate_del_nl_policy,
475
+
.maxattr = DEVLINK_ATTR_RATE_NODE_NAME,
476
+
.flags = GENL_ADMIN_PERM | GENL_CMD_CAP_DO,
477
+
},
478
+
{
1154
479
.cmd = DEVLINK_CMD_LINECARD_GET,
1155
480
.validate = GENL_DONT_VALIDATE_STRICT,
1156
481
.pre_doit = devlink_nl_pre_doit,
···
1198
463
.flags = GENL_CMD_CAP_DUMP,
1199
464
},
1200
465
{
466
+
.cmd = DEVLINK_CMD_LINECARD_SET,
467
+
.validate = GENL_DONT_VALIDATE_STRICT,
468
+
.pre_doit = devlink_nl_pre_doit,
469
+
.doit = devlink_nl_linecard_set_doit,
470
+
.post_doit = devlink_nl_post_doit,
471
+
.policy = devlink_linecard_set_nl_policy,
472
+
.maxattr = DEVLINK_ATTR_LINECARD_TYPE,
473
+
.flags = GENL_ADMIN_PERM | GENL_CMD_CAP_DO,
474
+
},
475
+
{
1201
476
.cmd = DEVLINK_CMD_SELFTESTS_GET,
1202
477
.validate = GENL_DONT_VALIDATE_STRICT,
1203
478
.pre_doit = devlink_nl_pre_doit,
···
1222
477
.validate = GENL_DONT_VALIDATE_DUMP,
1223
478
.dumpit = devlink_nl_selftests_get_dumpit,
1224
479
.flags = GENL_CMD_CAP_DUMP,
480
+
},
481
+
{
482
+
.cmd = DEVLINK_CMD_SELFTESTS_RUN,
483
+
.validate = GENL_DONT_VALIDATE_STRICT,
484
+
.pre_doit = devlink_nl_pre_doit,
485
+
.doit = devlink_nl_selftests_run_doit,
486
+
.post_doit = devlink_nl_post_doit,
487
+
.policy = devlink_selftests_run_nl_policy,
488
+
.maxattr = DEVLINK_ATTR_SELFTESTS,
489
+
.flags = GENL_ADMIN_PERM | GENL_CMD_CAP_DO,
1225
490
},
1226
491
};
+63
-1
net/devlink/netlink_gen.h
+63
-1
net/devlink/netlink_gen.h
···
11
11
12
12
#include <uapi/linux/devlink.h>
13
13
14
+
/* Common nested types */
15
+
extern const struct nla_policy devlink_dl_port_function_nl_policy[DEVLINK_PORT_FN_ATTR_CAPS + 1];
16
+
extern const struct nla_policy devlink_dl_selftest_id_nl_policy[DEVLINK_ATTR_SELFTEST_ID_FLASH + 1];
17
+
14
18
/* Ops table for devlink */
15
-
extern const struct genl_split_ops devlink_nl_ops[32];
19
+
extern const struct genl_split_ops devlink_nl_ops[73];
16
20
17
21
int devlink_nl_pre_doit(const struct genl_split_ops *ops, struct sk_buff *skb,
18
22
struct genl_info *info);
···
34
30
int devlink_nl_port_get_doit(struct sk_buff *skb, struct genl_info *info);
35
31
int devlink_nl_port_get_dumpit(struct sk_buff *skb,
36
32
struct netlink_callback *cb);
33
+
int devlink_nl_port_set_doit(struct sk_buff *skb, struct genl_info *info);
34
+
int devlink_nl_port_new_doit(struct sk_buff *skb, struct genl_info *info);
35
+
int devlink_nl_port_del_doit(struct sk_buff *skb, struct genl_info *info);
36
+
int devlink_nl_port_split_doit(struct sk_buff *skb, struct genl_info *info);
37
+
int devlink_nl_port_unsplit_doit(struct sk_buff *skb, struct genl_info *info);
37
38
int devlink_nl_sb_get_doit(struct sk_buff *skb, struct genl_info *info);
38
39
int devlink_nl_sb_get_dumpit(struct sk_buff *skb, struct netlink_callback *cb);
39
40
int devlink_nl_sb_pool_get_doit(struct sk_buff *skb, struct genl_info *info);
40
41
int devlink_nl_sb_pool_get_dumpit(struct sk_buff *skb,
41
42
struct netlink_callback *cb);
43
+
int devlink_nl_sb_pool_set_doit(struct sk_buff *skb, struct genl_info *info);
42
44
int devlink_nl_sb_port_pool_get_doit(struct sk_buff *skb,
43
45
struct genl_info *info);
44
46
int devlink_nl_sb_port_pool_get_dumpit(struct sk_buff *skb,
45
47
struct netlink_callback *cb);
48
+
int devlink_nl_sb_port_pool_set_doit(struct sk_buff *skb,
49
+
struct genl_info *info);
46
50
int devlink_nl_sb_tc_pool_bind_get_doit(struct sk_buff *skb,
47
51
struct genl_info *info);
48
52
int devlink_nl_sb_tc_pool_bind_get_dumpit(struct sk_buff *skb,
49
53
struct netlink_callback *cb);
54
+
int devlink_nl_sb_tc_pool_bind_set_doit(struct sk_buff *skb,
55
+
struct genl_info *info);
56
+
int devlink_nl_sb_occ_snapshot_doit(struct sk_buff *skb,
57
+
struct genl_info *info);
58
+
int devlink_nl_sb_occ_max_clear_doit(struct sk_buff *skb,
59
+
struct genl_info *info);
60
+
int devlink_nl_eswitch_get_doit(struct sk_buff *skb, struct genl_info *info);
61
+
int devlink_nl_eswitch_set_doit(struct sk_buff *skb, struct genl_info *info);
62
+
int devlink_nl_dpipe_table_get_doit(struct sk_buff *skb,
63
+
struct genl_info *info);
64
+
int devlink_nl_dpipe_entries_get_doit(struct sk_buff *skb,
65
+
struct genl_info *info);
66
+
int devlink_nl_dpipe_headers_get_doit(struct sk_buff *skb,
67
+
struct genl_info *info);
68
+
int devlink_nl_dpipe_table_counters_set_doit(struct sk_buff *skb,
69
+
struct genl_info *info);
70
+
int devlink_nl_resource_set_doit(struct sk_buff *skb, struct genl_info *info);
71
+
int devlink_nl_resource_dump_doit(struct sk_buff *skb, struct genl_info *info);
72
+
int devlink_nl_reload_doit(struct sk_buff *skb, struct genl_info *info);
50
73
int devlink_nl_param_get_doit(struct sk_buff *skb, struct genl_info *info);
51
74
int devlink_nl_param_get_dumpit(struct sk_buff *skb,
52
75
struct netlink_callback *cb);
76
+
int devlink_nl_param_set_doit(struct sk_buff *skb, struct genl_info *info);
53
77
int devlink_nl_region_get_doit(struct sk_buff *skb, struct genl_info *info);
54
78
int devlink_nl_region_get_dumpit(struct sk_buff *skb,
55
79
struct netlink_callback *cb);
80
+
int devlink_nl_region_new_doit(struct sk_buff *skb, struct genl_info *info);
81
+
int devlink_nl_region_del_doit(struct sk_buff *skb, struct genl_info *info);
82
+
int devlink_nl_region_read_dumpit(struct sk_buff *skb,
83
+
struct netlink_callback *cb);
84
+
int devlink_nl_port_param_get_doit(struct sk_buff *skb, struct genl_info *info);
85
+
int devlink_nl_port_param_get_dumpit(struct sk_buff *skb,
86
+
struct netlink_callback *cb);
87
+
int devlink_nl_port_param_set_doit(struct sk_buff *skb, struct genl_info *info);
56
88
int devlink_nl_info_get_doit(struct sk_buff *skb, struct genl_info *info);
57
89
int devlink_nl_info_get_dumpit(struct sk_buff *skb,
58
90
struct netlink_callback *cb);
···
96
56
struct genl_info *info);
97
57
int devlink_nl_health_reporter_get_dumpit(struct sk_buff *skb,
98
58
struct netlink_callback *cb);
59
+
int devlink_nl_health_reporter_set_doit(struct sk_buff *skb,
60
+
struct genl_info *info);
61
+
int devlink_nl_health_reporter_recover_doit(struct sk_buff *skb,
62
+
struct genl_info *info);
63
+
int devlink_nl_health_reporter_diagnose_doit(struct sk_buff *skb,
64
+
struct genl_info *info);
65
+
int devlink_nl_health_reporter_dump_get_dumpit(struct sk_buff *skb,
66
+
struct netlink_callback *cb);
67
+
int devlink_nl_health_reporter_dump_clear_doit(struct sk_buff *skb,
68
+
struct genl_info *info);
69
+
int devlink_nl_flash_update_doit(struct sk_buff *skb, struct genl_info *info);
99
70
int devlink_nl_trap_get_doit(struct sk_buff *skb, struct genl_info *info);
100
71
int devlink_nl_trap_get_dumpit(struct sk_buff *skb,
101
72
struct netlink_callback *cb);
73
+
int devlink_nl_trap_set_doit(struct sk_buff *skb, struct genl_info *info);
102
74
int devlink_nl_trap_group_get_doit(struct sk_buff *skb, struct genl_info *info);
103
75
int devlink_nl_trap_group_get_dumpit(struct sk_buff *skb,
104
76
struct netlink_callback *cb);
77
+
int devlink_nl_trap_group_set_doit(struct sk_buff *skb, struct genl_info *info);
105
78
int devlink_nl_trap_policer_get_doit(struct sk_buff *skb,
106
79
struct genl_info *info);
107
80
int devlink_nl_trap_policer_get_dumpit(struct sk_buff *skb,
108
81
struct netlink_callback *cb);
82
+
int devlink_nl_trap_policer_set_doit(struct sk_buff *skb,
83
+
struct genl_info *info);
84
+
int devlink_nl_health_reporter_test_doit(struct sk_buff *skb,
85
+
struct genl_info *info);
109
86
int devlink_nl_rate_get_doit(struct sk_buff *skb, struct genl_info *info);
110
87
int devlink_nl_rate_get_dumpit(struct sk_buff *skb,
111
88
struct netlink_callback *cb);
89
+
int devlink_nl_rate_set_doit(struct sk_buff *skb, struct genl_info *info);
90
+
int devlink_nl_rate_new_doit(struct sk_buff *skb, struct genl_info *info);
91
+
int devlink_nl_rate_del_doit(struct sk_buff *skb, struct genl_info *info);
112
92
int devlink_nl_linecard_get_doit(struct sk_buff *skb, struct genl_info *info);
113
93
int devlink_nl_linecard_get_dumpit(struct sk_buff *skb,
114
94
struct netlink_callback *cb);
95
+
int devlink_nl_linecard_set_doit(struct sk_buff *skb, struct genl_info *info);
115
96
int devlink_nl_selftests_get_doit(struct sk_buff *skb, struct genl_info *info);
116
97
int devlink_nl_selftests_get_dumpit(struct sk_buff *skb,
117
98
struct netlink_callback *cb);
99
+
int devlink_nl_selftests_run_doit(struct sk_buff *skb, struct genl_info *info);
118
100
119
101
#endif /* _LINUX_DEVLINK_GEN_H */
+7
-7
net/devlink/param.c
+7
-7
net/devlink/param.c
···
581
581
return 0;
582
582
}
583
583
584
-
int devlink_nl_cmd_param_set_doit(struct sk_buff *skb, struct genl_info *info)
584
+
int devlink_nl_param_set_doit(struct sk_buff *skb, struct genl_info *info)
585
585
{
586
586
struct devlink *devlink = info->user_ptr[0];
587
587
···
589
589
info, DEVLINK_CMD_PARAM_NEW);
590
590
}
591
591
592
-
int devlink_nl_cmd_port_param_get_dumpit(struct sk_buff *msg,
593
-
struct netlink_callback *cb)
592
+
int devlink_nl_port_param_get_dumpit(struct sk_buff *msg,
593
+
struct netlink_callback *cb)
594
594
{
595
595
NL_SET_ERR_MSG(cb->extack, "Port params are not supported");
596
596
return msg->len;
597
597
}
598
598
599
-
int devlink_nl_cmd_port_param_get_doit(struct sk_buff *skb,
600
-
struct genl_info *info)
599
+
int devlink_nl_port_param_get_doit(struct sk_buff *skb,
600
+
struct genl_info *info)
601
601
{
602
602
NL_SET_ERR_MSG(info->extack, "Port params are not supported");
603
603
return -EINVAL;
604
604
}
605
605
606
-
int devlink_nl_cmd_port_param_set_doit(struct sk_buff *skb,
607
-
struct genl_info *info)
606
+
int devlink_nl_port_param_set_doit(struct sk_buff *skb,
607
+
struct genl_info *info)
608
608
{
609
609
NL_SET_ERR_MSG(info->extack, "Port params are not supported");
610
610
return -EINVAL;
+5
-6
net/devlink/port.c
+5
-6
net/devlink/port.c
···
772
772
return err;
773
773
}
774
774
775
-
int devlink_nl_cmd_port_set_doit(struct sk_buff *skb, struct genl_info *info)
775
+
int devlink_nl_port_set_doit(struct sk_buff *skb, struct genl_info *info)
776
776
{
777
777
struct devlink_port *devlink_port = info->user_ptr[1];
778
778
int err;
···
798
798
return 0;
799
799
}
800
800
801
-
int devlink_nl_cmd_port_split_doit(struct sk_buff *skb, struct genl_info *info)
801
+
int devlink_nl_port_split_doit(struct sk_buff *skb, struct genl_info *info)
802
802
{
803
803
struct devlink_port *devlink_port = info->user_ptr[1];
804
804
struct devlink *devlink = info->user_ptr[0];
···
829
829
info->extack);
830
830
}
831
831
832
-
int devlink_nl_cmd_port_unsplit_doit(struct sk_buff *skb,
833
-
struct genl_info *info)
832
+
int devlink_nl_port_unsplit_doit(struct sk_buff *skb, struct genl_info *info)
834
833
{
835
834
struct devlink_port *devlink_port = info->user_ptr[1];
836
835
struct devlink *devlink = info->user_ptr[0];
···
839
840
return devlink_port->ops->port_unsplit(devlink, devlink_port, info->extack);
840
841
}
841
842
842
-
int devlink_nl_cmd_port_new_doit(struct sk_buff *skb, struct genl_info *info)
843
+
int devlink_nl_port_new_doit(struct sk_buff *skb, struct genl_info *info)
843
844
{
844
845
struct netlink_ext_ack *extack = info->extack;
845
846
struct devlink_port_new_attrs new_attrs = {};
···
903
904
return err;
904
905
}
905
906
906
-
int devlink_nl_cmd_port_del_doit(struct sk_buff *skb, struct genl_info *info)
907
+
int devlink_nl_port_del_doit(struct sk_buff *skb, struct genl_info *info)
907
908
{
908
909
struct devlink_port *devlink_port = info->user_ptr[1];
909
910
struct netlink_ext_ack *extack = info->extack;
+3
-3
net/devlink/rate.c
+3
-3
net/devlink/rate.c
···
458
458
return true;
459
459
}
460
460
461
-
int devlink_nl_cmd_rate_set_doit(struct sk_buff *skb, struct genl_info *info)
461
+
int devlink_nl_rate_set_doit(struct sk_buff *skb, struct genl_info *info)
462
462
{
463
463
struct devlink *devlink = info->user_ptr[0];
464
464
struct devlink_rate *devlink_rate;
···
480
480
return err;
481
481
}
482
482
483
-
int devlink_nl_cmd_rate_new_doit(struct sk_buff *skb, struct genl_info *info)
483
+
int devlink_nl_rate_new_doit(struct sk_buff *skb, struct genl_info *info)
484
484
{
485
485
struct devlink *devlink = info->user_ptr[0];
486
486
struct devlink_rate *rate_node;
···
536
536
return err;
537
537
}
538
538
539
-
int devlink_nl_cmd_rate_del_doit(struct sk_buff *skb, struct genl_info *info)
539
+
int devlink_nl_rate_del_doit(struct sk_buff *skb, struct genl_info *info)
540
540
{
541
541
struct devlink *devlink = info->user_ptr[0];
542
542
struct devlink_rate *rate_node;
+4
-4
net/devlink/region.c
+4
-4
net/devlink/region.c
···
588
588
return devlink_nl_dumpit(skb, cb, devlink_nl_region_get_dump_one);
589
589
}
590
590
591
-
int devlink_nl_cmd_region_del(struct sk_buff *skb, struct genl_info *info)
591
+
int devlink_nl_region_del_doit(struct sk_buff *skb, struct genl_info *info)
592
592
{
593
593
struct devlink *devlink = info->user_ptr[0];
594
594
struct devlink_snapshot *snapshot;
···
633
633
return 0;
634
634
}
635
635
636
-
int devlink_nl_cmd_region_new(struct sk_buff *skb, struct genl_info *info)
636
+
int devlink_nl_region_new_doit(struct sk_buff *skb, struct genl_info *info)
637
637
{
638
638
struct devlink *devlink = info->user_ptr[0];
639
639
struct devlink_snapshot *snapshot;
···
863
863
curr_offset, chunk_size, chunk);
864
864
}
865
865
866
-
int devlink_nl_cmd_region_read_dumpit(struct sk_buff *skb,
867
-
struct netlink_callback *cb)
866
+
int devlink_nl_region_read_dumpit(struct sk_buff *skb,
867
+
struct netlink_callback *cb)
868
868
{
869
869
const struct genl_dumpit_info *info = genl_dumpit_info(cb);
870
870
struct devlink_nl_dump_state *state = devlink_dump_state(cb);
+2
-2
net/devlink/resource.c
+2
-2
net/devlink/resource.c
···
105
105
return err;
106
106
}
107
107
108
-
int devlink_nl_cmd_resource_set(struct sk_buff *skb, struct genl_info *info)
108
+
int devlink_nl_resource_set_doit(struct sk_buff *skb, struct genl_info *info)
109
109
{
110
110
struct devlink *devlink = info->user_ptr[0];
111
111
struct devlink_resource *resource;
···
285
285
return err;
286
286
}
287
287
288
-
int devlink_nl_cmd_resource_dump(struct sk_buff *skb, struct genl_info *info)
288
+
int devlink_nl_resource_dump_doit(struct sk_buff *skb, struct genl_info *info)
289
289
{
290
290
struct devlink *devlink = info->user_ptr[0];
291
291
+8
-9
net/devlink/sb.c
+8
-9
net/devlink/sb.c
···
413
413
return -EOPNOTSUPP;
414
414
}
415
415
416
-
int devlink_nl_cmd_sb_pool_set_doit(struct sk_buff *skb, struct genl_info *info)
416
+
int devlink_nl_sb_pool_set_doit(struct sk_buff *skb, struct genl_info *info)
417
417
{
418
418
struct devlink *devlink = info->user_ptr[0];
419
419
enum devlink_sb_threshold_type threshold_type;
···
621
621
return -EOPNOTSUPP;
622
622
}
623
623
624
-
int devlink_nl_cmd_sb_port_pool_set_doit(struct sk_buff *skb,
625
-
struct genl_info *info)
624
+
int devlink_nl_sb_port_pool_set_doit(struct sk_buff *skb,
625
+
struct genl_info *info)
626
626
{
627
627
struct devlink_port *devlink_port = info->user_ptr[1];
628
628
struct devlink *devlink = info->user_ptr[0];
···
861
861
return -EOPNOTSUPP;
862
862
}
863
863
864
-
int devlink_nl_cmd_sb_tc_pool_bind_set_doit(struct sk_buff *skb,
865
-
struct genl_info *info)
864
+
int devlink_nl_sb_tc_pool_bind_set_doit(struct sk_buff *skb,
865
+
struct genl_info *info)
866
866
{
867
867
struct devlink_port *devlink_port = info->user_ptr[1];
868
868
struct devlink *devlink = info->user_ptr[0];
···
900
900
pool_index, threshold, info->extack);
901
901
}
902
902
903
-
int devlink_nl_cmd_sb_occ_snapshot_doit(struct sk_buff *skb,
904
-
struct genl_info *info)
903
+
int devlink_nl_sb_occ_snapshot_doit(struct sk_buff *skb, struct genl_info *info)
905
904
{
906
905
struct devlink *devlink = info->user_ptr[0];
907
906
const struct devlink_ops *ops = devlink->ops;
···
915
916
return -EOPNOTSUPP;
916
917
}
917
918
918
-
int devlink_nl_cmd_sb_occ_max_clear_doit(struct sk_buff *skb,
919
-
struct genl_info *info)
919
+
int devlink_nl_sb_occ_max_clear_doit(struct sk_buff *skb,
920
+
struct genl_info *info)
920
921
{
921
922
struct devlink *devlink = info->user_ptr[0];
922
923
const struct devlink_ops *ops = devlink->ops;
+4
-5
net/devlink/trap.c
+4
-5
net/devlink/trap.c
···
414
414
info->extack);
415
415
}
416
416
417
-
int devlink_nl_cmd_trap_set_doit(struct sk_buff *skb, struct genl_info *info)
417
+
int devlink_nl_trap_set_doit(struct sk_buff *skb, struct genl_info *info)
418
418
{
419
419
struct netlink_ext_ack *extack = info->extack;
420
420
struct devlink *devlink = info->user_ptr[0];
···
684
684
return 0;
685
685
}
686
686
687
-
int devlink_nl_cmd_trap_group_set_doit(struct sk_buff *skb,
688
-
struct genl_info *info)
687
+
int devlink_nl_trap_group_set_doit(struct sk_buff *skb, struct genl_info *info)
689
688
{
690
689
struct netlink_ext_ack *extack = info->extack;
691
690
struct devlink *devlink = info->user_ptr[0];
···
925
926
return 0;
926
927
}
927
928
928
-
int devlink_nl_cmd_trap_policer_set_doit(struct sk_buff *skb,
929
-
struct genl_info *info)
929
+
int devlink_nl_trap_policer_set_doit(struct sk_buff *skb,
930
+
struct genl_info *info)
930
931
{
931
932
struct devlink_trap_policer_item *policer_item;
932
933
struct netlink_ext_ack *extack = info->extack;
+2
-1
net/netlink/genetlink.c
+2
-1
net/netlink/genetlink.c
···
225
225
}
226
226
227
227
if (i + cnt < family->n_split_ops &&
228
-
family->split_ops[i + cnt].flags & GENL_CMD_CAP_DUMP) {
228
+
family->split_ops[i + cnt].flags & GENL_CMD_CAP_DUMP &&
229
+
(!cnt || family->split_ops[i + cnt].cmd == iter->doit.cmd)) {
229
230
iter->dumpit = family->split_ops[i + cnt];
230
231
genl_op_fill_in_reject_policy_split(family, &iter->dumpit);
231
232
cnt++;
+3856
-5
tools/net/ynl/generated/devlink-user.c
+3856
-5
tools/net/ynl/generated/devlink-user.c
···
16
16
static const char * const devlink_op_strmap[] = {
17
17
[3] = "get",
18
18
[7] = "port-get",
19
+
[DEVLINK_CMD_PORT_NEW] = "port-new",
19
20
[13] = "sb-get",
20
21
[17] = "sb-pool-get",
21
22
[21] = "sb-port-pool-get",
22
23
[25] = "sb-tc-pool-bind-get",
24
+
[DEVLINK_CMD_ESWITCH_GET] = "eswitch-get",
25
+
[DEVLINK_CMD_DPIPE_TABLE_GET] = "dpipe-table-get",
26
+
[DEVLINK_CMD_DPIPE_ENTRIES_GET] = "dpipe-entries-get",
27
+
[DEVLINK_CMD_DPIPE_HEADERS_GET] = "dpipe-headers-get",
28
+
[DEVLINK_CMD_RESOURCE_DUMP] = "resource-dump",
29
+
[DEVLINK_CMD_RELOAD] = "reload",
23
30
[DEVLINK_CMD_PARAM_GET] = "param-get",
24
31
[DEVLINK_CMD_REGION_GET] = "region-get",
32
+
[DEVLINK_CMD_REGION_NEW] = "region-new",
33
+
[DEVLINK_CMD_REGION_READ] = "region-read",
34
+
[DEVLINK_CMD_PORT_PARAM_GET] = "port-param-get",
25
35
[DEVLINK_CMD_INFO_GET] = "info-get",
26
36
[DEVLINK_CMD_HEALTH_REPORTER_GET] = "health-reporter-get",
37
+
[DEVLINK_CMD_HEALTH_REPORTER_DUMP_GET] = "health-reporter-dump-get",
27
38
[63] = "trap-get",
28
39
[67] = "trap-group-get",
29
40
[71] = "trap-policer-get",
···
62
51
return devlink_sb_pool_type_strmap[value];
63
52
}
64
53
54
+
static const char * const devlink_port_type_strmap[] = {
55
+
[0] = "notset",
56
+
[1] = "auto",
57
+
[2] = "eth",
58
+
[3] = "ib",
59
+
};
60
+
61
+
const char *devlink_port_type_str(enum devlink_port_type value)
62
+
{
63
+
if (value < 0 || value >= (int)MNL_ARRAY_SIZE(devlink_port_type_strmap))
64
+
return NULL;
65
+
return devlink_port_type_strmap[value];
66
+
}
67
+
68
+
static const char * const devlink_port_flavour_strmap[] = {
69
+
[0] = "physical",
70
+
[1] = "cpu",
71
+
[2] = "dsa",
72
+
[3] = "pci_pf",
73
+
[4] = "pci_vf",
74
+
[5] = "virtual",
75
+
[6] = "unused",
76
+
[7] = "pci_sf",
77
+
};
78
+
79
+
const char *devlink_port_flavour_str(enum devlink_port_flavour value)
80
+
{
81
+
if (value < 0 || value >= (int)MNL_ARRAY_SIZE(devlink_port_flavour_strmap))
82
+
return NULL;
83
+
return devlink_port_flavour_strmap[value];
84
+
}
85
+
86
+
static const char * const devlink_port_fn_state_strmap[] = {
87
+
[0] = "inactive",
88
+
[1] = "active",
89
+
};
90
+
91
+
const char *devlink_port_fn_state_str(enum devlink_port_fn_state value)
92
+
{
93
+
if (value < 0 || value >= (int)MNL_ARRAY_SIZE(devlink_port_fn_state_strmap))
94
+
return NULL;
95
+
return devlink_port_fn_state_strmap[value];
96
+
}
97
+
98
+
static const char * const devlink_port_fn_opstate_strmap[] = {
99
+
[0] = "detached",
100
+
[1] = "attached",
101
+
};
102
+
103
+
const char *devlink_port_fn_opstate_str(enum devlink_port_fn_opstate value)
104
+
{
105
+
if (value < 0 || value >= (int)MNL_ARRAY_SIZE(devlink_port_fn_opstate_strmap))
106
+
return NULL;
107
+
return devlink_port_fn_opstate_strmap[value];
108
+
}
109
+
110
+
static const char * const devlink_port_fn_attr_cap_strmap[] = {
111
+
[0] = "roce-bit",
112
+
[1] = "migratable-bit",
113
+
};
114
+
115
+
const char *devlink_port_fn_attr_cap_str(enum devlink_port_fn_attr_cap value)
116
+
{
117
+
if (value < 0 || value >= (int)MNL_ARRAY_SIZE(devlink_port_fn_attr_cap_strmap))
118
+
return NULL;
119
+
return devlink_port_fn_attr_cap_strmap[value];
120
+
}
121
+
122
+
static const char * const devlink_sb_threshold_type_strmap[] = {
123
+
[0] = "static",
124
+
[1] = "dynamic",
125
+
};
126
+
127
+
const char *devlink_sb_threshold_type_str(enum devlink_sb_threshold_type value)
128
+
{
129
+
if (value < 0 || value >= (int)MNL_ARRAY_SIZE(devlink_sb_threshold_type_strmap))
130
+
return NULL;
131
+
return devlink_sb_threshold_type_strmap[value];
132
+
}
133
+
134
+
static const char * const devlink_eswitch_mode_strmap[] = {
135
+
[0] = "legacy",
136
+
[1] = "switchdev",
137
+
};
138
+
139
+
const char *devlink_eswitch_mode_str(enum devlink_eswitch_mode value)
140
+
{
141
+
if (value < 0 || value >= (int)MNL_ARRAY_SIZE(devlink_eswitch_mode_strmap))
142
+
return NULL;
143
+
return devlink_eswitch_mode_strmap[value];
144
+
}
145
+
146
+
static const char * const devlink_eswitch_inline_mode_strmap[] = {
147
+
[0] = "none",
148
+
[1] = "link",
149
+
[2] = "network",
150
+
[3] = "transport",
151
+
};
152
+
153
+
const char *
154
+
devlink_eswitch_inline_mode_str(enum devlink_eswitch_inline_mode value)
155
+
{
156
+
if (value < 0 || value >= (int)MNL_ARRAY_SIZE(devlink_eswitch_inline_mode_strmap))
157
+
return NULL;
158
+
return devlink_eswitch_inline_mode_strmap[value];
159
+
}
160
+
161
+
static const char * const devlink_eswitch_encap_mode_strmap[] = {
162
+
[0] = "none",
163
+
[1] = "basic",
164
+
};
165
+
166
+
const char *
167
+
devlink_eswitch_encap_mode_str(enum devlink_eswitch_encap_mode value)
168
+
{
169
+
if (value < 0 || value >= (int)MNL_ARRAY_SIZE(devlink_eswitch_encap_mode_strmap))
170
+
return NULL;
171
+
return devlink_eswitch_encap_mode_strmap[value];
172
+
}
173
+
174
+
static const char * const devlink_dpipe_match_type_strmap[] = {
175
+
[0] = "field-exact",
176
+
};
177
+
178
+
const char *devlink_dpipe_match_type_str(enum devlink_dpipe_match_type value)
179
+
{
180
+
if (value < 0 || value >= (int)MNL_ARRAY_SIZE(devlink_dpipe_match_type_strmap))
181
+
return NULL;
182
+
return devlink_dpipe_match_type_strmap[value];
183
+
}
184
+
185
+
static const char * const devlink_dpipe_action_type_strmap[] = {
186
+
[0] = "field-modify",
187
+
};
188
+
189
+
const char *devlink_dpipe_action_type_str(enum devlink_dpipe_action_type value)
190
+
{
191
+
if (value < 0 || value >= (int)MNL_ARRAY_SIZE(devlink_dpipe_action_type_strmap))
192
+
return NULL;
193
+
return devlink_dpipe_action_type_strmap[value];
194
+
}
195
+
196
+
static const char * const devlink_dpipe_field_mapping_type_strmap[] = {
197
+
[0] = "none",
198
+
[1] = "ifindex",
199
+
};
200
+
201
+
const char *
202
+
devlink_dpipe_field_mapping_type_str(enum devlink_dpipe_field_mapping_type value)
203
+
{
204
+
if (value < 0 || value >= (int)MNL_ARRAY_SIZE(devlink_dpipe_field_mapping_type_strmap))
205
+
return NULL;
206
+
return devlink_dpipe_field_mapping_type_strmap[value];
207
+
}
208
+
209
+
static const char * const devlink_resource_unit_strmap[] = {
210
+
[0] = "entry",
211
+
};
212
+
213
+
const char *devlink_resource_unit_str(enum devlink_resource_unit value)
214
+
{
215
+
if (value < 0 || value >= (int)MNL_ARRAY_SIZE(devlink_resource_unit_strmap))
216
+
return NULL;
217
+
return devlink_resource_unit_strmap[value];
218
+
}
219
+
220
+
static const char * const devlink_reload_action_strmap[] = {
221
+
[1] = "driver-reinit",
222
+
[2] = "fw-activate",
223
+
};
224
+
225
+
const char *devlink_reload_action_str(enum devlink_reload_action value)
226
+
{
227
+
if (value < 0 || value >= (int)MNL_ARRAY_SIZE(devlink_reload_action_strmap))
228
+
return NULL;
229
+
return devlink_reload_action_strmap[value];
230
+
}
231
+
232
+
static const char * const devlink_param_cmode_strmap[] = {
233
+
[0] = "runtime",
234
+
[1] = "driverinit",
235
+
[2] = "permanent",
236
+
};
237
+
238
+
const char *devlink_param_cmode_str(enum devlink_param_cmode value)
239
+
{
240
+
if (value < 0 || value >= (int)MNL_ARRAY_SIZE(devlink_param_cmode_strmap))
241
+
return NULL;
242
+
return devlink_param_cmode_strmap[value];
243
+
}
244
+
245
+
static const char * const devlink_flash_overwrite_strmap[] = {
246
+
[0] = "settings-bit",
247
+
[1] = "identifiers-bit",
248
+
};
249
+
250
+
const char *devlink_flash_overwrite_str(enum devlink_flash_overwrite value)
251
+
{
252
+
if (value < 0 || value >= (int)MNL_ARRAY_SIZE(devlink_flash_overwrite_strmap))
253
+
return NULL;
254
+
return devlink_flash_overwrite_strmap[value];
255
+
}
256
+
257
+
static const char * const devlink_trap_action_strmap[] = {
258
+
[0] = "drop",
259
+
[1] = "trap",
260
+
[2] = "mirror",
261
+
};
262
+
263
+
const char *devlink_trap_action_str(enum devlink_trap_action value)
264
+
{
265
+
if (value < 0 || value >= (int)MNL_ARRAY_SIZE(devlink_trap_action_strmap))
266
+
return NULL;
267
+
return devlink_trap_action_strmap[value];
268
+
}
269
+
65
270
/* Policies */
271
+
struct ynl_policy_attr devlink_dl_dpipe_match_policy[DEVLINK_ATTR_MAX + 1] = {
272
+
[DEVLINK_ATTR_DPIPE_MATCH_TYPE] = { .name = "dpipe-match-type", .type = YNL_PT_U32, },
273
+
[DEVLINK_ATTR_DPIPE_HEADER_ID] = { .name = "dpipe-header-id", .type = YNL_PT_U32, },
274
+
[DEVLINK_ATTR_DPIPE_HEADER_GLOBAL] = { .name = "dpipe-header-global", .type = YNL_PT_U8, },
275
+
[DEVLINK_ATTR_DPIPE_HEADER_INDEX] = { .name = "dpipe-header-index", .type = YNL_PT_U32, },
276
+
[DEVLINK_ATTR_DPIPE_FIELD_ID] = { .name = "dpipe-field-id", .type = YNL_PT_U32, },
277
+
};
278
+
279
+
struct ynl_policy_nest devlink_dl_dpipe_match_nest = {
280
+
.max_attr = DEVLINK_ATTR_MAX,
281
+
.table = devlink_dl_dpipe_match_policy,
282
+
};
283
+
284
+
struct ynl_policy_attr devlink_dl_dpipe_match_value_policy[DEVLINK_ATTR_MAX + 1] = {
285
+
[DEVLINK_ATTR_DPIPE_MATCH] = { .name = "dpipe-match", .type = YNL_PT_NEST, .nest = &devlink_dl_dpipe_match_nest, },
286
+
[DEVLINK_ATTR_DPIPE_VALUE] = { .name = "dpipe-value", .type = YNL_PT_BINARY,},
287
+
[DEVLINK_ATTR_DPIPE_VALUE_MASK] = { .name = "dpipe-value-mask", .type = YNL_PT_BINARY,},
288
+
[DEVLINK_ATTR_DPIPE_VALUE_MAPPING] = { .name = "dpipe-value-mapping", .type = YNL_PT_U32, },
289
+
};
290
+
291
+
struct ynl_policy_nest devlink_dl_dpipe_match_value_nest = {
292
+
.max_attr = DEVLINK_ATTR_MAX,
293
+
.table = devlink_dl_dpipe_match_value_policy,
294
+
};
295
+
296
+
struct ynl_policy_attr devlink_dl_dpipe_action_policy[DEVLINK_ATTR_MAX + 1] = {
297
+
[DEVLINK_ATTR_DPIPE_ACTION_TYPE] = { .name = "dpipe-action-type", .type = YNL_PT_U32, },
298
+
[DEVLINK_ATTR_DPIPE_HEADER_ID] = { .name = "dpipe-header-id", .type = YNL_PT_U32, },
299
+
[DEVLINK_ATTR_DPIPE_HEADER_GLOBAL] = { .name = "dpipe-header-global", .type = YNL_PT_U8, },
300
+
[DEVLINK_ATTR_DPIPE_HEADER_INDEX] = { .name = "dpipe-header-index", .type = YNL_PT_U32, },
301
+
[DEVLINK_ATTR_DPIPE_FIELD_ID] = { .name = "dpipe-field-id", .type = YNL_PT_U32, },
302
+
};
303
+
304
+
struct ynl_policy_nest devlink_dl_dpipe_action_nest = {
305
+
.max_attr = DEVLINK_ATTR_MAX,
306
+
.table = devlink_dl_dpipe_action_policy,
307
+
};
308
+
309
+
struct ynl_policy_attr devlink_dl_dpipe_action_value_policy[DEVLINK_ATTR_MAX + 1] = {
310
+
[DEVLINK_ATTR_DPIPE_ACTION] = { .name = "dpipe-action", .type = YNL_PT_NEST, .nest = &devlink_dl_dpipe_action_nest, },
311
+
[DEVLINK_ATTR_DPIPE_VALUE] = { .name = "dpipe-value", .type = YNL_PT_BINARY,},
312
+
[DEVLINK_ATTR_DPIPE_VALUE_MASK] = { .name = "dpipe-value-mask", .type = YNL_PT_BINARY,},
313
+
[DEVLINK_ATTR_DPIPE_VALUE_MAPPING] = { .name = "dpipe-value-mapping", .type = YNL_PT_U32, },
314
+
};
315
+
316
+
struct ynl_policy_nest devlink_dl_dpipe_action_value_nest = {
317
+
.max_attr = DEVLINK_ATTR_MAX,
318
+
.table = devlink_dl_dpipe_action_value_policy,
319
+
};
320
+
321
+
struct ynl_policy_attr devlink_dl_dpipe_field_policy[DEVLINK_ATTR_MAX + 1] = {
322
+
[DEVLINK_ATTR_DPIPE_FIELD_NAME] = { .name = "dpipe-field-name", .type = YNL_PT_NUL_STR, },
323
+
[DEVLINK_ATTR_DPIPE_FIELD_ID] = { .name = "dpipe-field-id", .type = YNL_PT_U32, },
324
+
[DEVLINK_ATTR_DPIPE_FIELD_BITWIDTH] = { .name = "dpipe-field-bitwidth", .type = YNL_PT_U32, },
325
+
[DEVLINK_ATTR_DPIPE_FIELD_MAPPING_TYPE] = { .name = "dpipe-field-mapping-type", .type = YNL_PT_U32, },
326
+
};
327
+
328
+
struct ynl_policy_nest devlink_dl_dpipe_field_nest = {
329
+
.max_attr = DEVLINK_ATTR_MAX,
330
+
.table = devlink_dl_dpipe_field_policy,
331
+
};
332
+
333
+
struct ynl_policy_attr devlink_dl_resource_policy[DEVLINK_ATTR_MAX + 1] = {
334
+
[DEVLINK_ATTR_RESOURCE_NAME] = { .name = "resource-name", .type = YNL_PT_NUL_STR, },
335
+
[DEVLINK_ATTR_RESOURCE_ID] = { .name = "resource-id", .type = YNL_PT_U64, },
336
+
[DEVLINK_ATTR_RESOURCE_SIZE] = { .name = "resource-size", .type = YNL_PT_U64, },
337
+
[DEVLINK_ATTR_RESOURCE_SIZE_NEW] = { .name = "resource-size-new", .type = YNL_PT_U64, },
338
+
[DEVLINK_ATTR_RESOURCE_SIZE_VALID] = { .name = "resource-size-valid", .type = YNL_PT_U8, },
339
+
[DEVLINK_ATTR_RESOURCE_SIZE_MIN] = { .name = "resource-size-min", .type = YNL_PT_U64, },
340
+
[DEVLINK_ATTR_RESOURCE_SIZE_MAX] = { .name = "resource-size-max", .type = YNL_PT_U64, },
341
+
[DEVLINK_ATTR_RESOURCE_SIZE_GRAN] = { .name = "resource-size-gran", .type = YNL_PT_U64, },
342
+
[DEVLINK_ATTR_RESOURCE_UNIT] = { .name = "resource-unit", .type = YNL_PT_U8, },
343
+
[DEVLINK_ATTR_RESOURCE_OCC] = { .name = "resource-occ", .type = YNL_PT_U64, },
344
+
};
345
+
346
+
struct ynl_policy_nest devlink_dl_resource_nest = {
347
+
.max_attr = DEVLINK_ATTR_MAX,
348
+
.table = devlink_dl_resource_policy,
349
+
};
350
+
66
351
struct ynl_policy_attr devlink_dl_info_version_policy[DEVLINK_ATTR_MAX + 1] = {
67
352
[DEVLINK_ATTR_INFO_VERSION_NAME] = { .name = "info-version-name", .type = YNL_PT_NUL_STR, },
68
353
[DEVLINK_ATTR_INFO_VERSION_VALUE] = { .name = "info-version-value", .type = YNL_PT_NUL_STR, },
···
367
60
struct ynl_policy_nest devlink_dl_info_version_nest = {
368
61
.max_attr = DEVLINK_ATTR_MAX,
369
62
.table = devlink_dl_info_version_policy,
63
+
};
64
+
65
+
struct ynl_policy_attr devlink_dl_fmsg_policy[DEVLINK_ATTR_MAX + 1] = {
66
+
[DEVLINK_ATTR_FMSG_OBJ_NEST_START] = { .name = "fmsg-obj-nest-start", .type = YNL_PT_FLAG, },
67
+
[DEVLINK_ATTR_FMSG_PAIR_NEST_START] = { .name = "fmsg-pair-nest-start", .type = YNL_PT_FLAG, },
68
+
[DEVLINK_ATTR_FMSG_ARR_NEST_START] = { .name = "fmsg-arr-nest-start", .type = YNL_PT_FLAG, },
69
+
[DEVLINK_ATTR_FMSG_NEST_END] = { .name = "fmsg-nest-end", .type = YNL_PT_FLAG, },
70
+
[DEVLINK_ATTR_FMSG_OBJ_NAME] = { .name = "fmsg-obj-name", .type = YNL_PT_NUL_STR, },
71
+
};
72
+
73
+
struct ynl_policy_nest devlink_dl_fmsg_nest = {
74
+
.max_attr = DEVLINK_ATTR_MAX,
75
+
.table = devlink_dl_fmsg_policy,
76
+
};
77
+
78
+
struct ynl_policy_attr devlink_dl_port_function_policy[DEVLINK_PORT_FUNCTION_ATTR_MAX + 1] = {
79
+
[DEVLINK_PORT_FUNCTION_ATTR_HW_ADDR] = { .name = "hw-addr", .type = YNL_PT_BINARY,},
80
+
[DEVLINK_PORT_FN_ATTR_STATE] = { .name = "state", .type = YNL_PT_U8, },
81
+
[DEVLINK_PORT_FN_ATTR_OPSTATE] = { .name = "opstate", .type = YNL_PT_U8, },
82
+
[DEVLINK_PORT_FN_ATTR_CAPS] = { .name = "caps", .type = YNL_PT_BITFIELD32, },
83
+
};
84
+
85
+
struct ynl_policy_nest devlink_dl_port_function_nest = {
86
+
.max_attr = DEVLINK_PORT_FUNCTION_ATTR_MAX,
87
+
.table = devlink_dl_port_function_policy,
370
88
};
371
89
372
90
struct ynl_policy_attr devlink_dl_reload_stats_entry_policy[DEVLINK_ATTR_MAX + 1] = {
···
413
81
.table = devlink_dl_reload_act_stats_policy,
414
82
};
415
83
84
+
struct ynl_policy_attr devlink_dl_selftest_id_policy[DEVLINK_ATTR_SELFTEST_ID_MAX + 1] = {
85
+
[DEVLINK_ATTR_SELFTEST_ID_FLASH] = { .name = "flash", .type = YNL_PT_FLAG, },
86
+
};
87
+
88
+
struct ynl_policy_nest devlink_dl_selftest_id_nest = {
89
+
.max_attr = DEVLINK_ATTR_SELFTEST_ID_MAX,
90
+
.table = devlink_dl_selftest_id_policy,
91
+
};
92
+
93
+
struct ynl_policy_attr devlink_dl_dpipe_table_matches_policy[DEVLINK_ATTR_MAX + 1] = {
94
+
[DEVLINK_ATTR_DPIPE_MATCH] = { .name = "dpipe-match", .type = YNL_PT_NEST, .nest = &devlink_dl_dpipe_match_nest, },
95
+
};
96
+
97
+
struct ynl_policy_nest devlink_dl_dpipe_table_matches_nest = {
98
+
.max_attr = DEVLINK_ATTR_MAX,
99
+
.table = devlink_dl_dpipe_table_matches_policy,
100
+
};
101
+
102
+
struct ynl_policy_attr devlink_dl_dpipe_table_actions_policy[DEVLINK_ATTR_MAX + 1] = {
103
+
[DEVLINK_ATTR_DPIPE_ACTION] = { .name = "dpipe-action", .type = YNL_PT_NEST, .nest = &devlink_dl_dpipe_action_nest, },
104
+
};
105
+
106
+
struct ynl_policy_nest devlink_dl_dpipe_table_actions_nest = {
107
+
.max_attr = DEVLINK_ATTR_MAX,
108
+
.table = devlink_dl_dpipe_table_actions_policy,
109
+
};
110
+
111
+
struct ynl_policy_attr devlink_dl_dpipe_entry_match_values_policy[DEVLINK_ATTR_MAX + 1] = {
112
+
[DEVLINK_ATTR_DPIPE_MATCH_VALUE] = { .name = "dpipe-match-value", .type = YNL_PT_NEST, .nest = &devlink_dl_dpipe_match_value_nest, },
113
+
};
114
+
115
+
struct ynl_policy_nest devlink_dl_dpipe_entry_match_values_nest = {
116
+
.max_attr = DEVLINK_ATTR_MAX,
117
+
.table = devlink_dl_dpipe_entry_match_values_policy,
118
+
};
119
+
120
+
struct ynl_policy_attr devlink_dl_dpipe_entry_action_values_policy[DEVLINK_ATTR_MAX + 1] = {
121
+
[DEVLINK_ATTR_DPIPE_ACTION_VALUE] = { .name = "dpipe-action-value", .type = YNL_PT_NEST, .nest = &devlink_dl_dpipe_action_value_nest, },
122
+
};
123
+
124
+
struct ynl_policy_nest devlink_dl_dpipe_entry_action_values_nest = {
125
+
.max_attr = DEVLINK_ATTR_MAX,
126
+
.table = devlink_dl_dpipe_entry_action_values_policy,
127
+
};
128
+
129
+
struct ynl_policy_attr devlink_dl_dpipe_header_fields_policy[DEVLINK_ATTR_MAX + 1] = {
130
+
[DEVLINK_ATTR_DPIPE_FIELD] = { .name = "dpipe-field", .type = YNL_PT_NEST, .nest = &devlink_dl_dpipe_field_nest, },
131
+
};
132
+
133
+
struct ynl_policy_nest devlink_dl_dpipe_header_fields_nest = {
134
+
.max_attr = DEVLINK_ATTR_MAX,
135
+
.table = devlink_dl_dpipe_header_fields_policy,
136
+
};
137
+
138
+
struct ynl_policy_attr devlink_dl_resource_list_policy[DEVLINK_ATTR_MAX + 1] = {
139
+
[DEVLINK_ATTR_RESOURCE] = { .name = "resource", .type = YNL_PT_NEST, .nest = &devlink_dl_resource_nest, },
140
+
};
141
+
142
+
struct ynl_policy_nest devlink_dl_resource_list_nest = {
143
+
.max_attr = DEVLINK_ATTR_MAX,
144
+
.table = devlink_dl_resource_list_policy,
145
+
};
146
+
416
147
struct ynl_policy_attr devlink_dl_reload_act_info_policy[DEVLINK_ATTR_MAX + 1] = {
417
148
[DEVLINK_ATTR_RELOAD_ACTION] = { .name = "reload-action", .type = YNL_PT_U8, },
418
149
[DEVLINK_ATTR_RELOAD_ACTION_STATS] = { .name = "reload-action-stats", .type = YNL_PT_NEST, .nest = &devlink_dl_reload_act_stats_nest, },
···
486
91
.table = devlink_dl_reload_act_info_policy,
487
92
};
488
93
94
+
struct ynl_policy_attr devlink_dl_dpipe_table_policy[DEVLINK_ATTR_MAX + 1] = {
95
+
[DEVLINK_ATTR_DPIPE_TABLE_NAME] = { .name = "dpipe-table-name", .type = YNL_PT_NUL_STR, },
96
+
[DEVLINK_ATTR_DPIPE_TABLE_SIZE] = { .name = "dpipe-table-size", .type = YNL_PT_U64, },
97
+
[DEVLINK_ATTR_DPIPE_TABLE_MATCHES] = { .name = "dpipe-table-matches", .type = YNL_PT_NEST, .nest = &devlink_dl_dpipe_table_matches_nest, },
98
+
[DEVLINK_ATTR_DPIPE_TABLE_ACTIONS] = { .name = "dpipe-table-actions", .type = YNL_PT_NEST, .nest = &devlink_dl_dpipe_table_actions_nest, },
99
+
[DEVLINK_ATTR_DPIPE_TABLE_COUNTERS_ENABLED] = { .name = "dpipe-table-counters-enabled", .type = YNL_PT_U8, },
100
+
[DEVLINK_ATTR_DPIPE_TABLE_RESOURCE_ID] = { .name = "dpipe-table-resource-id", .type = YNL_PT_U64, },
101
+
[DEVLINK_ATTR_DPIPE_TABLE_RESOURCE_UNITS] = { .name = "dpipe-table-resource-units", .type = YNL_PT_U64, },
102
+
};
103
+
104
+
struct ynl_policy_nest devlink_dl_dpipe_table_nest = {
105
+
.max_attr = DEVLINK_ATTR_MAX,
106
+
.table = devlink_dl_dpipe_table_policy,
107
+
};
108
+
109
+
struct ynl_policy_attr devlink_dl_dpipe_entry_policy[DEVLINK_ATTR_MAX + 1] = {
110
+
[DEVLINK_ATTR_DPIPE_ENTRY_INDEX] = { .name = "dpipe-entry-index", .type = YNL_PT_U64, },
111
+
[DEVLINK_ATTR_DPIPE_ENTRY_MATCH_VALUES] = { .name = "dpipe-entry-match-values", .type = YNL_PT_NEST, .nest = &devlink_dl_dpipe_entry_match_values_nest, },
112
+
[DEVLINK_ATTR_DPIPE_ENTRY_ACTION_VALUES] = { .name = "dpipe-entry-action-values", .type = YNL_PT_NEST, .nest = &devlink_dl_dpipe_entry_action_values_nest, },
113
+
[DEVLINK_ATTR_DPIPE_ENTRY_COUNTER] = { .name = "dpipe-entry-counter", .type = YNL_PT_U64, },
114
+
};
115
+
116
+
struct ynl_policy_nest devlink_dl_dpipe_entry_nest = {
117
+
.max_attr = DEVLINK_ATTR_MAX,
118
+
.table = devlink_dl_dpipe_entry_policy,
119
+
};
120
+
121
+
struct ynl_policy_attr devlink_dl_dpipe_header_policy[DEVLINK_ATTR_MAX + 1] = {
122
+
[DEVLINK_ATTR_DPIPE_HEADER_NAME] = { .name = "dpipe-header-name", .type = YNL_PT_NUL_STR, },
123
+
[DEVLINK_ATTR_DPIPE_HEADER_ID] = { .name = "dpipe-header-id", .type = YNL_PT_U32, },
124
+
[DEVLINK_ATTR_DPIPE_HEADER_GLOBAL] = { .name = "dpipe-header-global", .type = YNL_PT_U8, },
125
+
[DEVLINK_ATTR_DPIPE_HEADER_FIELDS] = { .name = "dpipe-header-fields", .type = YNL_PT_NEST, .nest = &devlink_dl_dpipe_header_fields_nest, },
126
+
};
127
+
128
+
struct ynl_policy_nest devlink_dl_dpipe_header_nest = {
129
+
.max_attr = DEVLINK_ATTR_MAX,
130
+
.table = devlink_dl_dpipe_header_policy,
131
+
};
132
+
489
133
struct ynl_policy_attr devlink_dl_reload_stats_policy[DEVLINK_ATTR_MAX + 1] = {
490
134
[DEVLINK_ATTR_RELOAD_ACTION_INFO] = { .name = "reload-action-info", .type = YNL_PT_NEST, .nest = &devlink_dl_reload_act_info_nest, },
491
135
};
···
532
98
struct ynl_policy_nest devlink_dl_reload_stats_nest = {
533
99
.max_attr = DEVLINK_ATTR_MAX,
534
100
.table = devlink_dl_reload_stats_policy,
101
+
};
102
+
103
+
struct ynl_policy_attr devlink_dl_dpipe_tables_policy[DEVLINK_ATTR_MAX + 1] = {
104
+
[DEVLINK_ATTR_DPIPE_TABLE] = { .name = "dpipe-table", .type = YNL_PT_NEST, .nest = &devlink_dl_dpipe_table_nest, },
105
+
};
106
+
107
+
struct ynl_policy_nest devlink_dl_dpipe_tables_nest = {
108
+
.max_attr = DEVLINK_ATTR_MAX,
109
+
.table = devlink_dl_dpipe_tables_policy,
110
+
};
111
+
112
+
struct ynl_policy_attr devlink_dl_dpipe_entries_policy[DEVLINK_ATTR_MAX + 1] = {
113
+
[DEVLINK_ATTR_DPIPE_ENTRY] = { .name = "dpipe-entry", .type = YNL_PT_NEST, .nest = &devlink_dl_dpipe_entry_nest, },
114
+
};
115
+
116
+
struct ynl_policy_nest devlink_dl_dpipe_entries_nest = {
117
+
.max_attr = DEVLINK_ATTR_MAX,
118
+
.table = devlink_dl_dpipe_entries_policy,
119
+
};
120
+
121
+
struct ynl_policy_attr devlink_dl_dpipe_headers_policy[DEVLINK_ATTR_MAX + 1] = {
122
+
[DEVLINK_ATTR_DPIPE_HEADER] = { .name = "dpipe-header", .type = YNL_PT_NEST, .nest = &devlink_dl_dpipe_header_nest, },
123
+
};
124
+
125
+
struct ynl_policy_nest devlink_dl_dpipe_headers_nest = {
126
+
.max_attr = DEVLINK_ATTR_MAX,
127
+
.table = devlink_dl_dpipe_headers_policy,
535
128
};
536
129
537
130
struct ynl_policy_attr devlink_dl_dev_stats_policy[DEVLINK_ATTR_MAX + 1] = {
···
575
114
[DEVLINK_ATTR_BUS_NAME] = { .name = "bus-name", .type = YNL_PT_NUL_STR, },
576
115
[DEVLINK_ATTR_DEV_NAME] = { .name = "dev-name", .type = YNL_PT_NUL_STR, },
577
116
[DEVLINK_ATTR_PORT_INDEX] = { .name = "port-index", .type = YNL_PT_U32, },
117
+
[DEVLINK_ATTR_PORT_TYPE] = { .name = "port-type", .type = YNL_PT_U16, },
118
+
[DEVLINK_ATTR_PORT_SPLIT_COUNT] = { .name = "port-split-count", .type = YNL_PT_U32, },
578
119
[DEVLINK_ATTR_SB_INDEX] = { .name = "sb-index", .type = YNL_PT_U32, },
579
120
[DEVLINK_ATTR_SB_POOL_INDEX] = { .name = "sb-pool-index", .type = YNL_PT_U16, },
580
121
[DEVLINK_ATTR_SB_POOL_TYPE] = { .name = "sb-pool-type", .type = YNL_PT_U8, },
122
+
[DEVLINK_ATTR_SB_POOL_SIZE] = { .name = "sb-pool-size", .type = YNL_PT_U32, },
123
+
[DEVLINK_ATTR_SB_POOL_THRESHOLD_TYPE] = { .name = "sb-pool-threshold-type", .type = YNL_PT_U8, },
124
+
[DEVLINK_ATTR_SB_THRESHOLD] = { .name = "sb-threshold", .type = YNL_PT_U32, },
581
125
[DEVLINK_ATTR_SB_TC_INDEX] = { .name = "sb-tc-index", .type = YNL_PT_U16, },
126
+
[DEVLINK_ATTR_ESWITCH_MODE] = { .name = "eswitch-mode", .type = YNL_PT_U16, },
127
+
[DEVLINK_ATTR_ESWITCH_INLINE_MODE] = { .name = "eswitch-inline-mode", .type = YNL_PT_U16, },
128
+
[DEVLINK_ATTR_DPIPE_TABLES] = { .name = "dpipe-tables", .type = YNL_PT_NEST, .nest = &devlink_dl_dpipe_tables_nest, },
129
+
[DEVLINK_ATTR_DPIPE_TABLE] = { .name = "dpipe-table", .type = YNL_PT_NEST, .nest = &devlink_dl_dpipe_table_nest, },
130
+
[DEVLINK_ATTR_DPIPE_TABLE_NAME] = { .name = "dpipe-table-name", .type = YNL_PT_NUL_STR, },
131
+
[DEVLINK_ATTR_DPIPE_TABLE_SIZE] = { .name = "dpipe-table-size", .type = YNL_PT_U64, },
132
+
[DEVLINK_ATTR_DPIPE_TABLE_MATCHES] = { .name = "dpipe-table-matches", .type = YNL_PT_NEST, .nest = &devlink_dl_dpipe_table_matches_nest, },
133
+
[DEVLINK_ATTR_DPIPE_TABLE_ACTIONS] = { .name = "dpipe-table-actions", .type = YNL_PT_NEST, .nest = &devlink_dl_dpipe_table_actions_nest, },
134
+
[DEVLINK_ATTR_DPIPE_TABLE_COUNTERS_ENABLED] = { .name = "dpipe-table-counters-enabled", .type = YNL_PT_U8, },
135
+
[DEVLINK_ATTR_DPIPE_ENTRIES] = { .name = "dpipe-entries", .type = YNL_PT_NEST, .nest = &devlink_dl_dpipe_entries_nest, },
136
+
[DEVLINK_ATTR_DPIPE_ENTRY] = { .name = "dpipe-entry", .type = YNL_PT_NEST, .nest = &devlink_dl_dpipe_entry_nest, },
137
+
[DEVLINK_ATTR_DPIPE_ENTRY_INDEX] = { .name = "dpipe-entry-index", .type = YNL_PT_U64, },
138
+
[DEVLINK_ATTR_DPIPE_ENTRY_MATCH_VALUES] = { .name = "dpipe-entry-match-values", .type = YNL_PT_NEST, .nest = &devlink_dl_dpipe_entry_match_values_nest, },
139
+
[DEVLINK_ATTR_DPIPE_ENTRY_ACTION_VALUES] = { .name = "dpipe-entry-action-values", .type = YNL_PT_NEST, .nest = &devlink_dl_dpipe_entry_action_values_nest, },
140
+
[DEVLINK_ATTR_DPIPE_ENTRY_COUNTER] = { .name = "dpipe-entry-counter", .type = YNL_PT_U64, },
141
+
[DEVLINK_ATTR_DPIPE_MATCH] = { .name = "dpipe-match", .type = YNL_PT_NEST, .nest = &devlink_dl_dpipe_match_nest, },
142
+
[DEVLINK_ATTR_DPIPE_MATCH_VALUE] = { .name = "dpipe-match-value", .type = YNL_PT_NEST, .nest = &devlink_dl_dpipe_match_value_nest, },
143
+
[DEVLINK_ATTR_DPIPE_MATCH_TYPE] = { .name = "dpipe-match-type", .type = YNL_PT_U32, },
144
+
[DEVLINK_ATTR_DPIPE_ACTION] = { .name = "dpipe-action", .type = YNL_PT_NEST, .nest = &devlink_dl_dpipe_action_nest, },
145
+
[DEVLINK_ATTR_DPIPE_ACTION_VALUE] = { .name = "dpipe-action-value", .type = YNL_PT_NEST, .nest = &devlink_dl_dpipe_action_value_nest, },
146
+
[DEVLINK_ATTR_DPIPE_ACTION_TYPE] = { .name = "dpipe-action-type", .type = YNL_PT_U32, },
147
+
[DEVLINK_ATTR_DPIPE_VALUE] = { .name = "dpipe-value", .type = YNL_PT_BINARY,},
148
+
[DEVLINK_ATTR_DPIPE_VALUE_MASK] = { .name = "dpipe-value-mask", .type = YNL_PT_BINARY,},
149
+
[DEVLINK_ATTR_DPIPE_VALUE_MAPPING] = { .name = "dpipe-value-mapping", .type = YNL_PT_U32, },
150
+
[DEVLINK_ATTR_DPIPE_HEADERS] = { .name = "dpipe-headers", .type = YNL_PT_NEST, .nest = &devlink_dl_dpipe_headers_nest, },
151
+
[DEVLINK_ATTR_DPIPE_HEADER] = { .name = "dpipe-header", .type = YNL_PT_NEST, .nest = &devlink_dl_dpipe_header_nest, },
152
+
[DEVLINK_ATTR_DPIPE_HEADER_NAME] = { .name = "dpipe-header-name", .type = YNL_PT_NUL_STR, },
153
+
[DEVLINK_ATTR_DPIPE_HEADER_ID] = { .name = "dpipe-header-id", .type = YNL_PT_U32, },
154
+
[DEVLINK_ATTR_DPIPE_HEADER_FIELDS] = { .name = "dpipe-header-fields", .type = YNL_PT_NEST, .nest = &devlink_dl_dpipe_header_fields_nest, },
155
+
[DEVLINK_ATTR_DPIPE_HEADER_GLOBAL] = { .name = "dpipe-header-global", .type = YNL_PT_U8, },
156
+
[DEVLINK_ATTR_DPIPE_HEADER_INDEX] = { .name = "dpipe-header-index", .type = YNL_PT_U32, },
157
+
[DEVLINK_ATTR_DPIPE_FIELD] = { .name = "dpipe-field", .type = YNL_PT_NEST, .nest = &devlink_dl_dpipe_field_nest, },
158
+
[DEVLINK_ATTR_DPIPE_FIELD_NAME] = { .name = "dpipe-field-name", .type = YNL_PT_NUL_STR, },
159
+
[DEVLINK_ATTR_DPIPE_FIELD_ID] = { .name = "dpipe-field-id", .type = YNL_PT_U32, },
160
+
[DEVLINK_ATTR_DPIPE_FIELD_BITWIDTH] = { .name = "dpipe-field-bitwidth", .type = YNL_PT_U32, },
161
+
[DEVLINK_ATTR_DPIPE_FIELD_MAPPING_TYPE] = { .name = "dpipe-field-mapping-type", .type = YNL_PT_U32, },
162
+
[DEVLINK_ATTR_PAD] = { .name = "pad", .type = YNL_PT_IGNORE, },
163
+
[DEVLINK_ATTR_ESWITCH_ENCAP_MODE] = { .name = "eswitch-encap-mode", .type = YNL_PT_U8, },
164
+
[DEVLINK_ATTR_RESOURCE_LIST] = { .name = "resource-list", .type = YNL_PT_NEST, .nest = &devlink_dl_resource_list_nest, },
165
+
[DEVLINK_ATTR_RESOURCE] = { .name = "resource", .type = YNL_PT_NEST, .nest = &devlink_dl_resource_nest, },
166
+
[DEVLINK_ATTR_RESOURCE_NAME] = { .name = "resource-name", .type = YNL_PT_NUL_STR, },
167
+
[DEVLINK_ATTR_RESOURCE_ID] = { .name = "resource-id", .type = YNL_PT_U64, },
168
+
[DEVLINK_ATTR_RESOURCE_SIZE] = { .name = "resource-size", .type = YNL_PT_U64, },
169
+
[DEVLINK_ATTR_RESOURCE_SIZE_NEW] = { .name = "resource-size-new", .type = YNL_PT_U64, },
170
+
[DEVLINK_ATTR_RESOURCE_SIZE_VALID] = { .name = "resource-size-valid", .type = YNL_PT_U8, },
171
+
[DEVLINK_ATTR_RESOURCE_SIZE_MIN] = { .name = "resource-size-min", .type = YNL_PT_U64, },
172
+
[DEVLINK_ATTR_RESOURCE_SIZE_MAX] = { .name = "resource-size-max", .type = YNL_PT_U64, },
173
+
[DEVLINK_ATTR_RESOURCE_SIZE_GRAN] = { .name = "resource-size-gran", .type = YNL_PT_U64, },
174
+
[DEVLINK_ATTR_RESOURCE_UNIT] = { .name = "resource-unit", .type = YNL_PT_U8, },
175
+
[DEVLINK_ATTR_RESOURCE_OCC] = { .name = "resource-occ", .type = YNL_PT_U64, },
176
+
[DEVLINK_ATTR_DPIPE_TABLE_RESOURCE_ID] = { .name = "dpipe-table-resource-id", .type = YNL_PT_U64, },
177
+
[DEVLINK_ATTR_DPIPE_TABLE_RESOURCE_UNITS] = { .name = "dpipe-table-resource-units", .type = YNL_PT_U64, },
178
+
[DEVLINK_ATTR_PORT_FLAVOUR] = { .name = "port-flavour", .type = YNL_PT_U16, },
582
179
[DEVLINK_ATTR_PARAM_NAME] = { .name = "param-name", .type = YNL_PT_NUL_STR, },
180
+
[DEVLINK_ATTR_PARAM_TYPE] = { .name = "param-type", .type = YNL_PT_U8, },
181
+
[DEVLINK_ATTR_PARAM_VALUE_CMODE] = { .name = "param-value-cmode", .type = YNL_PT_U8, },
583
182
[DEVLINK_ATTR_REGION_NAME] = { .name = "region-name", .type = YNL_PT_NUL_STR, },
183
+
[DEVLINK_ATTR_REGION_SNAPSHOT_ID] = { .name = "region-snapshot-id", .type = YNL_PT_U32, },
184
+
[DEVLINK_ATTR_REGION_CHUNK_ADDR] = { .name = "region-chunk-addr", .type = YNL_PT_U64, },
185
+
[DEVLINK_ATTR_REGION_CHUNK_LEN] = { .name = "region-chunk-len", .type = YNL_PT_U64, },
584
186
[DEVLINK_ATTR_INFO_DRIVER_NAME] = { .name = "info-driver-name", .type = YNL_PT_NUL_STR, },
585
187
[DEVLINK_ATTR_INFO_SERIAL_NUMBER] = { .name = "info-serial-number", .type = YNL_PT_NUL_STR, },
586
188
[DEVLINK_ATTR_INFO_VERSION_FIXED] = { .name = "info-version-fixed", .type = YNL_PT_NEST, .nest = &devlink_dl_info_version_nest, },
···
651
127
[DEVLINK_ATTR_INFO_VERSION_STORED] = { .name = "info-version-stored", .type = YNL_PT_NEST, .nest = &devlink_dl_info_version_nest, },
652
128
[DEVLINK_ATTR_INFO_VERSION_NAME] = { .name = "info-version-name", .type = YNL_PT_NUL_STR, },
653
129
[DEVLINK_ATTR_INFO_VERSION_VALUE] = { .name = "info-version-value", .type = YNL_PT_NUL_STR, },
130
+
[DEVLINK_ATTR_FMSG] = { .name = "fmsg", .type = YNL_PT_NEST, .nest = &devlink_dl_fmsg_nest, },
131
+
[DEVLINK_ATTR_FMSG_OBJ_NEST_START] = { .name = "fmsg-obj-nest-start", .type = YNL_PT_FLAG, },
132
+
[DEVLINK_ATTR_FMSG_PAIR_NEST_START] = { .name = "fmsg-pair-nest-start", .type = YNL_PT_FLAG, },
133
+
[DEVLINK_ATTR_FMSG_ARR_NEST_START] = { .name = "fmsg-arr-nest-start", .type = YNL_PT_FLAG, },
134
+
[DEVLINK_ATTR_FMSG_NEST_END] = { .name = "fmsg-nest-end", .type = YNL_PT_FLAG, },
135
+
[DEVLINK_ATTR_FMSG_OBJ_NAME] = { .name = "fmsg-obj-name", .type = YNL_PT_NUL_STR, },
654
136
[DEVLINK_ATTR_HEALTH_REPORTER_NAME] = { .name = "health-reporter-name", .type = YNL_PT_NUL_STR, },
137
+
[DEVLINK_ATTR_HEALTH_REPORTER_GRACEFUL_PERIOD] = { .name = "health-reporter-graceful-period", .type = YNL_PT_U64, },
138
+
[DEVLINK_ATTR_HEALTH_REPORTER_AUTO_RECOVER] = { .name = "health-reporter-auto-recover", .type = YNL_PT_U8, },
139
+
[DEVLINK_ATTR_FLASH_UPDATE_FILE_NAME] = { .name = "flash-update-file-name", .type = YNL_PT_NUL_STR, },
140
+
[DEVLINK_ATTR_FLASH_UPDATE_COMPONENT] = { .name = "flash-update-component", .type = YNL_PT_NUL_STR, },
141
+
[DEVLINK_ATTR_PORT_PCI_PF_NUMBER] = { .name = "port-pci-pf-number", .type = YNL_PT_U16, },
655
142
[DEVLINK_ATTR_TRAP_NAME] = { .name = "trap-name", .type = YNL_PT_NUL_STR, },
143
+
[DEVLINK_ATTR_TRAP_ACTION] = { .name = "trap-action", .type = YNL_PT_U8, },
656
144
[DEVLINK_ATTR_TRAP_GROUP_NAME] = { .name = "trap-group-name", .type = YNL_PT_NUL_STR, },
657
145
[DEVLINK_ATTR_RELOAD_FAILED] = { .name = "reload-failed", .type = YNL_PT_U8, },
146
+
[DEVLINK_ATTR_NETNS_FD] = { .name = "netns-fd", .type = YNL_PT_U32, },
147
+
[DEVLINK_ATTR_NETNS_PID] = { .name = "netns-pid", .type = YNL_PT_U32, },
148
+
[DEVLINK_ATTR_NETNS_ID] = { .name = "netns-id", .type = YNL_PT_U32, },
149
+
[DEVLINK_ATTR_HEALTH_REPORTER_AUTO_DUMP] = { .name = "health-reporter-auto-dump", .type = YNL_PT_U8, },
658
150
[DEVLINK_ATTR_TRAP_POLICER_ID] = { .name = "trap-policer-id", .type = YNL_PT_U32, },
151
+
[DEVLINK_ATTR_TRAP_POLICER_RATE] = { .name = "trap-policer-rate", .type = YNL_PT_U64, },
152
+
[DEVLINK_ATTR_TRAP_POLICER_BURST] = { .name = "trap-policer-burst", .type = YNL_PT_U64, },
153
+
[DEVLINK_ATTR_PORT_FUNCTION] = { .name = "port-function", .type = YNL_PT_NEST, .nest = &devlink_dl_port_function_nest, },
154
+
[DEVLINK_ATTR_PORT_CONTROLLER_NUMBER] = { .name = "port-controller-number", .type = YNL_PT_U32, },
155
+
[DEVLINK_ATTR_FLASH_UPDATE_OVERWRITE_MASK] = { .name = "flash-update-overwrite-mask", .type = YNL_PT_BITFIELD32, },
659
156
[DEVLINK_ATTR_RELOAD_ACTION] = { .name = "reload-action", .type = YNL_PT_U8, },
157
+
[DEVLINK_ATTR_RELOAD_ACTIONS_PERFORMED] = { .name = "reload-actions-performed", .type = YNL_PT_BITFIELD32, },
158
+
[DEVLINK_ATTR_RELOAD_LIMITS] = { .name = "reload-limits", .type = YNL_PT_BITFIELD32, },
660
159
[DEVLINK_ATTR_DEV_STATS] = { .name = "dev-stats", .type = YNL_PT_NEST, .nest = &devlink_dl_dev_stats_nest, },
661
160
[DEVLINK_ATTR_RELOAD_STATS] = { .name = "reload-stats", .type = YNL_PT_NEST, .nest = &devlink_dl_reload_stats_nest, },
662
161
[DEVLINK_ATTR_RELOAD_STATS_ENTRY] = { .name = "reload-stats-entry", .type = YNL_PT_NEST, .nest = &devlink_dl_reload_stats_entry_nest, },
···
688
141
[DEVLINK_ATTR_REMOTE_RELOAD_STATS] = { .name = "remote-reload-stats", .type = YNL_PT_NEST, .nest = &devlink_dl_reload_stats_nest, },
689
142
[DEVLINK_ATTR_RELOAD_ACTION_INFO] = { .name = "reload-action-info", .type = YNL_PT_NEST, .nest = &devlink_dl_reload_act_info_nest, },
690
143
[DEVLINK_ATTR_RELOAD_ACTION_STATS] = { .name = "reload-action-stats", .type = YNL_PT_NEST, .nest = &devlink_dl_reload_act_stats_nest, },
144
+
[DEVLINK_ATTR_PORT_PCI_SF_NUMBER] = { .name = "port-pci-sf-number", .type = YNL_PT_U32, },
145
+
[DEVLINK_ATTR_RATE_TX_SHARE] = { .name = "rate-tx-share", .type = YNL_PT_U64, },
146
+
[DEVLINK_ATTR_RATE_TX_MAX] = { .name = "rate-tx-max", .type = YNL_PT_U64, },
691
147
[DEVLINK_ATTR_RATE_NODE_NAME] = { .name = "rate-node-name", .type = YNL_PT_NUL_STR, },
148
+
[DEVLINK_ATTR_RATE_PARENT_NODE_NAME] = { .name = "rate-parent-node-name", .type = YNL_PT_NUL_STR, },
692
149
[DEVLINK_ATTR_LINECARD_INDEX] = { .name = "linecard-index", .type = YNL_PT_U32, },
150
+
[DEVLINK_ATTR_LINECARD_TYPE] = { .name = "linecard-type", .type = YNL_PT_NUL_STR, },
151
+
[DEVLINK_ATTR_SELFTESTS] = { .name = "selftests", .type = YNL_PT_NEST, .nest = &devlink_dl_selftest_id_nest, },
152
+
[DEVLINK_ATTR_RATE_TX_PRIORITY] = { .name = "rate-tx-priority", .type = YNL_PT_U32, },
153
+
[DEVLINK_ATTR_RATE_TX_WEIGHT] = { .name = "rate-tx-weight", .type = YNL_PT_U32, },
154
+
[DEVLINK_ATTR_REGION_DIRECT] = { .name = "region-direct", .type = YNL_PT_FLAG, },
693
155
};
694
156
695
157
struct ynl_policy_nest devlink_nest = {
···
707
151
};
708
152
709
153
/* Common nested types */
154
+
void devlink_dl_dpipe_match_free(struct devlink_dl_dpipe_match *obj)
155
+
{
156
+
}
157
+
158
+
int devlink_dl_dpipe_match_parse(struct ynl_parse_arg *yarg,
159
+
const struct nlattr *nested)
160
+
{
161
+
struct devlink_dl_dpipe_match *dst = yarg->data;
162
+
const struct nlattr *attr;
163
+
164
+
mnl_attr_for_each_nested(attr, nested) {
165
+
unsigned int type = mnl_attr_get_type(attr);
166
+
167
+
if (type == DEVLINK_ATTR_DPIPE_MATCH_TYPE) {
168
+
if (ynl_attr_validate(yarg, attr))
169
+
return MNL_CB_ERROR;
170
+
dst->_present.dpipe_match_type = 1;
171
+
dst->dpipe_match_type = mnl_attr_get_u32(attr);
172
+
} else if (type == DEVLINK_ATTR_DPIPE_HEADER_ID) {
173
+
if (ynl_attr_validate(yarg, attr))
174
+
return MNL_CB_ERROR;
175
+
dst->_present.dpipe_header_id = 1;
176
+
dst->dpipe_header_id = mnl_attr_get_u32(attr);
177
+
} else if (type == DEVLINK_ATTR_DPIPE_HEADER_GLOBAL) {
178
+
if (ynl_attr_validate(yarg, attr))
179
+
return MNL_CB_ERROR;
180
+
dst->_present.dpipe_header_global = 1;
181
+
dst->dpipe_header_global = mnl_attr_get_u8(attr);
182
+
} else if (type == DEVLINK_ATTR_DPIPE_HEADER_INDEX) {
183
+
if (ynl_attr_validate(yarg, attr))
184
+
return MNL_CB_ERROR;
185
+
dst->_present.dpipe_header_index = 1;
186
+
dst->dpipe_header_index = mnl_attr_get_u32(attr);
187
+
} else if (type == DEVLINK_ATTR_DPIPE_FIELD_ID) {
188
+
if (ynl_attr_validate(yarg, attr))
189
+
return MNL_CB_ERROR;
190
+
dst->_present.dpipe_field_id = 1;
191
+
dst->dpipe_field_id = mnl_attr_get_u32(attr);
192
+
}
193
+
}
194
+
195
+
return 0;
196
+
}
197
+
198
+
void
199
+
devlink_dl_dpipe_match_value_free(struct devlink_dl_dpipe_match_value *obj)
200
+
{
201
+
unsigned int i;
202
+
203
+
for (i = 0; i < obj->n_dpipe_match; i++)
204
+
devlink_dl_dpipe_match_free(&obj->dpipe_match[i]);
205
+
free(obj->dpipe_match);
206
+
free(obj->dpipe_value);
207
+
free(obj->dpipe_value_mask);
208
+
}
209
+
210
+
int devlink_dl_dpipe_match_value_parse(struct ynl_parse_arg *yarg,
211
+
const struct nlattr *nested)
212
+
{
213
+
struct devlink_dl_dpipe_match_value *dst = yarg->data;
214
+
unsigned int n_dpipe_match = 0;
215
+
const struct nlattr *attr;
216
+
struct ynl_parse_arg parg;
217
+
int i;
218
+
219
+
parg.ys = yarg->ys;
220
+
221
+
if (dst->dpipe_match)
222
+
return ynl_error_parse(yarg, "attribute already present (dl-dpipe-match-value.dpipe-match)");
223
+
224
+
mnl_attr_for_each_nested(attr, nested) {
225
+
unsigned int type = mnl_attr_get_type(attr);
226
+
227
+
if (type == DEVLINK_ATTR_DPIPE_MATCH) {
228
+
n_dpipe_match++;
229
+
} else if (type == DEVLINK_ATTR_DPIPE_VALUE) {
230
+
unsigned int len;
231
+
232
+
if (ynl_attr_validate(yarg, attr))
233
+
return MNL_CB_ERROR;
234
+
235
+
len = mnl_attr_get_payload_len(attr);
236
+
dst->_present.dpipe_value_len = len;
237
+
dst->dpipe_value = malloc(len);
238
+
memcpy(dst->dpipe_value, mnl_attr_get_payload(attr), len);
239
+
} else if (type == DEVLINK_ATTR_DPIPE_VALUE_MASK) {
240
+
unsigned int len;
241
+
242
+
if (ynl_attr_validate(yarg, attr))
243
+
return MNL_CB_ERROR;
244
+
245
+
len = mnl_attr_get_payload_len(attr);
246
+
dst->_present.dpipe_value_mask_len = len;
247
+
dst->dpipe_value_mask = malloc(len);
248
+
memcpy(dst->dpipe_value_mask, mnl_attr_get_payload(attr), len);
249
+
} else if (type == DEVLINK_ATTR_DPIPE_VALUE_MAPPING) {
250
+
if (ynl_attr_validate(yarg, attr))
251
+
return MNL_CB_ERROR;
252
+
dst->_present.dpipe_value_mapping = 1;
253
+
dst->dpipe_value_mapping = mnl_attr_get_u32(attr);
254
+
}
255
+
}
256
+
257
+
if (n_dpipe_match) {
258
+
dst->dpipe_match = calloc(n_dpipe_match, sizeof(*dst->dpipe_match));
259
+
dst->n_dpipe_match = n_dpipe_match;
260
+
i = 0;
261
+
parg.rsp_policy = &devlink_dl_dpipe_match_nest;
262
+
mnl_attr_for_each_nested(attr, nested) {
263
+
if (mnl_attr_get_type(attr) == DEVLINK_ATTR_DPIPE_MATCH) {
264
+
parg.data = &dst->dpipe_match[i];
265
+
if (devlink_dl_dpipe_match_parse(&parg, attr))
266
+
return MNL_CB_ERROR;
267
+
i++;
268
+
}
269
+
}
270
+
}
271
+
272
+
return 0;
273
+
}
274
+
275
+
void devlink_dl_dpipe_action_free(struct devlink_dl_dpipe_action *obj)
276
+
{
277
+
}
278
+
279
+
int devlink_dl_dpipe_action_parse(struct ynl_parse_arg *yarg,
280
+
const struct nlattr *nested)
281
+
{
282
+
struct devlink_dl_dpipe_action *dst = yarg->data;
283
+
const struct nlattr *attr;
284
+
285
+
mnl_attr_for_each_nested(attr, nested) {
286
+
unsigned int type = mnl_attr_get_type(attr);
287
+
288
+
if (type == DEVLINK_ATTR_DPIPE_ACTION_TYPE) {
289
+
if (ynl_attr_validate(yarg, attr))
290
+
return MNL_CB_ERROR;
291
+
dst->_present.dpipe_action_type = 1;
292
+
dst->dpipe_action_type = mnl_attr_get_u32(attr);
293
+
} else if (type == DEVLINK_ATTR_DPIPE_HEADER_ID) {
294
+
if (ynl_attr_validate(yarg, attr))
295
+
return MNL_CB_ERROR;
296
+
dst->_present.dpipe_header_id = 1;
297
+
dst->dpipe_header_id = mnl_attr_get_u32(attr);
298
+
} else if (type == DEVLINK_ATTR_DPIPE_HEADER_GLOBAL) {
299
+
if (ynl_attr_validate(yarg, attr))
300
+
return MNL_CB_ERROR;
301
+
dst->_present.dpipe_header_global = 1;
302
+
dst->dpipe_header_global = mnl_attr_get_u8(attr);
303
+
} else if (type == DEVLINK_ATTR_DPIPE_HEADER_INDEX) {
304
+
if (ynl_attr_validate(yarg, attr))
305
+
return MNL_CB_ERROR;
306
+
dst->_present.dpipe_header_index = 1;
307
+
dst->dpipe_header_index = mnl_attr_get_u32(attr);
308
+
} else if (type == DEVLINK_ATTR_DPIPE_FIELD_ID) {
309
+
if (ynl_attr_validate(yarg, attr))
310
+
return MNL_CB_ERROR;
311
+
dst->_present.dpipe_field_id = 1;
312
+
dst->dpipe_field_id = mnl_attr_get_u32(attr);
313
+
}
314
+
}
315
+
316
+
return 0;
317
+
}
318
+
319
+
void
320
+
devlink_dl_dpipe_action_value_free(struct devlink_dl_dpipe_action_value *obj)
321
+
{
322
+
unsigned int i;
323
+
324
+
for (i = 0; i < obj->n_dpipe_action; i++)
325
+
devlink_dl_dpipe_action_free(&obj->dpipe_action[i]);
326
+
free(obj->dpipe_action);
327
+
free(obj->dpipe_value);
328
+
free(obj->dpipe_value_mask);
329
+
}
330
+
331
+
int devlink_dl_dpipe_action_value_parse(struct ynl_parse_arg *yarg,
332
+
const struct nlattr *nested)
333
+
{
334
+
struct devlink_dl_dpipe_action_value *dst = yarg->data;
335
+
unsigned int n_dpipe_action = 0;
336
+
const struct nlattr *attr;
337
+
struct ynl_parse_arg parg;
338
+
int i;
339
+
340
+
parg.ys = yarg->ys;
341
+
342
+
if (dst->dpipe_action)
343
+
return ynl_error_parse(yarg, "attribute already present (dl-dpipe-action-value.dpipe-action)");
344
+
345
+
mnl_attr_for_each_nested(attr, nested) {
346
+
unsigned int type = mnl_attr_get_type(attr);
347
+
348
+
if (type == DEVLINK_ATTR_DPIPE_ACTION) {
349
+
n_dpipe_action++;
350
+
} else if (type == DEVLINK_ATTR_DPIPE_VALUE) {
351
+
unsigned int len;
352
+
353
+
if (ynl_attr_validate(yarg, attr))
354
+
return MNL_CB_ERROR;
355
+
356
+
len = mnl_attr_get_payload_len(attr);
357
+
dst->_present.dpipe_value_len = len;
358
+
dst->dpipe_value = malloc(len);
359
+
memcpy(dst->dpipe_value, mnl_attr_get_payload(attr), len);
360
+
} else if (type == DEVLINK_ATTR_DPIPE_VALUE_MASK) {
361
+
unsigned int len;
362
+
363
+
if (ynl_attr_validate(yarg, attr))
364
+
return MNL_CB_ERROR;
365
+
366
+
len = mnl_attr_get_payload_len(attr);
367
+
dst->_present.dpipe_value_mask_len = len;
368
+
dst->dpipe_value_mask = malloc(len);
369
+
memcpy(dst->dpipe_value_mask, mnl_attr_get_payload(attr), len);
370
+
} else if (type == DEVLINK_ATTR_DPIPE_VALUE_MAPPING) {
371
+
if (ynl_attr_validate(yarg, attr))
372
+
return MNL_CB_ERROR;
373
+
dst->_present.dpipe_value_mapping = 1;
374
+
dst->dpipe_value_mapping = mnl_attr_get_u32(attr);
375
+
}
376
+
}
377
+
378
+
if (n_dpipe_action) {
379
+
dst->dpipe_action = calloc(n_dpipe_action, sizeof(*dst->dpipe_action));
380
+
dst->n_dpipe_action = n_dpipe_action;
381
+
i = 0;
382
+
parg.rsp_policy = &devlink_dl_dpipe_action_nest;
383
+
mnl_attr_for_each_nested(attr, nested) {
384
+
if (mnl_attr_get_type(attr) == DEVLINK_ATTR_DPIPE_ACTION) {
385
+
parg.data = &dst->dpipe_action[i];
386
+
if (devlink_dl_dpipe_action_parse(&parg, attr))
387
+
return MNL_CB_ERROR;
388
+
i++;
389
+
}
390
+
}
391
+
}
392
+
393
+
return 0;
394
+
}
395
+
396
+
void devlink_dl_dpipe_field_free(struct devlink_dl_dpipe_field *obj)
397
+
{
398
+
free(obj->dpipe_field_name);
399
+
}
400
+
401
+
int devlink_dl_dpipe_field_parse(struct ynl_parse_arg *yarg,
402
+
const struct nlattr *nested)
403
+
{
404
+
struct devlink_dl_dpipe_field *dst = yarg->data;
405
+
const struct nlattr *attr;
406
+
407
+
mnl_attr_for_each_nested(attr, nested) {
408
+
unsigned int type = mnl_attr_get_type(attr);
409
+
410
+
if (type == DEVLINK_ATTR_DPIPE_FIELD_NAME) {
411
+
unsigned int len;
412
+
413
+
if (ynl_attr_validate(yarg, attr))
414
+
return MNL_CB_ERROR;
415
+
416
+
len = strnlen(mnl_attr_get_str(attr), mnl_attr_get_payload_len(attr));
417
+
dst->_present.dpipe_field_name_len = len;
418
+
dst->dpipe_field_name = malloc(len + 1);
419
+
memcpy(dst->dpipe_field_name, mnl_attr_get_str(attr), len);
420
+
dst->dpipe_field_name[len] = 0;
421
+
} else if (type == DEVLINK_ATTR_DPIPE_FIELD_ID) {
422
+
if (ynl_attr_validate(yarg, attr))
423
+
return MNL_CB_ERROR;
424
+
dst->_present.dpipe_field_id = 1;
425
+
dst->dpipe_field_id = mnl_attr_get_u32(attr);
426
+
} else if (type == DEVLINK_ATTR_DPIPE_FIELD_BITWIDTH) {
427
+
if (ynl_attr_validate(yarg, attr))
428
+
return MNL_CB_ERROR;
429
+
dst->_present.dpipe_field_bitwidth = 1;
430
+
dst->dpipe_field_bitwidth = mnl_attr_get_u32(attr);
431
+
} else if (type == DEVLINK_ATTR_DPIPE_FIELD_MAPPING_TYPE) {
432
+
if (ynl_attr_validate(yarg, attr))
433
+
return MNL_CB_ERROR;
434
+
dst->_present.dpipe_field_mapping_type = 1;
435
+
dst->dpipe_field_mapping_type = mnl_attr_get_u32(attr);
436
+
}
437
+
}
438
+
439
+
return 0;
440
+
}
441
+
442
+
void devlink_dl_resource_free(struct devlink_dl_resource *obj)
443
+
{
444
+
free(obj->resource_name);
445
+
}
446
+
447
+
int devlink_dl_resource_parse(struct ynl_parse_arg *yarg,
448
+
const struct nlattr *nested)
449
+
{
450
+
struct devlink_dl_resource *dst = yarg->data;
451
+
const struct nlattr *attr;
452
+
453
+
mnl_attr_for_each_nested(attr, nested) {
454
+
unsigned int type = mnl_attr_get_type(attr);
455
+
456
+
if (type == DEVLINK_ATTR_RESOURCE_NAME) {
457
+
unsigned int len;
458
+
459
+
if (ynl_attr_validate(yarg, attr))
460
+
return MNL_CB_ERROR;
461
+
462
+
len = strnlen(mnl_attr_get_str(attr), mnl_attr_get_payload_len(attr));
463
+
dst->_present.resource_name_len = len;
464
+
dst->resource_name = malloc(len + 1);
465
+
memcpy(dst->resource_name, mnl_attr_get_str(attr), len);
466
+
dst->resource_name[len] = 0;
467
+
} else if (type == DEVLINK_ATTR_RESOURCE_ID) {
468
+
if (ynl_attr_validate(yarg, attr))
469
+
return MNL_CB_ERROR;
470
+
dst->_present.resource_id = 1;
471
+
dst->resource_id = mnl_attr_get_u64(attr);
472
+
} else if (type == DEVLINK_ATTR_RESOURCE_SIZE) {
473
+
if (ynl_attr_validate(yarg, attr))
474
+
return MNL_CB_ERROR;
475
+
dst->_present.resource_size = 1;
476
+
dst->resource_size = mnl_attr_get_u64(attr);
477
+
} else if (type == DEVLINK_ATTR_RESOURCE_SIZE_NEW) {
478
+
if (ynl_attr_validate(yarg, attr))
479
+
return MNL_CB_ERROR;
480
+
dst->_present.resource_size_new = 1;
481
+
dst->resource_size_new = mnl_attr_get_u64(attr);
482
+
} else if (type == DEVLINK_ATTR_RESOURCE_SIZE_VALID) {
483
+
if (ynl_attr_validate(yarg, attr))
484
+
return MNL_CB_ERROR;
485
+
dst->_present.resource_size_valid = 1;
486
+
dst->resource_size_valid = mnl_attr_get_u8(attr);
487
+
} else if (type == DEVLINK_ATTR_RESOURCE_SIZE_MIN) {
488
+
if (ynl_attr_validate(yarg, attr))
489
+
return MNL_CB_ERROR;
490
+
dst->_present.resource_size_min = 1;
491
+
dst->resource_size_min = mnl_attr_get_u64(attr);
492
+
} else if (type == DEVLINK_ATTR_RESOURCE_SIZE_MAX) {
493
+
if (ynl_attr_validate(yarg, attr))
494
+
return MNL_CB_ERROR;
495
+
dst->_present.resource_size_max = 1;
496
+
dst->resource_size_max = mnl_attr_get_u64(attr);
497
+
} else if (type == DEVLINK_ATTR_RESOURCE_SIZE_GRAN) {
498
+
if (ynl_attr_validate(yarg, attr))
499
+
return MNL_CB_ERROR;
500
+
dst->_present.resource_size_gran = 1;
501
+
dst->resource_size_gran = mnl_attr_get_u64(attr);
502
+
} else if (type == DEVLINK_ATTR_RESOURCE_UNIT) {
503
+
if (ynl_attr_validate(yarg, attr))
504
+
return MNL_CB_ERROR;
505
+
dst->_present.resource_unit = 1;
506
+
dst->resource_unit = mnl_attr_get_u8(attr);
507
+
} else if (type == DEVLINK_ATTR_RESOURCE_OCC) {
508
+
if (ynl_attr_validate(yarg, attr))
509
+
return MNL_CB_ERROR;
510
+
dst->_present.resource_occ = 1;
511
+
dst->resource_occ = mnl_attr_get_u64(attr);
512
+
}
513
+
}
514
+
515
+
return 0;
516
+
}
517
+
710
518
void devlink_dl_info_version_free(struct devlink_dl_info_version *obj)
711
519
{
712
520
free(obj->info_version_name);
···
1110
190
dst->info_version_value[len] = 0;
1111
191
}
1112
192
}
193
+
194
+
return 0;
195
+
}
196
+
197
+
void devlink_dl_fmsg_free(struct devlink_dl_fmsg *obj)
198
+
{
199
+
free(obj->fmsg_obj_name);
200
+
}
201
+
202
+
int devlink_dl_fmsg_parse(struct ynl_parse_arg *yarg,
203
+
const struct nlattr *nested)
204
+
{
205
+
struct devlink_dl_fmsg *dst = yarg->data;
206
+
const struct nlattr *attr;
207
+
208
+
mnl_attr_for_each_nested(attr, nested) {
209
+
unsigned int type = mnl_attr_get_type(attr);
210
+
211
+
if (type == DEVLINK_ATTR_FMSG_OBJ_NEST_START) {
212
+
if (ynl_attr_validate(yarg, attr))
213
+
return MNL_CB_ERROR;
214
+
dst->_present.fmsg_obj_nest_start = 1;
215
+
} else if (type == DEVLINK_ATTR_FMSG_PAIR_NEST_START) {
216
+
if (ynl_attr_validate(yarg, attr))
217
+
return MNL_CB_ERROR;
218
+
dst->_present.fmsg_pair_nest_start = 1;
219
+
} else if (type == DEVLINK_ATTR_FMSG_ARR_NEST_START) {
220
+
if (ynl_attr_validate(yarg, attr))
221
+
return MNL_CB_ERROR;
222
+
dst->_present.fmsg_arr_nest_start = 1;
223
+
} else if (type == DEVLINK_ATTR_FMSG_NEST_END) {
224
+
if (ynl_attr_validate(yarg, attr))
225
+
return MNL_CB_ERROR;
226
+
dst->_present.fmsg_nest_end = 1;
227
+
} else if (type == DEVLINK_ATTR_FMSG_OBJ_NAME) {
228
+
unsigned int len;
229
+
230
+
if (ynl_attr_validate(yarg, attr))
231
+
return MNL_CB_ERROR;
232
+
233
+
len = strnlen(mnl_attr_get_str(attr), mnl_attr_get_payload_len(attr));
234
+
dst->_present.fmsg_obj_name_len = len;
235
+
dst->fmsg_obj_name = malloc(len + 1);
236
+
memcpy(dst->fmsg_obj_name, mnl_attr_get_str(attr), len);
237
+
dst->fmsg_obj_name[len] = 0;
238
+
}
239
+
}
240
+
241
+
return 0;
242
+
}
243
+
244
+
void devlink_dl_port_function_free(struct devlink_dl_port_function *obj)
245
+
{
246
+
free(obj->hw_addr);
247
+
}
248
+
249
+
int devlink_dl_port_function_put(struct nlmsghdr *nlh, unsigned int attr_type,
250
+
struct devlink_dl_port_function *obj)
251
+
{
252
+
struct nlattr *nest;
253
+
254
+
nest = mnl_attr_nest_start(nlh, attr_type);
255
+
if (obj->_present.hw_addr_len)
256
+
mnl_attr_put(nlh, DEVLINK_PORT_FUNCTION_ATTR_HW_ADDR, obj->_present.hw_addr_len, obj->hw_addr);
257
+
if (obj->_present.state)
258
+
mnl_attr_put_u8(nlh, DEVLINK_PORT_FN_ATTR_STATE, obj->state);
259
+
if (obj->_present.opstate)
260
+
mnl_attr_put_u8(nlh, DEVLINK_PORT_FN_ATTR_OPSTATE, obj->opstate);
261
+
if (obj->_present.caps)
262
+
mnl_attr_put(nlh, DEVLINK_PORT_FN_ATTR_CAPS, sizeof(struct nla_bitfield32), &obj->caps);
263
+
mnl_attr_nest_end(nlh, nest);
1113
264
1114
265
return 0;
1115
266
}
···
1264
273
return 0;
1265
274
}
1266
275
276
+
void devlink_dl_selftest_id_free(struct devlink_dl_selftest_id *obj)
277
+
{
278
+
}
279
+
280
+
int devlink_dl_selftest_id_put(struct nlmsghdr *nlh, unsigned int attr_type,
281
+
struct devlink_dl_selftest_id *obj)
282
+
{
283
+
struct nlattr *nest;
284
+
285
+
nest = mnl_attr_nest_start(nlh, attr_type);
286
+
if (obj->_present.flash)
287
+
mnl_attr_put(nlh, DEVLINK_ATTR_SELFTEST_ID_FLASH, 0, NULL);
288
+
mnl_attr_nest_end(nlh, nest);
289
+
290
+
return 0;
291
+
}
292
+
293
+
void
294
+
devlink_dl_dpipe_table_matches_free(struct devlink_dl_dpipe_table_matches *obj)
295
+
{
296
+
unsigned int i;
297
+
298
+
for (i = 0; i < obj->n_dpipe_match; i++)
299
+
devlink_dl_dpipe_match_free(&obj->dpipe_match[i]);
300
+
free(obj->dpipe_match);
301
+
}
302
+
303
+
int devlink_dl_dpipe_table_matches_parse(struct ynl_parse_arg *yarg,
304
+
const struct nlattr *nested)
305
+
{
306
+
struct devlink_dl_dpipe_table_matches *dst = yarg->data;
307
+
unsigned int n_dpipe_match = 0;
308
+
const struct nlattr *attr;
309
+
struct ynl_parse_arg parg;
310
+
int i;
311
+
312
+
parg.ys = yarg->ys;
313
+
314
+
if (dst->dpipe_match)
315
+
return ynl_error_parse(yarg, "attribute already present (dl-dpipe-table-matches.dpipe-match)");
316
+
317
+
mnl_attr_for_each_nested(attr, nested) {
318
+
unsigned int type = mnl_attr_get_type(attr);
319
+
320
+
if (type == DEVLINK_ATTR_DPIPE_MATCH) {
321
+
n_dpipe_match++;
322
+
}
323
+
}
324
+
325
+
if (n_dpipe_match) {
326
+
dst->dpipe_match = calloc(n_dpipe_match, sizeof(*dst->dpipe_match));
327
+
dst->n_dpipe_match = n_dpipe_match;
328
+
i = 0;
329
+
parg.rsp_policy = &devlink_dl_dpipe_match_nest;
330
+
mnl_attr_for_each_nested(attr, nested) {
331
+
if (mnl_attr_get_type(attr) == DEVLINK_ATTR_DPIPE_MATCH) {
332
+
parg.data = &dst->dpipe_match[i];
333
+
if (devlink_dl_dpipe_match_parse(&parg, attr))
334
+
return MNL_CB_ERROR;
335
+
i++;
336
+
}
337
+
}
338
+
}
339
+
340
+
return 0;
341
+
}
342
+
343
+
void
344
+
devlink_dl_dpipe_table_actions_free(struct devlink_dl_dpipe_table_actions *obj)
345
+
{
346
+
unsigned int i;
347
+
348
+
for (i = 0; i < obj->n_dpipe_action; i++)
349
+
devlink_dl_dpipe_action_free(&obj->dpipe_action[i]);
350
+
free(obj->dpipe_action);
351
+
}
352
+
353
+
int devlink_dl_dpipe_table_actions_parse(struct ynl_parse_arg *yarg,
354
+
const struct nlattr *nested)
355
+
{
356
+
struct devlink_dl_dpipe_table_actions *dst = yarg->data;
357
+
unsigned int n_dpipe_action = 0;
358
+
const struct nlattr *attr;
359
+
struct ynl_parse_arg parg;
360
+
int i;
361
+
362
+
parg.ys = yarg->ys;
363
+
364
+
if (dst->dpipe_action)
365
+
return ynl_error_parse(yarg, "attribute already present (dl-dpipe-table-actions.dpipe-action)");
366
+
367
+
mnl_attr_for_each_nested(attr, nested) {
368
+
unsigned int type = mnl_attr_get_type(attr);
369
+
370
+
if (type == DEVLINK_ATTR_DPIPE_ACTION) {
371
+
n_dpipe_action++;
372
+
}
373
+
}
374
+
375
+
if (n_dpipe_action) {
376
+
dst->dpipe_action = calloc(n_dpipe_action, sizeof(*dst->dpipe_action));
377
+
dst->n_dpipe_action = n_dpipe_action;
378
+
i = 0;
379
+
parg.rsp_policy = &devlink_dl_dpipe_action_nest;
380
+
mnl_attr_for_each_nested(attr, nested) {
381
+
if (mnl_attr_get_type(attr) == DEVLINK_ATTR_DPIPE_ACTION) {
382
+
parg.data = &dst->dpipe_action[i];
383
+
if (devlink_dl_dpipe_action_parse(&parg, attr))
384
+
return MNL_CB_ERROR;
385
+
i++;
386
+
}
387
+
}
388
+
}
389
+
390
+
return 0;
391
+
}
392
+
393
+
void
394
+
devlink_dl_dpipe_entry_match_values_free(struct devlink_dl_dpipe_entry_match_values *obj)
395
+
{
396
+
unsigned int i;
397
+
398
+
for (i = 0; i < obj->n_dpipe_match_value; i++)
399
+
devlink_dl_dpipe_match_value_free(&obj->dpipe_match_value[i]);
400
+
free(obj->dpipe_match_value);
401
+
}
402
+
403
+
int devlink_dl_dpipe_entry_match_values_parse(struct ynl_parse_arg *yarg,
404
+
const struct nlattr *nested)
405
+
{
406
+
struct devlink_dl_dpipe_entry_match_values *dst = yarg->data;
407
+
unsigned int n_dpipe_match_value = 0;
408
+
const struct nlattr *attr;
409
+
struct ynl_parse_arg parg;
410
+
int i;
411
+
412
+
parg.ys = yarg->ys;
413
+
414
+
if (dst->dpipe_match_value)
415
+
return ynl_error_parse(yarg, "attribute already present (dl-dpipe-entry-match-values.dpipe-match-value)");
416
+
417
+
mnl_attr_for_each_nested(attr, nested) {
418
+
unsigned int type = mnl_attr_get_type(attr);
419
+
420
+
if (type == DEVLINK_ATTR_DPIPE_MATCH_VALUE) {
421
+
n_dpipe_match_value++;
422
+
}
423
+
}
424
+
425
+
if (n_dpipe_match_value) {
426
+
dst->dpipe_match_value = calloc(n_dpipe_match_value, sizeof(*dst->dpipe_match_value));
427
+
dst->n_dpipe_match_value = n_dpipe_match_value;
428
+
i = 0;
429
+
parg.rsp_policy = &devlink_dl_dpipe_match_value_nest;
430
+
mnl_attr_for_each_nested(attr, nested) {
431
+
if (mnl_attr_get_type(attr) == DEVLINK_ATTR_DPIPE_MATCH_VALUE) {
432
+
parg.data = &dst->dpipe_match_value[i];
433
+
if (devlink_dl_dpipe_match_value_parse(&parg, attr))
434
+
return MNL_CB_ERROR;
435
+
i++;
436
+
}
437
+
}
438
+
}
439
+
440
+
return 0;
441
+
}
442
+
443
+
void
444
+
devlink_dl_dpipe_entry_action_values_free(struct devlink_dl_dpipe_entry_action_values *obj)
445
+
{
446
+
unsigned int i;
447
+
448
+
for (i = 0; i < obj->n_dpipe_action_value; i++)
449
+
devlink_dl_dpipe_action_value_free(&obj->dpipe_action_value[i]);
450
+
free(obj->dpipe_action_value);
451
+
}
452
+
453
+
int devlink_dl_dpipe_entry_action_values_parse(struct ynl_parse_arg *yarg,
454
+
const struct nlattr *nested)
455
+
{
456
+
struct devlink_dl_dpipe_entry_action_values *dst = yarg->data;
457
+
unsigned int n_dpipe_action_value = 0;
458
+
const struct nlattr *attr;
459
+
struct ynl_parse_arg parg;
460
+
int i;
461
+
462
+
parg.ys = yarg->ys;
463
+
464
+
if (dst->dpipe_action_value)
465
+
return ynl_error_parse(yarg, "attribute already present (dl-dpipe-entry-action-values.dpipe-action-value)");
466
+
467
+
mnl_attr_for_each_nested(attr, nested) {
468
+
unsigned int type = mnl_attr_get_type(attr);
469
+
470
+
if (type == DEVLINK_ATTR_DPIPE_ACTION_VALUE) {
471
+
n_dpipe_action_value++;
472
+
}
473
+
}
474
+
475
+
if (n_dpipe_action_value) {
476
+
dst->dpipe_action_value = calloc(n_dpipe_action_value, sizeof(*dst->dpipe_action_value));
477
+
dst->n_dpipe_action_value = n_dpipe_action_value;
478
+
i = 0;
479
+
parg.rsp_policy = &devlink_dl_dpipe_action_value_nest;
480
+
mnl_attr_for_each_nested(attr, nested) {
481
+
if (mnl_attr_get_type(attr) == DEVLINK_ATTR_DPIPE_ACTION_VALUE) {
482
+
parg.data = &dst->dpipe_action_value[i];
483
+
if (devlink_dl_dpipe_action_value_parse(&parg, attr))
484
+
return MNL_CB_ERROR;
485
+
i++;
486
+
}
487
+
}
488
+
}
489
+
490
+
return 0;
491
+
}
492
+
493
+
void
494
+
devlink_dl_dpipe_header_fields_free(struct devlink_dl_dpipe_header_fields *obj)
495
+
{
496
+
unsigned int i;
497
+
498
+
for (i = 0; i < obj->n_dpipe_field; i++)
499
+
devlink_dl_dpipe_field_free(&obj->dpipe_field[i]);
500
+
free(obj->dpipe_field);
501
+
}
502
+
503
+
int devlink_dl_dpipe_header_fields_parse(struct ynl_parse_arg *yarg,
504
+
const struct nlattr *nested)
505
+
{
506
+
struct devlink_dl_dpipe_header_fields *dst = yarg->data;
507
+
unsigned int n_dpipe_field = 0;
508
+
const struct nlattr *attr;
509
+
struct ynl_parse_arg parg;
510
+
int i;
511
+
512
+
parg.ys = yarg->ys;
513
+
514
+
if (dst->dpipe_field)
515
+
return ynl_error_parse(yarg, "attribute already present (dl-dpipe-header-fields.dpipe-field)");
516
+
517
+
mnl_attr_for_each_nested(attr, nested) {
518
+
unsigned int type = mnl_attr_get_type(attr);
519
+
520
+
if (type == DEVLINK_ATTR_DPIPE_FIELD) {
521
+
n_dpipe_field++;
522
+
}
523
+
}
524
+
525
+
if (n_dpipe_field) {
526
+
dst->dpipe_field = calloc(n_dpipe_field, sizeof(*dst->dpipe_field));
527
+
dst->n_dpipe_field = n_dpipe_field;
528
+
i = 0;
529
+
parg.rsp_policy = &devlink_dl_dpipe_field_nest;
530
+
mnl_attr_for_each_nested(attr, nested) {
531
+
if (mnl_attr_get_type(attr) == DEVLINK_ATTR_DPIPE_FIELD) {
532
+
parg.data = &dst->dpipe_field[i];
533
+
if (devlink_dl_dpipe_field_parse(&parg, attr))
534
+
return MNL_CB_ERROR;
535
+
i++;
536
+
}
537
+
}
538
+
}
539
+
540
+
return 0;
541
+
}
542
+
543
+
void devlink_dl_resource_list_free(struct devlink_dl_resource_list *obj)
544
+
{
545
+
unsigned int i;
546
+
547
+
for (i = 0; i < obj->n_resource; i++)
548
+
devlink_dl_resource_free(&obj->resource[i]);
549
+
free(obj->resource);
550
+
}
551
+
552
+
int devlink_dl_resource_list_parse(struct ynl_parse_arg *yarg,
553
+
const struct nlattr *nested)
554
+
{
555
+
struct devlink_dl_resource_list *dst = yarg->data;
556
+
unsigned int n_resource = 0;
557
+
const struct nlattr *attr;
558
+
struct ynl_parse_arg parg;
559
+
int i;
560
+
561
+
parg.ys = yarg->ys;
562
+
563
+
if (dst->resource)
564
+
return ynl_error_parse(yarg, "attribute already present (dl-resource-list.resource)");
565
+
566
+
mnl_attr_for_each_nested(attr, nested) {
567
+
unsigned int type = mnl_attr_get_type(attr);
568
+
569
+
if (type == DEVLINK_ATTR_RESOURCE) {
570
+
n_resource++;
571
+
}
572
+
}
573
+
574
+
if (n_resource) {
575
+
dst->resource = calloc(n_resource, sizeof(*dst->resource));
576
+
dst->n_resource = n_resource;
577
+
i = 0;
578
+
parg.rsp_policy = &devlink_dl_resource_nest;
579
+
mnl_attr_for_each_nested(attr, nested) {
580
+
if (mnl_attr_get_type(attr) == DEVLINK_ATTR_RESOURCE) {
581
+
parg.data = &dst->resource[i];
582
+
if (devlink_dl_resource_parse(&parg, attr))
583
+
return MNL_CB_ERROR;
584
+
i++;
585
+
}
586
+
}
587
+
}
588
+
589
+
return 0;
590
+
}
591
+
1267
592
void devlink_dl_reload_act_info_free(struct devlink_dl_reload_act_info *obj)
1268
593
{
1269
594
unsigned int i;
···
1634
327
return 0;
1635
328
}
1636
329
330
+
void devlink_dl_dpipe_table_free(struct devlink_dl_dpipe_table *obj)
331
+
{
332
+
free(obj->dpipe_table_name);
333
+
devlink_dl_dpipe_table_matches_free(&obj->dpipe_table_matches);
334
+
devlink_dl_dpipe_table_actions_free(&obj->dpipe_table_actions);
335
+
}
336
+
337
+
int devlink_dl_dpipe_table_parse(struct ynl_parse_arg *yarg,
338
+
const struct nlattr *nested)
339
+
{
340
+
struct devlink_dl_dpipe_table *dst = yarg->data;
341
+
const struct nlattr *attr;
342
+
struct ynl_parse_arg parg;
343
+
344
+
parg.ys = yarg->ys;
345
+
346
+
mnl_attr_for_each_nested(attr, nested) {
347
+
unsigned int type = mnl_attr_get_type(attr);
348
+
349
+
if (type == DEVLINK_ATTR_DPIPE_TABLE_NAME) {
350
+
unsigned int len;
351
+
352
+
if (ynl_attr_validate(yarg, attr))
353
+
return MNL_CB_ERROR;
354
+
355
+
len = strnlen(mnl_attr_get_str(attr), mnl_attr_get_payload_len(attr));
356
+
dst->_present.dpipe_table_name_len = len;
357
+
dst->dpipe_table_name = malloc(len + 1);
358
+
memcpy(dst->dpipe_table_name, mnl_attr_get_str(attr), len);
359
+
dst->dpipe_table_name[len] = 0;
360
+
} else if (type == DEVLINK_ATTR_DPIPE_TABLE_SIZE) {
361
+
if (ynl_attr_validate(yarg, attr))
362
+
return MNL_CB_ERROR;
363
+
dst->_present.dpipe_table_size = 1;
364
+
dst->dpipe_table_size = mnl_attr_get_u64(attr);
365
+
} else if (type == DEVLINK_ATTR_DPIPE_TABLE_MATCHES) {
366
+
if (ynl_attr_validate(yarg, attr))
367
+
return MNL_CB_ERROR;
368
+
dst->_present.dpipe_table_matches = 1;
369
+
370
+
parg.rsp_policy = &devlink_dl_dpipe_table_matches_nest;
371
+
parg.data = &dst->dpipe_table_matches;
372
+
if (devlink_dl_dpipe_table_matches_parse(&parg, attr))
373
+
return MNL_CB_ERROR;
374
+
} else if (type == DEVLINK_ATTR_DPIPE_TABLE_ACTIONS) {
375
+
if (ynl_attr_validate(yarg, attr))
376
+
return MNL_CB_ERROR;
377
+
dst->_present.dpipe_table_actions = 1;
378
+
379
+
parg.rsp_policy = &devlink_dl_dpipe_table_actions_nest;
380
+
parg.data = &dst->dpipe_table_actions;
381
+
if (devlink_dl_dpipe_table_actions_parse(&parg, attr))
382
+
return MNL_CB_ERROR;
383
+
} else if (type == DEVLINK_ATTR_DPIPE_TABLE_COUNTERS_ENABLED) {
384
+
if (ynl_attr_validate(yarg, attr))
385
+
return MNL_CB_ERROR;
386
+
dst->_present.dpipe_table_counters_enabled = 1;
387
+
dst->dpipe_table_counters_enabled = mnl_attr_get_u8(attr);
388
+
} else if (type == DEVLINK_ATTR_DPIPE_TABLE_RESOURCE_ID) {
389
+
if (ynl_attr_validate(yarg, attr))
390
+
return MNL_CB_ERROR;
391
+
dst->_present.dpipe_table_resource_id = 1;
392
+
dst->dpipe_table_resource_id = mnl_attr_get_u64(attr);
393
+
} else if (type == DEVLINK_ATTR_DPIPE_TABLE_RESOURCE_UNITS) {
394
+
if (ynl_attr_validate(yarg, attr))
395
+
return MNL_CB_ERROR;
396
+
dst->_present.dpipe_table_resource_units = 1;
397
+
dst->dpipe_table_resource_units = mnl_attr_get_u64(attr);
398
+
}
399
+
}
400
+
401
+
return 0;
402
+
}
403
+
404
+
void devlink_dl_dpipe_entry_free(struct devlink_dl_dpipe_entry *obj)
405
+
{
406
+
devlink_dl_dpipe_entry_match_values_free(&obj->dpipe_entry_match_values);
407
+
devlink_dl_dpipe_entry_action_values_free(&obj->dpipe_entry_action_values);
408
+
}
409
+
410
+
int devlink_dl_dpipe_entry_parse(struct ynl_parse_arg *yarg,
411
+
const struct nlattr *nested)
412
+
{
413
+
struct devlink_dl_dpipe_entry *dst = yarg->data;
414
+
const struct nlattr *attr;
415
+
struct ynl_parse_arg parg;
416
+
417
+
parg.ys = yarg->ys;
418
+
419
+
mnl_attr_for_each_nested(attr, nested) {
420
+
unsigned int type = mnl_attr_get_type(attr);
421
+
422
+
if (type == DEVLINK_ATTR_DPIPE_ENTRY_INDEX) {
423
+
if (ynl_attr_validate(yarg, attr))
424
+
return MNL_CB_ERROR;
425
+
dst->_present.dpipe_entry_index = 1;
426
+
dst->dpipe_entry_index = mnl_attr_get_u64(attr);
427
+
} else if (type == DEVLINK_ATTR_DPIPE_ENTRY_MATCH_VALUES) {
428
+
if (ynl_attr_validate(yarg, attr))
429
+
return MNL_CB_ERROR;
430
+
dst->_present.dpipe_entry_match_values = 1;
431
+
432
+
parg.rsp_policy = &devlink_dl_dpipe_entry_match_values_nest;
433
+
parg.data = &dst->dpipe_entry_match_values;
434
+
if (devlink_dl_dpipe_entry_match_values_parse(&parg, attr))
435
+
return MNL_CB_ERROR;
436
+
} else if (type == DEVLINK_ATTR_DPIPE_ENTRY_ACTION_VALUES) {
437
+
if (ynl_attr_validate(yarg, attr))
438
+
return MNL_CB_ERROR;
439
+
dst->_present.dpipe_entry_action_values = 1;
440
+
441
+
parg.rsp_policy = &devlink_dl_dpipe_entry_action_values_nest;
442
+
parg.data = &dst->dpipe_entry_action_values;
443
+
if (devlink_dl_dpipe_entry_action_values_parse(&parg, attr))
444
+
return MNL_CB_ERROR;
445
+
} else if (type == DEVLINK_ATTR_DPIPE_ENTRY_COUNTER) {
446
+
if (ynl_attr_validate(yarg, attr))
447
+
return MNL_CB_ERROR;
448
+
dst->_present.dpipe_entry_counter = 1;
449
+
dst->dpipe_entry_counter = mnl_attr_get_u64(attr);
450
+
}
451
+
}
452
+
453
+
return 0;
454
+
}
455
+
456
+
void devlink_dl_dpipe_header_free(struct devlink_dl_dpipe_header *obj)
457
+
{
458
+
free(obj->dpipe_header_name);
459
+
devlink_dl_dpipe_header_fields_free(&obj->dpipe_header_fields);
460
+
}
461
+
462
+
int devlink_dl_dpipe_header_parse(struct ynl_parse_arg *yarg,
463
+
const struct nlattr *nested)
464
+
{
465
+
struct devlink_dl_dpipe_header *dst = yarg->data;
466
+
const struct nlattr *attr;
467
+
struct ynl_parse_arg parg;
468
+
469
+
parg.ys = yarg->ys;
470
+
471
+
mnl_attr_for_each_nested(attr, nested) {
472
+
unsigned int type = mnl_attr_get_type(attr);
473
+
474
+
if (type == DEVLINK_ATTR_DPIPE_HEADER_NAME) {
475
+
unsigned int len;
476
+
477
+
if (ynl_attr_validate(yarg, attr))
478
+
return MNL_CB_ERROR;
479
+
480
+
len = strnlen(mnl_attr_get_str(attr), mnl_attr_get_payload_len(attr));
481
+
dst->_present.dpipe_header_name_len = len;
482
+
dst->dpipe_header_name = malloc(len + 1);
483
+
memcpy(dst->dpipe_header_name, mnl_attr_get_str(attr), len);
484
+
dst->dpipe_header_name[len] = 0;
485
+
} else if (type == DEVLINK_ATTR_DPIPE_HEADER_ID) {
486
+
if (ynl_attr_validate(yarg, attr))
487
+
return MNL_CB_ERROR;
488
+
dst->_present.dpipe_header_id = 1;
489
+
dst->dpipe_header_id = mnl_attr_get_u32(attr);
490
+
} else if (type == DEVLINK_ATTR_DPIPE_HEADER_GLOBAL) {
491
+
if (ynl_attr_validate(yarg, attr))
492
+
return MNL_CB_ERROR;
493
+
dst->_present.dpipe_header_global = 1;
494
+
dst->dpipe_header_global = mnl_attr_get_u8(attr);
495
+
} else if (type == DEVLINK_ATTR_DPIPE_HEADER_FIELDS) {
496
+
if (ynl_attr_validate(yarg, attr))
497
+
return MNL_CB_ERROR;
498
+
dst->_present.dpipe_header_fields = 1;
499
+
500
+
parg.rsp_policy = &devlink_dl_dpipe_header_fields_nest;
501
+
parg.data = &dst->dpipe_header_fields;
502
+
if (devlink_dl_dpipe_header_fields_parse(&parg, attr))
503
+
return MNL_CB_ERROR;
504
+
}
505
+
}
506
+
507
+
return 0;
508
+
}
509
+
1637
510
void devlink_dl_reload_stats_free(struct devlink_dl_reload_stats *obj)
1638
511
{
1639
512
unsigned int i;
···
1854
367
if (mnl_attr_get_type(attr) == DEVLINK_ATTR_RELOAD_ACTION_INFO) {
1855
368
parg.data = &dst->reload_action_info[i];
1856
369
if (devlink_dl_reload_act_info_parse(&parg, attr))
370
+
return MNL_CB_ERROR;
371
+
i++;
372
+
}
373
+
}
374
+
}
375
+
376
+
return 0;
377
+
}
378
+
379
+
void devlink_dl_dpipe_tables_free(struct devlink_dl_dpipe_tables *obj)
380
+
{
381
+
unsigned int i;
382
+
383
+
for (i = 0; i < obj->n_dpipe_table; i++)
384
+
devlink_dl_dpipe_table_free(&obj->dpipe_table[i]);
385
+
free(obj->dpipe_table);
386
+
}
387
+
388
+
int devlink_dl_dpipe_tables_parse(struct ynl_parse_arg *yarg,
389
+
const struct nlattr *nested)
390
+
{
391
+
struct devlink_dl_dpipe_tables *dst = yarg->data;
392
+
unsigned int n_dpipe_table = 0;
393
+
const struct nlattr *attr;
394
+
struct ynl_parse_arg parg;
395
+
int i;
396
+
397
+
parg.ys = yarg->ys;
398
+
399
+
if (dst->dpipe_table)
400
+
return ynl_error_parse(yarg, "attribute already present (dl-dpipe-tables.dpipe-table)");
401
+
402
+
mnl_attr_for_each_nested(attr, nested) {
403
+
unsigned int type = mnl_attr_get_type(attr);
404
+
405
+
if (type == DEVLINK_ATTR_DPIPE_TABLE) {
406
+
n_dpipe_table++;
407
+
}
408
+
}
409
+
410
+
if (n_dpipe_table) {
411
+
dst->dpipe_table = calloc(n_dpipe_table, sizeof(*dst->dpipe_table));
412
+
dst->n_dpipe_table = n_dpipe_table;
413
+
i = 0;
414
+
parg.rsp_policy = &devlink_dl_dpipe_table_nest;
415
+
mnl_attr_for_each_nested(attr, nested) {
416
+
if (mnl_attr_get_type(attr) == DEVLINK_ATTR_DPIPE_TABLE) {
417
+
parg.data = &dst->dpipe_table[i];
418
+
if (devlink_dl_dpipe_table_parse(&parg, attr))
419
+
return MNL_CB_ERROR;
420
+
i++;
421
+
}
422
+
}
423
+
}
424
+
425
+
return 0;
426
+
}
427
+
428
+
void devlink_dl_dpipe_entries_free(struct devlink_dl_dpipe_entries *obj)
429
+
{
430
+
unsigned int i;
431
+
432
+
for (i = 0; i < obj->n_dpipe_entry; i++)
433
+
devlink_dl_dpipe_entry_free(&obj->dpipe_entry[i]);
434
+
free(obj->dpipe_entry);
435
+
}
436
+
437
+
int devlink_dl_dpipe_entries_parse(struct ynl_parse_arg *yarg,
438
+
const struct nlattr *nested)
439
+
{
440
+
struct devlink_dl_dpipe_entries *dst = yarg->data;
441
+
unsigned int n_dpipe_entry = 0;
442
+
const struct nlattr *attr;
443
+
struct ynl_parse_arg parg;
444
+
int i;
445
+
446
+
parg.ys = yarg->ys;
447
+
448
+
if (dst->dpipe_entry)
449
+
return ynl_error_parse(yarg, "attribute already present (dl-dpipe-entries.dpipe-entry)");
450
+
451
+
mnl_attr_for_each_nested(attr, nested) {
452
+
unsigned int type = mnl_attr_get_type(attr);
453
+
454
+
if (type == DEVLINK_ATTR_DPIPE_ENTRY) {
455
+
n_dpipe_entry++;
456
+
}
457
+
}
458
+
459
+
if (n_dpipe_entry) {
460
+
dst->dpipe_entry = calloc(n_dpipe_entry, sizeof(*dst->dpipe_entry));
461
+
dst->n_dpipe_entry = n_dpipe_entry;
462
+
i = 0;
463
+
parg.rsp_policy = &devlink_dl_dpipe_entry_nest;
464
+
mnl_attr_for_each_nested(attr, nested) {
465
+
if (mnl_attr_get_type(attr) == DEVLINK_ATTR_DPIPE_ENTRY) {
466
+
parg.data = &dst->dpipe_entry[i];
467
+
if (devlink_dl_dpipe_entry_parse(&parg, attr))
468
+
return MNL_CB_ERROR;
469
+
i++;
470
+
}
471
+
}
472
+
}
473
+
474
+
return 0;
475
+
}
476
+
477
+
void devlink_dl_dpipe_headers_free(struct devlink_dl_dpipe_headers *obj)
478
+
{
479
+
unsigned int i;
480
+
481
+
for (i = 0; i < obj->n_dpipe_header; i++)
482
+
devlink_dl_dpipe_header_free(&obj->dpipe_header[i]);
483
+
free(obj->dpipe_header);
484
+
}
485
+
486
+
int devlink_dl_dpipe_headers_parse(struct ynl_parse_arg *yarg,
487
+
const struct nlattr *nested)
488
+
{
489
+
struct devlink_dl_dpipe_headers *dst = yarg->data;
490
+
unsigned int n_dpipe_header = 0;
491
+
const struct nlattr *attr;
492
+
struct ynl_parse_arg parg;
493
+
int i;
494
+
495
+
parg.ys = yarg->ys;
496
+
497
+
if (dst->dpipe_header)
498
+
return ynl_error_parse(yarg, "attribute already present (dl-dpipe-headers.dpipe-header)");
499
+
500
+
mnl_attr_for_each_nested(attr, nested) {
501
+
unsigned int type = mnl_attr_get_type(attr);
502
+
503
+
if (type == DEVLINK_ATTR_DPIPE_HEADER) {
504
+
n_dpipe_header++;
505
+
}
506
+
}
507
+
508
+
if (n_dpipe_header) {
509
+
dst->dpipe_header = calloc(n_dpipe_header, sizeof(*dst->dpipe_header));
510
+
dst->n_dpipe_header = n_dpipe_header;
511
+
i = 0;
512
+
parg.rsp_policy = &devlink_dl_dpipe_header_nest;
513
+
mnl_attr_for_each_nested(attr, nested) {
514
+
if (mnl_attr_get_type(attr) == DEVLINK_ATTR_DPIPE_HEADER) {
515
+
parg.data = &dst->dpipe_header[i];
516
+
if (devlink_dl_dpipe_header_parse(&parg, attr))
1857
517
return MNL_CB_ERROR;
1858
518
i++;
1859
519
}
···
2109
475
return MNL_CB_ERROR;
2110
476
dst->_present.reload_failed = 1;
2111
477
dst->reload_failed = mnl_attr_get_u8(attr);
2112
-
} else if (type == DEVLINK_ATTR_RELOAD_ACTION) {
2113
-
if (ynl_attr_validate(yarg, attr))
2114
-
return MNL_CB_ERROR;
2115
-
dst->_present.reload_action = 1;
2116
-
dst->reload_action = mnl_attr_get_u8(attr);
2117
478
} else if (type == DEVLINK_ATTR_DEV_STATS) {
2118
479
if (ynl_attr_validate(yarg, attr))
2119
480
return MNL_CB_ERROR;
···
2383
754
free_list:
2384
755
devlink_port_get_rsp_list_free(yds.first);
2385
756
return NULL;
757
+
}
758
+
759
+
/* ============== DEVLINK_CMD_PORT_SET ============== */
760
+
/* DEVLINK_CMD_PORT_SET - do */
761
+
void devlink_port_set_req_free(struct devlink_port_set_req *req)
762
+
{
763
+
free(req->bus_name);
764
+
free(req->dev_name);
765
+
devlink_dl_port_function_free(&req->port_function);
766
+
free(req);
767
+
}
768
+
769
+
int devlink_port_set(struct ynl_sock *ys, struct devlink_port_set_req *req)
770
+
{
771
+
struct nlmsghdr *nlh;
772
+
int err;
773
+
774
+
nlh = ynl_gemsg_start_req(ys, ys->family_id, DEVLINK_CMD_PORT_SET, 1);
775
+
ys->req_policy = &devlink_nest;
776
+
777
+
if (req->_present.bus_name_len)
778
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_BUS_NAME, req->bus_name);
779
+
if (req->_present.dev_name_len)
780
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_DEV_NAME, req->dev_name);
781
+
if (req->_present.port_index)
782
+
mnl_attr_put_u32(nlh, DEVLINK_ATTR_PORT_INDEX, req->port_index);
783
+
if (req->_present.port_type)
784
+
mnl_attr_put_u16(nlh, DEVLINK_ATTR_PORT_TYPE, req->port_type);
785
+
if (req->_present.port_function)
786
+
devlink_dl_port_function_put(nlh, DEVLINK_ATTR_PORT_FUNCTION, &req->port_function);
787
+
788
+
err = ynl_exec(ys, nlh, NULL);
789
+
if (err < 0)
790
+
return -1;
791
+
792
+
return 0;
793
+
}
794
+
795
+
/* ============== DEVLINK_CMD_PORT_NEW ============== */
796
+
/* DEVLINK_CMD_PORT_NEW - do */
797
+
void devlink_port_new_req_free(struct devlink_port_new_req *req)
798
+
{
799
+
free(req->bus_name);
800
+
free(req->dev_name);
801
+
free(req);
802
+
}
803
+
804
+
void devlink_port_new_rsp_free(struct devlink_port_new_rsp *rsp)
805
+
{
806
+
free(rsp->bus_name);
807
+
free(rsp->dev_name);
808
+
free(rsp);
809
+
}
810
+
811
+
int devlink_port_new_rsp_parse(const struct nlmsghdr *nlh, void *data)
812
+
{
813
+
struct ynl_parse_arg *yarg = data;
814
+
struct devlink_port_new_rsp *dst;
815
+
const struct nlattr *attr;
816
+
817
+
dst = yarg->data;
818
+
819
+
mnl_attr_for_each(attr, nlh, sizeof(struct genlmsghdr)) {
820
+
unsigned int type = mnl_attr_get_type(attr);
821
+
822
+
if (type == DEVLINK_ATTR_BUS_NAME) {
823
+
unsigned int len;
824
+
825
+
if (ynl_attr_validate(yarg, attr))
826
+
return MNL_CB_ERROR;
827
+
828
+
len = strnlen(mnl_attr_get_str(attr), mnl_attr_get_payload_len(attr));
829
+
dst->_present.bus_name_len = len;
830
+
dst->bus_name = malloc(len + 1);
831
+
memcpy(dst->bus_name, mnl_attr_get_str(attr), len);
832
+
dst->bus_name[len] = 0;
833
+
} else if (type == DEVLINK_ATTR_DEV_NAME) {
834
+
unsigned int len;
835
+
836
+
if (ynl_attr_validate(yarg, attr))
837
+
return MNL_CB_ERROR;
838
+
839
+
len = strnlen(mnl_attr_get_str(attr), mnl_attr_get_payload_len(attr));
840
+
dst->_present.dev_name_len = len;
841
+
dst->dev_name = malloc(len + 1);
842
+
memcpy(dst->dev_name, mnl_attr_get_str(attr), len);
843
+
dst->dev_name[len] = 0;
844
+
} else if (type == DEVLINK_ATTR_PORT_INDEX) {
845
+
if (ynl_attr_validate(yarg, attr))
846
+
return MNL_CB_ERROR;
847
+
dst->_present.port_index = 1;
848
+
dst->port_index = mnl_attr_get_u32(attr);
849
+
}
850
+
}
851
+
852
+
return MNL_CB_OK;
853
+
}
854
+
855
+
struct devlink_port_new_rsp *
856
+
devlink_port_new(struct ynl_sock *ys, struct devlink_port_new_req *req)
857
+
{
858
+
struct ynl_req_state yrs = { .yarg = { .ys = ys, }, };
859
+
struct devlink_port_new_rsp *rsp;
860
+
struct nlmsghdr *nlh;
861
+
int err;
862
+
863
+
nlh = ynl_gemsg_start_req(ys, ys->family_id, DEVLINK_CMD_PORT_NEW, 1);
864
+
ys->req_policy = &devlink_nest;
865
+
yrs.yarg.rsp_policy = &devlink_nest;
866
+
867
+
if (req->_present.bus_name_len)
868
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_BUS_NAME, req->bus_name);
869
+
if (req->_present.dev_name_len)
870
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_DEV_NAME, req->dev_name);
871
+
if (req->_present.port_index)
872
+
mnl_attr_put_u32(nlh, DEVLINK_ATTR_PORT_INDEX, req->port_index);
873
+
if (req->_present.port_flavour)
874
+
mnl_attr_put_u16(nlh, DEVLINK_ATTR_PORT_FLAVOUR, req->port_flavour);
875
+
if (req->_present.port_pci_pf_number)
876
+
mnl_attr_put_u16(nlh, DEVLINK_ATTR_PORT_PCI_PF_NUMBER, req->port_pci_pf_number);
877
+
if (req->_present.port_pci_sf_number)
878
+
mnl_attr_put_u32(nlh, DEVLINK_ATTR_PORT_PCI_SF_NUMBER, req->port_pci_sf_number);
879
+
if (req->_present.port_controller_number)
880
+
mnl_attr_put_u32(nlh, DEVLINK_ATTR_PORT_CONTROLLER_NUMBER, req->port_controller_number);
881
+
882
+
rsp = calloc(1, sizeof(*rsp));
883
+
yrs.yarg.data = rsp;
884
+
yrs.cb = devlink_port_new_rsp_parse;
885
+
yrs.rsp_cmd = DEVLINK_CMD_PORT_NEW;
886
+
887
+
err = ynl_exec(ys, nlh, &yrs);
888
+
if (err < 0)
889
+
goto err_free;
890
+
891
+
return rsp;
892
+
893
+
err_free:
894
+
devlink_port_new_rsp_free(rsp);
895
+
return NULL;
896
+
}
897
+
898
+
/* ============== DEVLINK_CMD_PORT_DEL ============== */
899
+
/* DEVLINK_CMD_PORT_DEL - do */
900
+
void devlink_port_del_req_free(struct devlink_port_del_req *req)
901
+
{
902
+
free(req->bus_name);
903
+
free(req->dev_name);
904
+
free(req);
905
+
}
906
+
907
+
int devlink_port_del(struct ynl_sock *ys, struct devlink_port_del_req *req)
908
+
{
909
+
struct nlmsghdr *nlh;
910
+
int err;
911
+
912
+
nlh = ynl_gemsg_start_req(ys, ys->family_id, DEVLINK_CMD_PORT_DEL, 1);
913
+
ys->req_policy = &devlink_nest;
914
+
915
+
if (req->_present.bus_name_len)
916
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_BUS_NAME, req->bus_name);
917
+
if (req->_present.dev_name_len)
918
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_DEV_NAME, req->dev_name);
919
+
if (req->_present.port_index)
920
+
mnl_attr_put_u32(nlh, DEVLINK_ATTR_PORT_INDEX, req->port_index);
921
+
922
+
err = ynl_exec(ys, nlh, NULL);
923
+
if (err < 0)
924
+
return -1;
925
+
926
+
return 0;
927
+
}
928
+
929
+
/* ============== DEVLINK_CMD_PORT_SPLIT ============== */
930
+
/* DEVLINK_CMD_PORT_SPLIT - do */
931
+
void devlink_port_split_req_free(struct devlink_port_split_req *req)
932
+
{
933
+
free(req->bus_name);
934
+
free(req->dev_name);
935
+
free(req);
936
+
}
937
+
938
+
int devlink_port_split(struct ynl_sock *ys, struct devlink_port_split_req *req)
939
+
{
940
+
struct nlmsghdr *nlh;
941
+
int err;
942
+
943
+
nlh = ynl_gemsg_start_req(ys, ys->family_id, DEVLINK_CMD_PORT_SPLIT, 1);
944
+
ys->req_policy = &devlink_nest;
945
+
946
+
if (req->_present.bus_name_len)
947
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_BUS_NAME, req->bus_name);
948
+
if (req->_present.dev_name_len)
949
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_DEV_NAME, req->dev_name);
950
+
if (req->_present.port_index)
951
+
mnl_attr_put_u32(nlh, DEVLINK_ATTR_PORT_INDEX, req->port_index);
952
+
if (req->_present.port_split_count)
953
+
mnl_attr_put_u32(nlh, DEVLINK_ATTR_PORT_SPLIT_COUNT, req->port_split_count);
954
+
955
+
err = ynl_exec(ys, nlh, NULL);
956
+
if (err < 0)
957
+
return -1;
958
+
959
+
return 0;
960
+
}
961
+
962
+
/* ============== DEVLINK_CMD_PORT_UNSPLIT ============== */
963
+
/* DEVLINK_CMD_PORT_UNSPLIT - do */
964
+
void devlink_port_unsplit_req_free(struct devlink_port_unsplit_req *req)
965
+
{
966
+
free(req->bus_name);
967
+
free(req->dev_name);
968
+
free(req);
969
+
}
970
+
971
+
int devlink_port_unsplit(struct ynl_sock *ys,
972
+
struct devlink_port_unsplit_req *req)
973
+
{
974
+
struct nlmsghdr *nlh;
975
+
int err;
976
+
977
+
nlh = ynl_gemsg_start_req(ys, ys->family_id, DEVLINK_CMD_PORT_UNSPLIT, 1);
978
+
ys->req_policy = &devlink_nest;
979
+
980
+
if (req->_present.bus_name_len)
981
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_BUS_NAME, req->bus_name);
982
+
if (req->_present.dev_name_len)
983
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_DEV_NAME, req->dev_name);
984
+
if (req->_present.port_index)
985
+
mnl_attr_put_u32(nlh, DEVLINK_ATTR_PORT_INDEX, req->port_index);
986
+
987
+
err = ynl_exec(ys, nlh, NULL);
988
+
if (err < 0)
989
+
return -1;
990
+
991
+
return 0;
2386
992
}
2387
993
2388
994
/* ============== DEVLINK_CMD_SB_GET ============== */
···
2912
1048
return NULL;
2913
1049
}
2914
1050
1051
+
/* ============== DEVLINK_CMD_SB_POOL_SET ============== */
1052
+
/* DEVLINK_CMD_SB_POOL_SET - do */
1053
+
void devlink_sb_pool_set_req_free(struct devlink_sb_pool_set_req *req)
1054
+
{
1055
+
free(req->bus_name);
1056
+
free(req->dev_name);
1057
+
free(req);
1058
+
}
1059
+
1060
+
int devlink_sb_pool_set(struct ynl_sock *ys,
1061
+
struct devlink_sb_pool_set_req *req)
1062
+
{
1063
+
struct nlmsghdr *nlh;
1064
+
int err;
1065
+
1066
+
nlh = ynl_gemsg_start_req(ys, ys->family_id, DEVLINK_CMD_SB_POOL_SET, 1);
1067
+
ys->req_policy = &devlink_nest;
1068
+
1069
+
if (req->_present.bus_name_len)
1070
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_BUS_NAME, req->bus_name);
1071
+
if (req->_present.dev_name_len)
1072
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_DEV_NAME, req->dev_name);
1073
+
if (req->_present.sb_index)
1074
+
mnl_attr_put_u32(nlh, DEVLINK_ATTR_SB_INDEX, req->sb_index);
1075
+
if (req->_present.sb_pool_index)
1076
+
mnl_attr_put_u16(nlh, DEVLINK_ATTR_SB_POOL_INDEX, req->sb_pool_index);
1077
+
if (req->_present.sb_pool_threshold_type)
1078
+
mnl_attr_put_u8(nlh, DEVLINK_ATTR_SB_POOL_THRESHOLD_TYPE, req->sb_pool_threshold_type);
1079
+
if (req->_present.sb_pool_size)
1080
+
mnl_attr_put_u32(nlh, DEVLINK_ATTR_SB_POOL_SIZE, req->sb_pool_size);
1081
+
1082
+
err = ynl_exec(ys, nlh, NULL);
1083
+
if (err < 0)
1084
+
return -1;
1085
+
1086
+
return 0;
1087
+
}
1088
+
2915
1089
/* ============== DEVLINK_CMD_SB_PORT_POOL_GET ============== */
2916
1090
/* DEVLINK_CMD_SB_PORT_POOL_GET - do */
2917
1091
void
···
3109
1207
free_list:
3110
1208
devlink_sb_port_pool_get_list_free(yds.first);
3111
1209
return NULL;
1210
+
}
1211
+
1212
+
/* ============== DEVLINK_CMD_SB_PORT_POOL_SET ============== */
1213
+
/* DEVLINK_CMD_SB_PORT_POOL_SET - do */
1214
+
void
1215
+
devlink_sb_port_pool_set_req_free(struct devlink_sb_port_pool_set_req *req)
1216
+
{
1217
+
free(req->bus_name);
1218
+
free(req->dev_name);
1219
+
free(req);
1220
+
}
1221
+
1222
+
int devlink_sb_port_pool_set(struct ynl_sock *ys,
1223
+
struct devlink_sb_port_pool_set_req *req)
1224
+
{
1225
+
struct nlmsghdr *nlh;
1226
+
int err;
1227
+
1228
+
nlh = ynl_gemsg_start_req(ys, ys->family_id, DEVLINK_CMD_SB_PORT_POOL_SET, 1);
1229
+
ys->req_policy = &devlink_nest;
1230
+
1231
+
if (req->_present.bus_name_len)
1232
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_BUS_NAME, req->bus_name);
1233
+
if (req->_present.dev_name_len)
1234
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_DEV_NAME, req->dev_name);
1235
+
if (req->_present.port_index)
1236
+
mnl_attr_put_u32(nlh, DEVLINK_ATTR_PORT_INDEX, req->port_index);
1237
+
if (req->_present.sb_index)
1238
+
mnl_attr_put_u32(nlh, DEVLINK_ATTR_SB_INDEX, req->sb_index);
1239
+
if (req->_present.sb_pool_index)
1240
+
mnl_attr_put_u16(nlh, DEVLINK_ATTR_SB_POOL_INDEX, req->sb_pool_index);
1241
+
if (req->_present.sb_threshold)
1242
+
mnl_attr_put_u32(nlh, DEVLINK_ATTR_SB_THRESHOLD, req->sb_threshold);
1243
+
1244
+
err = ynl_exec(ys, nlh, NULL);
1245
+
if (err < 0)
1246
+
return -1;
1247
+
1248
+
return 0;
3112
1249
}
3113
1250
3114
1251
/* ============== DEVLINK_CMD_SB_TC_POOL_BIND_GET ============== */
···
3319
1378
return NULL;
3320
1379
}
3321
1380
1381
+
/* ============== DEVLINK_CMD_SB_TC_POOL_BIND_SET ============== */
1382
+
/* DEVLINK_CMD_SB_TC_POOL_BIND_SET - do */
1383
+
void
1384
+
devlink_sb_tc_pool_bind_set_req_free(struct devlink_sb_tc_pool_bind_set_req *req)
1385
+
{
1386
+
free(req->bus_name);
1387
+
free(req->dev_name);
1388
+
free(req);
1389
+
}
1390
+
1391
+
int devlink_sb_tc_pool_bind_set(struct ynl_sock *ys,
1392
+
struct devlink_sb_tc_pool_bind_set_req *req)
1393
+
{
1394
+
struct nlmsghdr *nlh;
1395
+
int err;
1396
+
1397
+
nlh = ynl_gemsg_start_req(ys, ys->family_id, DEVLINK_CMD_SB_TC_POOL_BIND_SET, 1);
1398
+
ys->req_policy = &devlink_nest;
1399
+
1400
+
if (req->_present.bus_name_len)
1401
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_BUS_NAME, req->bus_name);
1402
+
if (req->_present.dev_name_len)
1403
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_DEV_NAME, req->dev_name);
1404
+
if (req->_present.port_index)
1405
+
mnl_attr_put_u32(nlh, DEVLINK_ATTR_PORT_INDEX, req->port_index);
1406
+
if (req->_present.sb_index)
1407
+
mnl_attr_put_u32(nlh, DEVLINK_ATTR_SB_INDEX, req->sb_index);
1408
+
if (req->_present.sb_pool_index)
1409
+
mnl_attr_put_u16(nlh, DEVLINK_ATTR_SB_POOL_INDEX, req->sb_pool_index);
1410
+
if (req->_present.sb_pool_type)
1411
+
mnl_attr_put_u8(nlh, DEVLINK_ATTR_SB_POOL_TYPE, req->sb_pool_type);
1412
+
if (req->_present.sb_tc_index)
1413
+
mnl_attr_put_u16(nlh, DEVLINK_ATTR_SB_TC_INDEX, req->sb_tc_index);
1414
+
if (req->_present.sb_threshold)
1415
+
mnl_attr_put_u32(nlh, DEVLINK_ATTR_SB_THRESHOLD, req->sb_threshold);
1416
+
1417
+
err = ynl_exec(ys, nlh, NULL);
1418
+
if (err < 0)
1419
+
return -1;
1420
+
1421
+
return 0;
1422
+
}
1423
+
1424
+
/* ============== DEVLINK_CMD_SB_OCC_SNAPSHOT ============== */
1425
+
/* DEVLINK_CMD_SB_OCC_SNAPSHOT - do */
1426
+
void devlink_sb_occ_snapshot_req_free(struct devlink_sb_occ_snapshot_req *req)
1427
+
{
1428
+
free(req->bus_name);
1429
+
free(req->dev_name);
1430
+
free(req);
1431
+
}
1432
+
1433
+
int devlink_sb_occ_snapshot(struct ynl_sock *ys,
1434
+
struct devlink_sb_occ_snapshot_req *req)
1435
+
{
1436
+
struct nlmsghdr *nlh;
1437
+
int err;
1438
+
1439
+
nlh = ynl_gemsg_start_req(ys, ys->family_id, DEVLINK_CMD_SB_OCC_SNAPSHOT, 1);
1440
+
ys->req_policy = &devlink_nest;
1441
+
1442
+
if (req->_present.bus_name_len)
1443
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_BUS_NAME, req->bus_name);
1444
+
if (req->_present.dev_name_len)
1445
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_DEV_NAME, req->dev_name);
1446
+
if (req->_present.sb_index)
1447
+
mnl_attr_put_u32(nlh, DEVLINK_ATTR_SB_INDEX, req->sb_index);
1448
+
1449
+
err = ynl_exec(ys, nlh, NULL);
1450
+
if (err < 0)
1451
+
return -1;
1452
+
1453
+
return 0;
1454
+
}
1455
+
1456
+
/* ============== DEVLINK_CMD_SB_OCC_MAX_CLEAR ============== */
1457
+
/* DEVLINK_CMD_SB_OCC_MAX_CLEAR - do */
1458
+
void
1459
+
devlink_sb_occ_max_clear_req_free(struct devlink_sb_occ_max_clear_req *req)
1460
+
{
1461
+
free(req->bus_name);
1462
+
free(req->dev_name);
1463
+
free(req);
1464
+
}
1465
+
1466
+
int devlink_sb_occ_max_clear(struct ynl_sock *ys,
1467
+
struct devlink_sb_occ_max_clear_req *req)
1468
+
{
1469
+
struct nlmsghdr *nlh;
1470
+
int err;
1471
+
1472
+
nlh = ynl_gemsg_start_req(ys, ys->family_id, DEVLINK_CMD_SB_OCC_MAX_CLEAR, 1);
1473
+
ys->req_policy = &devlink_nest;
1474
+
1475
+
if (req->_present.bus_name_len)
1476
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_BUS_NAME, req->bus_name);
1477
+
if (req->_present.dev_name_len)
1478
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_DEV_NAME, req->dev_name);
1479
+
if (req->_present.sb_index)
1480
+
mnl_attr_put_u32(nlh, DEVLINK_ATTR_SB_INDEX, req->sb_index);
1481
+
1482
+
err = ynl_exec(ys, nlh, NULL);
1483
+
if (err < 0)
1484
+
return -1;
1485
+
1486
+
return 0;
1487
+
}
1488
+
1489
+
/* ============== DEVLINK_CMD_ESWITCH_GET ============== */
1490
+
/* DEVLINK_CMD_ESWITCH_GET - do */
1491
+
void devlink_eswitch_get_req_free(struct devlink_eswitch_get_req *req)
1492
+
{
1493
+
free(req->bus_name);
1494
+
free(req->dev_name);
1495
+
free(req);
1496
+
}
1497
+
1498
+
void devlink_eswitch_get_rsp_free(struct devlink_eswitch_get_rsp *rsp)
1499
+
{
1500
+
free(rsp->bus_name);
1501
+
free(rsp->dev_name);
1502
+
free(rsp);
1503
+
}
1504
+
1505
+
int devlink_eswitch_get_rsp_parse(const struct nlmsghdr *nlh, void *data)
1506
+
{
1507
+
struct devlink_eswitch_get_rsp *dst;
1508
+
struct ynl_parse_arg *yarg = data;
1509
+
const struct nlattr *attr;
1510
+
1511
+
dst = yarg->data;
1512
+
1513
+
mnl_attr_for_each(attr, nlh, sizeof(struct genlmsghdr)) {
1514
+
unsigned int type = mnl_attr_get_type(attr);
1515
+
1516
+
if (type == DEVLINK_ATTR_BUS_NAME) {
1517
+
unsigned int len;
1518
+
1519
+
if (ynl_attr_validate(yarg, attr))
1520
+
return MNL_CB_ERROR;
1521
+
1522
+
len = strnlen(mnl_attr_get_str(attr), mnl_attr_get_payload_len(attr));
1523
+
dst->_present.bus_name_len = len;
1524
+
dst->bus_name = malloc(len + 1);
1525
+
memcpy(dst->bus_name, mnl_attr_get_str(attr), len);
1526
+
dst->bus_name[len] = 0;
1527
+
} else if (type == DEVLINK_ATTR_DEV_NAME) {
1528
+
unsigned int len;
1529
+
1530
+
if (ynl_attr_validate(yarg, attr))
1531
+
return MNL_CB_ERROR;
1532
+
1533
+
len = strnlen(mnl_attr_get_str(attr), mnl_attr_get_payload_len(attr));
1534
+
dst->_present.dev_name_len = len;
1535
+
dst->dev_name = malloc(len + 1);
1536
+
memcpy(dst->dev_name, mnl_attr_get_str(attr), len);
1537
+
dst->dev_name[len] = 0;
1538
+
} else if (type == DEVLINK_ATTR_ESWITCH_MODE) {
1539
+
if (ynl_attr_validate(yarg, attr))
1540
+
return MNL_CB_ERROR;
1541
+
dst->_present.eswitch_mode = 1;
1542
+
dst->eswitch_mode = mnl_attr_get_u16(attr);
1543
+
} else if (type == DEVLINK_ATTR_ESWITCH_INLINE_MODE) {
1544
+
if (ynl_attr_validate(yarg, attr))
1545
+
return MNL_CB_ERROR;
1546
+
dst->_present.eswitch_inline_mode = 1;
1547
+
dst->eswitch_inline_mode = mnl_attr_get_u16(attr);
1548
+
} else if (type == DEVLINK_ATTR_ESWITCH_ENCAP_MODE) {
1549
+
if (ynl_attr_validate(yarg, attr))
1550
+
return MNL_CB_ERROR;
1551
+
dst->_present.eswitch_encap_mode = 1;
1552
+
dst->eswitch_encap_mode = mnl_attr_get_u8(attr);
1553
+
}
1554
+
}
1555
+
1556
+
return MNL_CB_OK;
1557
+
}
1558
+
1559
+
struct devlink_eswitch_get_rsp *
1560
+
devlink_eswitch_get(struct ynl_sock *ys, struct devlink_eswitch_get_req *req)
1561
+
{
1562
+
struct ynl_req_state yrs = { .yarg = { .ys = ys, }, };
1563
+
struct devlink_eswitch_get_rsp *rsp;
1564
+
struct nlmsghdr *nlh;
1565
+
int err;
1566
+
1567
+
nlh = ynl_gemsg_start_req(ys, ys->family_id, DEVLINK_CMD_ESWITCH_GET, 1);
1568
+
ys->req_policy = &devlink_nest;
1569
+
yrs.yarg.rsp_policy = &devlink_nest;
1570
+
1571
+
if (req->_present.bus_name_len)
1572
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_BUS_NAME, req->bus_name);
1573
+
if (req->_present.dev_name_len)
1574
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_DEV_NAME, req->dev_name);
1575
+
1576
+
rsp = calloc(1, sizeof(*rsp));
1577
+
yrs.yarg.data = rsp;
1578
+
yrs.cb = devlink_eswitch_get_rsp_parse;
1579
+
yrs.rsp_cmd = DEVLINK_CMD_ESWITCH_GET;
1580
+
1581
+
err = ynl_exec(ys, nlh, &yrs);
1582
+
if (err < 0)
1583
+
goto err_free;
1584
+
1585
+
return rsp;
1586
+
1587
+
err_free:
1588
+
devlink_eswitch_get_rsp_free(rsp);
1589
+
return NULL;
1590
+
}
1591
+
1592
+
/* ============== DEVLINK_CMD_ESWITCH_SET ============== */
1593
+
/* DEVLINK_CMD_ESWITCH_SET - do */
1594
+
void devlink_eswitch_set_req_free(struct devlink_eswitch_set_req *req)
1595
+
{
1596
+
free(req->bus_name);
1597
+
free(req->dev_name);
1598
+
free(req);
1599
+
}
1600
+
1601
+
int devlink_eswitch_set(struct ynl_sock *ys,
1602
+
struct devlink_eswitch_set_req *req)
1603
+
{
1604
+
struct nlmsghdr *nlh;
1605
+
int err;
1606
+
1607
+
nlh = ynl_gemsg_start_req(ys, ys->family_id, DEVLINK_CMD_ESWITCH_SET, 1);
1608
+
ys->req_policy = &devlink_nest;
1609
+
1610
+
if (req->_present.bus_name_len)
1611
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_BUS_NAME, req->bus_name);
1612
+
if (req->_present.dev_name_len)
1613
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_DEV_NAME, req->dev_name);
1614
+
if (req->_present.eswitch_mode)
1615
+
mnl_attr_put_u16(nlh, DEVLINK_ATTR_ESWITCH_MODE, req->eswitch_mode);
1616
+
if (req->_present.eswitch_inline_mode)
1617
+
mnl_attr_put_u16(nlh, DEVLINK_ATTR_ESWITCH_INLINE_MODE, req->eswitch_inline_mode);
1618
+
if (req->_present.eswitch_encap_mode)
1619
+
mnl_attr_put_u8(nlh, DEVLINK_ATTR_ESWITCH_ENCAP_MODE, req->eswitch_encap_mode);
1620
+
1621
+
err = ynl_exec(ys, nlh, NULL);
1622
+
if (err < 0)
1623
+
return -1;
1624
+
1625
+
return 0;
1626
+
}
1627
+
1628
+
/* ============== DEVLINK_CMD_DPIPE_TABLE_GET ============== */
1629
+
/* DEVLINK_CMD_DPIPE_TABLE_GET - do */
1630
+
void devlink_dpipe_table_get_req_free(struct devlink_dpipe_table_get_req *req)
1631
+
{
1632
+
free(req->bus_name);
1633
+
free(req->dev_name);
1634
+
free(req->dpipe_table_name);
1635
+
free(req);
1636
+
}
1637
+
1638
+
void devlink_dpipe_table_get_rsp_free(struct devlink_dpipe_table_get_rsp *rsp)
1639
+
{
1640
+
free(rsp->bus_name);
1641
+
free(rsp->dev_name);
1642
+
devlink_dl_dpipe_tables_free(&rsp->dpipe_tables);
1643
+
free(rsp);
1644
+
}
1645
+
1646
+
int devlink_dpipe_table_get_rsp_parse(const struct nlmsghdr *nlh, void *data)
1647
+
{
1648
+
struct devlink_dpipe_table_get_rsp *dst;
1649
+
struct ynl_parse_arg *yarg = data;
1650
+
const struct nlattr *attr;
1651
+
struct ynl_parse_arg parg;
1652
+
1653
+
dst = yarg->data;
1654
+
parg.ys = yarg->ys;
1655
+
1656
+
mnl_attr_for_each(attr, nlh, sizeof(struct genlmsghdr)) {
1657
+
unsigned int type = mnl_attr_get_type(attr);
1658
+
1659
+
if (type == DEVLINK_ATTR_BUS_NAME) {
1660
+
unsigned int len;
1661
+
1662
+
if (ynl_attr_validate(yarg, attr))
1663
+
return MNL_CB_ERROR;
1664
+
1665
+
len = strnlen(mnl_attr_get_str(attr), mnl_attr_get_payload_len(attr));
1666
+
dst->_present.bus_name_len = len;
1667
+
dst->bus_name = malloc(len + 1);
1668
+
memcpy(dst->bus_name, mnl_attr_get_str(attr), len);
1669
+
dst->bus_name[len] = 0;
1670
+
} else if (type == DEVLINK_ATTR_DEV_NAME) {
1671
+
unsigned int len;
1672
+
1673
+
if (ynl_attr_validate(yarg, attr))
1674
+
return MNL_CB_ERROR;
1675
+
1676
+
len = strnlen(mnl_attr_get_str(attr), mnl_attr_get_payload_len(attr));
1677
+
dst->_present.dev_name_len = len;
1678
+
dst->dev_name = malloc(len + 1);
1679
+
memcpy(dst->dev_name, mnl_attr_get_str(attr), len);
1680
+
dst->dev_name[len] = 0;
1681
+
} else if (type == DEVLINK_ATTR_DPIPE_TABLES) {
1682
+
if (ynl_attr_validate(yarg, attr))
1683
+
return MNL_CB_ERROR;
1684
+
dst->_present.dpipe_tables = 1;
1685
+
1686
+
parg.rsp_policy = &devlink_dl_dpipe_tables_nest;
1687
+
parg.data = &dst->dpipe_tables;
1688
+
if (devlink_dl_dpipe_tables_parse(&parg, attr))
1689
+
return MNL_CB_ERROR;
1690
+
}
1691
+
}
1692
+
1693
+
return MNL_CB_OK;
1694
+
}
1695
+
1696
+
struct devlink_dpipe_table_get_rsp *
1697
+
devlink_dpipe_table_get(struct ynl_sock *ys,
1698
+
struct devlink_dpipe_table_get_req *req)
1699
+
{
1700
+
struct ynl_req_state yrs = { .yarg = { .ys = ys, }, };
1701
+
struct devlink_dpipe_table_get_rsp *rsp;
1702
+
struct nlmsghdr *nlh;
1703
+
int err;
1704
+
1705
+
nlh = ynl_gemsg_start_req(ys, ys->family_id, DEVLINK_CMD_DPIPE_TABLE_GET, 1);
1706
+
ys->req_policy = &devlink_nest;
1707
+
yrs.yarg.rsp_policy = &devlink_nest;
1708
+
1709
+
if (req->_present.bus_name_len)
1710
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_BUS_NAME, req->bus_name);
1711
+
if (req->_present.dev_name_len)
1712
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_DEV_NAME, req->dev_name);
1713
+
if (req->_present.dpipe_table_name_len)
1714
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_DPIPE_TABLE_NAME, req->dpipe_table_name);
1715
+
1716
+
rsp = calloc(1, sizeof(*rsp));
1717
+
yrs.yarg.data = rsp;
1718
+
yrs.cb = devlink_dpipe_table_get_rsp_parse;
1719
+
yrs.rsp_cmd = DEVLINK_CMD_DPIPE_TABLE_GET;
1720
+
1721
+
err = ynl_exec(ys, nlh, &yrs);
1722
+
if (err < 0)
1723
+
goto err_free;
1724
+
1725
+
return rsp;
1726
+
1727
+
err_free:
1728
+
devlink_dpipe_table_get_rsp_free(rsp);
1729
+
return NULL;
1730
+
}
1731
+
1732
+
/* ============== DEVLINK_CMD_DPIPE_ENTRIES_GET ============== */
1733
+
/* DEVLINK_CMD_DPIPE_ENTRIES_GET - do */
1734
+
void
1735
+
devlink_dpipe_entries_get_req_free(struct devlink_dpipe_entries_get_req *req)
1736
+
{
1737
+
free(req->bus_name);
1738
+
free(req->dev_name);
1739
+
free(req->dpipe_table_name);
1740
+
free(req);
1741
+
}
1742
+
1743
+
void
1744
+
devlink_dpipe_entries_get_rsp_free(struct devlink_dpipe_entries_get_rsp *rsp)
1745
+
{
1746
+
free(rsp->bus_name);
1747
+
free(rsp->dev_name);
1748
+
devlink_dl_dpipe_entries_free(&rsp->dpipe_entries);
1749
+
free(rsp);
1750
+
}
1751
+
1752
+
int devlink_dpipe_entries_get_rsp_parse(const struct nlmsghdr *nlh, void *data)
1753
+
{
1754
+
struct devlink_dpipe_entries_get_rsp *dst;
1755
+
struct ynl_parse_arg *yarg = data;
1756
+
const struct nlattr *attr;
1757
+
struct ynl_parse_arg parg;
1758
+
1759
+
dst = yarg->data;
1760
+
parg.ys = yarg->ys;
1761
+
1762
+
mnl_attr_for_each(attr, nlh, sizeof(struct genlmsghdr)) {
1763
+
unsigned int type = mnl_attr_get_type(attr);
1764
+
1765
+
if (type == DEVLINK_ATTR_BUS_NAME) {
1766
+
unsigned int len;
1767
+
1768
+
if (ynl_attr_validate(yarg, attr))
1769
+
return MNL_CB_ERROR;
1770
+
1771
+
len = strnlen(mnl_attr_get_str(attr), mnl_attr_get_payload_len(attr));
1772
+
dst->_present.bus_name_len = len;
1773
+
dst->bus_name = malloc(len + 1);
1774
+
memcpy(dst->bus_name, mnl_attr_get_str(attr), len);
1775
+
dst->bus_name[len] = 0;
1776
+
} else if (type == DEVLINK_ATTR_DEV_NAME) {
1777
+
unsigned int len;
1778
+
1779
+
if (ynl_attr_validate(yarg, attr))
1780
+
return MNL_CB_ERROR;
1781
+
1782
+
len = strnlen(mnl_attr_get_str(attr), mnl_attr_get_payload_len(attr));
1783
+
dst->_present.dev_name_len = len;
1784
+
dst->dev_name = malloc(len + 1);
1785
+
memcpy(dst->dev_name, mnl_attr_get_str(attr), len);
1786
+
dst->dev_name[len] = 0;
1787
+
} else if (type == DEVLINK_ATTR_DPIPE_ENTRIES) {
1788
+
if (ynl_attr_validate(yarg, attr))
1789
+
return MNL_CB_ERROR;
1790
+
dst->_present.dpipe_entries = 1;
1791
+
1792
+
parg.rsp_policy = &devlink_dl_dpipe_entries_nest;
1793
+
parg.data = &dst->dpipe_entries;
1794
+
if (devlink_dl_dpipe_entries_parse(&parg, attr))
1795
+
return MNL_CB_ERROR;
1796
+
}
1797
+
}
1798
+
1799
+
return MNL_CB_OK;
1800
+
}
1801
+
1802
+
struct devlink_dpipe_entries_get_rsp *
1803
+
devlink_dpipe_entries_get(struct ynl_sock *ys,
1804
+
struct devlink_dpipe_entries_get_req *req)
1805
+
{
1806
+
struct ynl_req_state yrs = { .yarg = { .ys = ys, }, };
1807
+
struct devlink_dpipe_entries_get_rsp *rsp;
1808
+
struct nlmsghdr *nlh;
1809
+
int err;
1810
+
1811
+
nlh = ynl_gemsg_start_req(ys, ys->family_id, DEVLINK_CMD_DPIPE_ENTRIES_GET, 1);
1812
+
ys->req_policy = &devlink_nest;
1813
+
yrs.yarg.rsp_policy = &devlink_nest;
1814
+
1815
+
if (req->_present.bus_name_len)
1816
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_BUS_NAME, req->bus_name);
1817
+
if (req->_present.dev_name_len)
1818
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_DEV_NAME, req->dev_name);
1819
+
if (req->_present.dpipe_table_name_len)
1820
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_DPIPE_TABLE_NAME, req->dpipe_table_name);
1821
+
1822
+
rsp = calloc(1, sizeof(*rsp));
1823
+
yrs.yarg.data = rsp;
1824
+
yrs.cb = devlink_dpipe_entries_get_rsp_parse;
1825
+
yrs.rsp_cmd = DEVLINK_CMD_DPIPE_ENTRIES_GET;
1826
+
1827
+
err = ynl_exec(ys, nlh, &yrs);
1828
+
if (err < 0)
1829
+
goto err_free;
1830
+
1831
+
return rsp;
1832
+
1833
+
err_free:
1834
+
devlink_dpipe_entries_get_rsp_free(rsp);
1835
+
return NULL;
1836
+
}
1837
+
1838
+
/* ============== DEVLINK_CMD_DPIPE_HEADERS_GET ============== */
1839
+
/* DEVLINK_CMD_DPIPE_HEADERS_GET - do */
1840
+
void
1841
+
devlink_dpipe_headers_get_req_free(struct devlink_dpipe_headers_get_req *req)
1842
+
{
1843
+
free(req->bus_name);
1844
+
free(req->dev_name);
1845
+
free(req);
1846
+
}
1847
+
1848
+
void
1849
+
devlink_dpipe_headers_get_rsp_free(struct devlink_dpipe_headers_get_rsp *rsp)
1850
+
{
1851
+
free(rsp->bus_name);
1852
+
free(rsp->dev_name);
1853
+
devlink_dl_dpipe_headers_free(&rsp->dpipe_headers);
1854
+
free(rsp);
1855
+
}
1856
+
1857
+
int devlink_dpipe_headers_get_rsp_parse(const struct nlmsghdr *nlh, void *data)
1858
+
{
1859
+
struct devlink_dpipe_headers_get_rsp *dst;
1860
+
struct ynl_parse_arg *yarg = data;
1861
+
const struct nlattr *attr;
1862
+
struct ynl_parse_arg parg;
1863
+
1864
+
dst = yarg->data;
1865
+
parg.ys = yarg->ys;
1866
+
1867
+
mnl_attr_for_each(attr, nlh, sizeof(struct genlmsghdr)) {
1868
+
unsigned int type = mnl_attr_get_type(attr);
1869
+
1870
+
if (type == DEVLINK_ATTR_BUS_NAME) {
1871
+
unsigned int len;
1872
+
1873
+
if (ynl_attr_validate(yarg, attr))
1874
+
return MNL_CB_ERROR;
1875
+
1876
+
len = strnlen(mnl_attr_get_str(attr), mnl_attr_get_payload_len(attr));
1877
+
dst->_present.bus_name_len = len;
1878
+
dst->bus_name = malloc(len + 1);
1879
+
memcpy(dst->bus_name, mnl_attr_get_str(attr), len);
1880
+
dst->bus_name[len] = 0;
1881
+
} else if (type == DEVLINK_ATTR_DEV_NAME) {
1882
+
unsigned int len;
1883
+
1884
+
if (ynl_attr_validate(yarg, attr))
1885
+
return MNL_CB_ERROR;
1886
+
1887
+
len = strnlen(mnl_attr_get_str(attr), mnl_attr_get_payload_len(attr));
1888
+
dst->_present.dev_name_len = len;
1889
+
dst->dev_name = malloc(len + 1);
1890
+
memcpy(dst->dev_name, mnl_attr_get_str(attr), len);
1891
+
dst->dev_name[len] = 0;
1892
+
} else if (type == DEVLINK_ATTR_DPIPE_HEADERS) {
1893
+
if (ynl_attr_validate(yarg, attr))
1894
+
return MNL_CB_ERROR;
1895
+
dst->_present.dpipe_headers = 1;
1896
+
1897
+
parg.rsp_policy = &devlink_dl_dpipe_headers_nest;
1898
+
parg.data = &dst->dpipe_headers;
1899
+
if (devlink_dl_dpipe_headers_parse(&parg, attr))
1900
+
return MNL_CB_ERROR;
1901
+
}
1902
+
}
1903
+
1904
+
return MNL_CB_OK;
1905
+
}
1906
+
1907
+
struct devlink_dpipe_headers_get_rsp *
1908
+
devlink_dpipe_headers_get(struct ynl_sock *ys,
1909
+
struct devlink_dpipe_headers_get_req *req)
1910
+
{
1911
+
struct ynl_req_state yrs = { .yarg = { .ys = ys, }, };
1912
+
struct devlink_dpipe_headers_get_rsp *rsp;
1913
+
struct nlmsghdr *nlh;
1914
+
int err;
1915
+
1916
+
nlh = ynl_gemsg_start_req(ys, ys->family_id, DEVLINK_CMD_DPIPE_HEADERS_GET, 1);
1917
+
ys->req_policy = &devlink_nest;
1918
+
yrs.yarg.rsp_policy = &devlink_nest;
1919
+
1920
+
if (req->_present.bus_name_len)
1921
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_BUS_NAME, req->bus_name);
1922
+
if (req->_present.dev_name_len)
1923
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_DEV_NAME, req->dev_name);
1924
+
1925
+
rsp = calloc(1, sizeof(*rsp));
1926
+
yrs.yarg.data = rsp;
1927
+
yrs.cb = devlink_dpipe_headers_get_rsp_parse;
1928
+
yrs.rsp_cmd = DEVLINK_CMD_DPIPE_HEADERS_GET;
1929
+
1930
+
err = ynl_exec(ys, nlh, &yrs);
1931
+
if (err < 0)
1932
+
goto err_free;
1933
+
1934
+
return rsp;
1935
+
1936
+
err_free:
1937
+
devlink_dpipe_headers_get_rsp_free(rsp);
1938
+
return NULL;
1939
+
}
1940
+
1941
+
/* ============== DEVLINK_CMD_DPIPE_TABLE_COUNTERS_SET ============== */
1942
+
/* DEVLINK_CMD_DPIPE_TABLE_COUNTERS_SET - do */
1943
+
void
1944
+
devlink_dpipe_table_counters_set_req_free(struct devlink_dpipe_table_counters_set_req *req)
1945
+
{
1946
+
free(req->bus_name);
1947
+
free(req->dev_name);
1948
+
free(req->dpipe_table_name);
1949
+
free(req);
1950
+
}
1951
+
1952
+
int devlink_dpipe_table_counters_set(struct ynl_sock *ys,
1953
+
struct devlink_dpipe_table_counters_set_req *req)
1954
+
{
1955
+
struct nlmsghdr *nlh;
1956
+
int err;
1957
+
1958
+
nlh = ynl_gemsg_start_req(ys, ys->family_id, DEVLINK_CMD_DPIPE_TABLE_COUNTERS_SET, 1);
1959
+
ys->req_policy = &devlink_nest;
1960
+
1961
+
if (req->_present.bus_name_len)
1962
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_BUS_NAME, req->bus_name);
1963
+
if (req->_present.dev_name_len)
1964
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_DEV_NAME, req->dev_name);
1965
+
if (req->_present.dpipe_table_name_len)
1966
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_DPIPE_TABLE_NAME, req->dpipe_table_name);
1967
+
if (req->_present.dpipe_table_counters_enabled)
1968
+
mnl_attr_put_u8(nlh, DEVLINK_ATTR_DPIPE_TABLE_COUNTERS_ENABLED, req->dpipe_table_counters_enabled);
1969
+
1970
+
err = ynl_exec(ys, nlh, NULL);
1971
+
if (err < 0)
1972
+
return -1;
1973
+
1974
+
return 0;
1975
+
}
1976
+
1977
+
/* ============== DEVLINK_CMD_RESOURCE_SET ============== */
1978
+
/* DEVLINK_CMD_RESOURCE_SET - do */
1979
+
void devlink_resource_set_req_free(struct devlink_resource_set_req *req)
1980
+
{
1981
+
free(req->bus_name);
1982
+
free(req->dev_name);
1983
+
free(req);
1984
+
}
1985
+
1986
+
int devlink_resource_set(struct ynl_sock *ys,
1987
+
struct devlink_resource_set_req *req)
1988
+
{
1989
+
struct nlmsghdr *nlh;
1990
+
int err;
1991
+
1992
+
nlh = ynl_gemsg_start_req(ys, ys->family_id, DEVLINK_CMD_RESOURCE_SET, 1);
1993
+
ys->req_policy = &devlink_nest;
1994
+
1995
+
if (req->_present.bus_name_len)
1996
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_BUS_NAME, req->bus_name);
1997
+
if (req->_present.dev_name_len)
1998
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_DEV_NAME, req->dev_name);
1999
+
if (req->_present.resource_id)
2000
+
mnl_attr_put_u64(nlh, DEVLINK_ATTR_RESOURCE_ID, req->resource_id);
2001
+
if (req->_present.resource_size)
2002
+
mnl_attr_put_u64(nlh, DEVLINK_ATTR_RESOURCE_SIZE, req->resource_size);
2003
+
2004
+
err = ynl_exec(ys, nlh, NULL);
2005
+
if (err < 0)
2006
+
return -1;
2007
+
2008
+
return 0;
2009
+
}
2010
+
2011
+
/* ============== DEVLINK_CMD_RESOURCE_DUMP ============== */
2012
+
/* DEVLINK_CMD_RESOURCE_DUMP - do */
2013
+
void devlink_resource_dump_req_free(struct devlink_resource_dump_req *req)
2014
+
{
2015
+
free(req->bus_name);
2016
+
free(req->dev_name);
2017
+
free(req);
2018
+
}
2019
+
2020
+
void devlink_resource_dump_rsp_free(struct devlink_resource_dump_rsp *rsp)
2021
+
{
2022
+
free(rsp->bus_name);
2023
+
free(rsp->dev_name);
2024
+
devlink_dl_resource_list_free(&rsp->resource_list);
2025
+
free(rsp);
2026
+
}
2027
+
2028
+
int devlink_resource_dump_rsp_parse(const struct nlmsghdr *nlh, void *data)
2029
+
{
2030
+
struct devlink_resource_dump_rsp *dst;
2031
+
struct ynl_parse_arg *yarg = data;
2032
+
const struct nlattr *attr;
2033
+
struct ynl_parse_arg parg;
2034
+
2035
+
dst = yarg->data;
2036
+
parg.ys = yarg->ys;
2037
+
2038
+
mnl_attr_for_each(attr, nlh, sizeof(struct genlmsghdr)) {
2039
+
unsigned int type = mnl_attr_get_type(attr);
2040
+
2041
+
if (type == DEVLINK_ATTR_BUS_NAME) {
2042
+
unsigned int len;
2043
+
2044
+
if (ynl_attr_validate(yarg, attr))
2045
+
return MNL_CB_ERROR;
2046
+
2047
+
len = strnlen(mnl_attr_get_str(attr), mnl_attr_get_payload_len(attr));
2048
+
dst->_present.bus_name_len = len;
2049
+
dst->bus_name = malloc(len + 1);
2050
+
memcpy(dst->bus_name, mnl_attr_get_str(attr), len);
2051
+
dst->bus_name[len] = 0;
2052
+
} else if (type == DEVLINK_ATTR_DEV_NAME) {
2053
+
unsigned int len;
2054
+
2055
+
if (ynl_attr_validate(yarg, attr))
2056
+
return MNL_CB_ERROR;
2057
+
2058
+
len = strnlen(mnl_attr_get_str(attr), mnl_attr_get_payload_len(attr));
2059
+
dst->_present.dev_name_len = len;
2060
+
dst->dev_name = malloc(len + 1);
2061
+
memcpy(dst->dev_name, mnl_attr_get_str(attr), len);
2062
+
dst->dev_name[len] = 0;
2063
+
} else if (type == DEVLINK_ATTR_RESOURCE_LIST) {
2064
+
if (ynl_attr_validate(yarg, attr))
2065
+
return MNL_CB_ERROR;
2066
+
dst->_present.resource_list = 1;
2067
+
2068
+
parg.rsp_policy = &devlink_dl_resource_list_nest;
2069
+
parg.data = &dst->resource_list;
2070
+
if (devlink_dl_resource_list_parse(&parg, attr))
2071
+
return MNL_CB_ERROR;
2072
+
}
2073
+
}
2074
+
2075
+
return MNL_CB_OK;
2076
+
}
2077
+
2078
+
struct devlink_resource_dump_rsp *
2079
+
devlink_resource_dump(struct ynl_sock *ys,
2080
+
struct devlink_resource_dump_req *req)
2081
+
{
2082
+
struct ynl_req_state yrs = { .yarg = { .ys = ys, }, };
2083
+
struct devlink_resource_dump_rsp *rsp;
2084
+
struct nlmsghdr *nlh;
2085
+
int err;
2086
+
2087
+
nlh = ynl_gemsg_start_req(ys, ys->family_id, DEVLINK_CMD_RESOURCE_DUMP, 1);
2088
+
ys->req_policy = &devlink_nest;
2089
+
yrs.yarg.rsp_policy = &devlink_nest;
2090
+
2091
+
if (req->_present.bus_name_len)
2092
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_BUS_NAME, req->bus_name);
2093
+
if (req->_present.dev_name_len)
2094
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_DEV_NAME, req->dev_name);
2095
+
2096
+
rsp = calloc(1, sizeof(*rsp));
2097
+
yrs.yarg.data = rsp;
2098
+
yrs.cb = devlink_resource_dump_rsp_parse;
2099
+
yrs.rsp_cmd = DEVLINK_CMD_RESOURCE_DUMP;
2100
+
2101
+
err = ynl_exec(ys, nlh, &yrs);
2102
+
if (err < 0)
2103
+
goto err_free;
2104
+
2105
+
return rsp;
2106
+
2107
+
err_free:
2108
+
devlink_resource_dump_rsp_free(rsp);
2109
+
return NULL;
2110
+
}
2111
+
2112
+
/* ============== DEVLINK_CMD_RELOAD ============== */
2113
+
/* DEVLINK_CMD_RELOAD - do */
2114
+
void devlink_reload_req_free(struct devlink_reload_req *req)
2115
+
{
2116
+
free(req->bus_name);
2117
+
free(req->dev_name);
2118
+
free(req);
2119
+
}
2120
+
2121
+
void devlink_reload_rsp_free(struct devlink_reload_rsp *rsp)
2122
+
{
2123
+
free(rsp->bus_name);
2124
+
free(rsp->dev_name);
2125
+
free(rsp);
2126
+
}
2127
+
2128
+
int devlink_reload_rsp_parse(const struct nlmsghdr *nlh, void *data)
2129
+
{
2130
+
struct ynl_parse_arg *yarg = data;
2131
+
struct devlink_reload_rsp *dst;
2132
+
const struct nlattr *attr;
2133
+
2134
+
dst = yarg->data;
2135
+
2136
+
mnl_attr_for_each(attr, nlh, sizeof(struct genlmsghdr)) {
2137
+
unsigned int type = mnl_attr_get_type(attr);
2138
+
2139
+
if (type == DEVLINK_ATTR_BUS_NAME) {
2140
+
unsigned int len;
2141
+
2142
+
if (ynl_attr_validate(yarg, attr))
2143
+
return MNL_CB_ERROR;
2144
+
2145
+
len = strnlen(mnl_attr_get_str(attr), mnl_attr_get_payload_len(attr));
2146
+
dst->_present.bus_name_len = len;
2147
+
dst->bus_name = malloc(len + 1);
2148
+
memcpy(dst->bus_name, mnl_attr_get_str(attr), len);
2149
+
dst->bus_name[len] = 0;
2150
+
} else if (type == DEVLINK_ATTR_DEV_NAME) {
2151
+
unsigned int len;
2152
+
2153
+
if (ynl_attr_validate(yarg, attr))
2154
+
return MNL_CB_ERROR;
2155
+
2156
+
len = strnlen(mnl_attr_get_str(attr), mnl_attr_get_payload_len(attr));
2157
+
dst->_present.dev_name_len = len;
2158
+
dst->dev_name = malloc(len + 1);
2159
+
memcpy(dst->dev_name, mnl_attr_get_str(attr), len);
2160
+
dst->dev_name[len] = 0;
2161
+
} else if (type == DEVLINK_ATTR_RELOAD_ACTIONS_PERFORMED) {
2162
+
if (ynl_attr_validate(yarg, attr))
2163
+
return MNL_CB_ERROR;
2164
+
dst->_present.reload_actions_performed = 1;
2165
+
memcpy(&dst->reload_actions_performed, mnl_attr_get_payload(attr), sizeof(struct nla_bitfield32));
2166
+
}
2167
+
}
2168
+
2169
+
return MNL_CB_OK;
2170
+
}
2171
+
2172
+
struct devlink_reload_rsp *
2173
+
devlink_reload(struct ynl_sock *ys, struct devlink_reload_req *req)
2174
+
{
2175
+
struct ynl_req_state yrs = { .yarg = { .ys = ys, }, };
2176
+
struct devlink_reload_rsp *rsp;
2177
+
struct nlmsghdr *nlh;
2178
+
int err;
2179
+
2180
+
nlh = ynl_gemsg_start_req(ys, ys->family_id, DEVLINK_CMD_RELOAD, 1);
2181
+
ys->req_policy = &devlink_nest;
2182
+
yrs.yarg.rsp_policy = &devlink_nest;
2183
+
2184
+
if (req->_present.bus_name_len)
2185
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_BUS_NAME, req->bus_name);
2186
+
if (req->_present.dev_name_len)
2187
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_DEV_NAME, req->dev_name);
2188
+
if (req->_present.reload_action)
2189
+
mnl_attr_put_u8(nlh, DEVLINK_ATTR_RELOAD_ACTION, req->reload_action);
2190
+
if (req->_present.reload_limits)
2191
+
mnl_attr_put(nlh, DEVLINK_ATTR_RELOAD_LIMITS, sizeof(struct nla_bitfield32), &req->reload_limits);
2192
+
if (req->_present.netns_pid)
2193
+
mnl_attr_put_u32(nlh, DEVLINK_ATTR_NETNS_PID, req->netns_pid);
2194
+
if (req->_present.netns_fd)
2195
+
mnl_attr_put_u32(nlh, DEVLINK_ATTR_NETNS_FD, req->netns_fd);
2196
+
if (req->_present.netns_id)
2197
+
mnl_attr_put_u32(nlh, DEVLINK_ATTR_NETNS_ID, req->netns_id);
2198
+
2199
+
rsp = calloc(1, sizeof(*rsp));
2200
+
yrs.yarg.data = rsp;
2201
+
yrs.cb = devlink_reload_rsp_parse;
2202
+
yrs.rsp_cmd = DEVLINK_CMD_RELOAD;
2203
+
2204
+
err = ynl_exec(ys, nlh, &yrs);
2205
+
if (err < 0)
2206
+
goto err_free;
2207
+
2208
+
return rsp;
2209
+
2210
+
err_free:
2211
+
devlink_reload_rsp_free(rsp);
2212
+
return NULL;
2213
+
}
2214
+
3322
2215
/* ============== DEVLINK_CMD_PARAM_GET ============== */
3323
2216
/* DEVLINK_CMD_PARAM_GET - do */
3324
2217
void devlink_param_get_req_free(struct devlink_param_get_req *req)
···
4303
1528
free_list:
4304
1529
devlink_param_get_list_free(yds.first);
4305
1530
return NULL;
1531
+
}
1532
+
1533
+
/* ============== DEVLINK_CMD_PARAM_SET ============== */
1534
+
/* DEVLINK_CMD_PARAM_SET - do */
1535
+
void devlink_param_set_req_free(struct devlink_param_set_req *req)
1536
+
{
1537
+
free(req->bus_name);
1538
+
free(req->dev_name);
1539
+
free(req->param_name);
1540
+
free(req);
1541
+
}
1542
+
1543
+
int devlink_param_set(struct ynl_sock *ys, struct devlink_param_set_req *req)
1544
+
{
1545
+
struct nlmsghdr *nlh;
1546
+
int err;
1547
+
1548
+
nlh = ynl_gemsg_start_req(ys, ys->family_id, DEVLINK_CMD_PARAM_SET, 1);
1549
+
ys->req_policy = &devlink_nest;
1550
+
1551
+
if (req->_present.bus_name_len)
1552
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_BUS_NAME, req->bus_name);
1553
+
if (req->_present.dev_name_len)
1554
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_DEV_NAME, req->dev_name);
1555
+
if (req->_present.param_name_len)
1556
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_PARAM_NAME, req->param_name);
1557
+
if (req->_present.param_type)
1558
+
mnl_attr_put_u8(nlh, DEVLINK_ATTR_PARAM_TYPE, req->param_type);
1559
+
if (req->_present.param_value_cmode)
1560
+
mnl_attr_put_u8(nlh, DEVLINK_ATTR_PARAM_VALUE_CMODE, req->param_value_cmode);
1561
+
1562
+
err = ynl_exec(ys, nlh, NULL);
1563
+
if (err < 0)
1564
+
return -1;
1565
+
1566
+
return 0;
4306
1567
}
4307
1568
4308
1569
/* ============== DEVLINK_CMD_REGION_GET ============== */
···
4498
1687
free_list:
4499
1688
devlink_region_get_list_free(yds.first);
4500
1689
return NULL;
1690
+
}
1691
+
1692
+
/* ============== DEVLINK_CMD_REGION_NEW ============== */
1693
+
/* DEVLINK_CMD_REGION_NEW - do */
1694
+
void devlink_region_new_req_free(struct devlink_region_new_req *req)
1695
+
{
1696
+
free(req->bus_name);
1697
+
free(req->dev_name);
1698
+
free(req->region_name);
1699
+
free(req);
1700
+
}
1701
+
1702
+
void devlink_region_new_rsp_free(struct devlink_region_new_rsp *rsp)
1703
+
{
1704
+
free(rsp->bus_name);
1705
+
free(rsp->dev_name);
1706
+
free(rsp->region_name);
1707
+
free(rsp);
1708
+
}
1709
+
1710
+
int devlink_region_new_rsp_parse(const struct nlmsghdr *nlh, void *data)
1711
+
{
1712
+
struct devlink_region_new_rsp *dst;
1713
+
struct ynl_parse_arg *yarg = data;
1714
+
const struct nlattr *attr;
1715
+
1716
+
dst = yarg->data;
1717
+
1718
+
mnl_attr_for_each(attr, nlh, sizeof(struct genlmsghdr)) {
1719
+
unsigned int type = mnl_attr_get_type(attr);
1720
+
1721
+
if (type == DEVLINK_ATTR_BUS_NAME) {
1722
+
unsigned int len;
1723
+
1724
+
if (ynl_attr_validate(yarg, attr))
1725
+
return MNL_CB_ERROR;
1726
+
1727
+
len = strnlen(mnl_attr_get_str(attr), mnl_attr_get_payload_len(attr));
1728
+
dst->_present.bus_name_len = len;
1729
+
dst->bus_name = malloc(len + 1);
1730
+
memcpy(dst->bus_name, mnl_attr_get_str(attr), len);
1731
+
dst->bus_name[len] = 0;
1732
+
} else if (type == DEVLINK_ATTR_DEV_NAME) {
1733
+
unsigned int len;
1734
+
1735
+
if (ynl_attr_validate(yarg, attr))
1736
+
return MNL_CB_ERROR;
1737
+
1738
+
len = strnlen(mnl_attr_get_str(attr), mnl_attr_get_payload_len(attr));
1739
+
dst->_present.dev_name_len = len;
1740
+
dst->dev_name = malloc(len + 1);
1741
+
memcpy(dst->dev_name, mnl_attr_get_str(attr), len);
1742
+
dst->dev_name[len] = 0;
1743
+
} else if (type == DEVLINK_ATTR_PORT_INDEX) {
1744
+
if (ynl_attr_validate(yarg, attr))
1745
+
return MNL_CB_ERROR;
1746
+
dst->_present.port_index = 1;
1747
+
dst->port_index = mnl_attr_get_u32(attr);
1748
+
} else if (type == DEVLINK_ATTR_REGION_NAME) {
1749
+
unsigned int len;
1750
+
1751
+
if (ynl_attr_validate(yarg, attr))
1752
+
return MNL_CB_ERROR;
1753
+
1754
+
len = strnlen(mnl_attr_get_str(attr), mnl_attr_get_payload_len(attr));
1755
+
dst->_present.region_name_len = len;
1756
+
dst->region_name = malloc(len + 1);
1757
+
memcpy(dst->region_name, mnl_attr_get_str(attr), len);
1758
+
dst->region_name[len] = 0;
1759
+
} else if (type == DEVLINK_ATTR_REGION_SNAPSHOT_ID) {
1760
+
if (ynl_attr_validate(yarg, attr))
1761
+
return MNL_CB_ERROR;
1762
+
dst->_present.region_snapshot_id = 1;
1763
+
dst->region_snapshot_id = mnl_attr_get_u32(attr);
1764
+
}
1765
+
}
1766
+
1767
+
return MNL_CB_OK;
1768
+
}
1769
+
1770
+
struct devlink_region_new_rsp *
1771
+
devlink_region_new(struct ynl_sock *ys, struct devlink_region_new_req *req)
1772
+
{
1773
+
struct ynl_req_state yrs = { .yarg = { .ys = ys, }, };
1774
+
struct devlink_region_new_rsp *rsp;
1775
+
struct nlmsghdr *nlh;
1776
+
int err;
1777
+
1778
+
nlh = ynl_gemsg_start_req(ys, ys->family_id, DEVLINK_CMD_REGION_NEW, 1);
1779
+
ys->req_policy = &devlink_nest;
1780
+
yrs.yarg.rsp_policy = &devlink_nest;
1781
+
1782
+
if (req->_present.bus_name_len)
1783
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_BUS_NAME, req->bus_name);
1784
+
if (req->_present.dev_name_len)
1785
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_DEV_NAME, req->dev_name);
1786
+
if (req->_present.port_index)
1787
+
mnl_attr_put_u32(nlh, DEVLINK_ATTR_PORT_INDEX, req->port_index);
1788
+
if (req->_present.region_name_len)
1789
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_REGION_NAME, req->region_name);
1790
+
if (req->_present.region_snapshot_id)
1791
+
mnl_attr_put_u32(nlh, DEVLINK_ATTR_REGION_SNAPSHOT_ID, req->region_snapshot_id);
1792
+
1793
+
rsp = calloc(1, sizeof(*rsp));
1794
+
yrs.yarg.data = rsp;
1795
+
yrs.cb = devlink_region_new_rsp_parse;
1796
+
yrs.rsp_cmd = DEVLINK_CMD_REGION_NEW;
1797
+
1798
+
err = ynl_exec(ys, nlh, &yrs);
1799
+
if (err < 0)
1800
+
goto err_free;
1801
+
1802
+
return rsp;
1803
+
1804
+
err_free:
1805
+
devlink_region_new_rsp_free(rsp);
1806
+
return NULL;
1807
+
}
1808
+
1809
+
/* ============== DEVLINK_CMD_REGION_DEL ============== */
1810
+
/* DEVLINK_CMD_REGION_DEL - do */
1811
+
void devlink_region_del_req_free(struct devlink_region_del_req *req)
1812
+
{
1813
+
free(req->bus_name);
1814
+
free(req->dev_name);
1815
+
free(req->region_name);
1816
+
free(req);
1817
+
}
1818
+
1819
+
int devlink_region_del(struct ynl_sock *ys, struct devlink_region_del_req *req)
1820
+
{
1821
+
struct nlmsghdr *nlh;
1822
+
int err;
1823
+
1824
+
nlh = ynl_gemsg_start_req(ys, ys->family_id, DEVLINK_CMD_REGION_DEL, 1);
1825
+
ys->req_policy = &devlink_nest;
1826
+
1827
+
if (req->_present.bus_name_len)
1828
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_BUS_NAME, req->bus_name);
1829
+
if (req->_present.dev_name_len)
1830
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_DEV_NAME, req->dev_name);
1831
+
if (req->_present.port_index)
1832
+
mnl_attr_put_u32(nlh, DEVLINK_ATTR_PORT_INDEX, req->port_index);
1833
+
if (req->_present.region_name_len)
1834
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_REGION_NAME, req->region_name);
1835
+
if (req->_present.region_snapshot_id)
1836
+
mnl_attr_put_u32(nlh, DEVLINK_ATTR_REGION_SNAPSHOT_ID, req->region_snapshot_id);
1837
+
1838
+
err = ynl_exec(ys, nlh, NULL);
1839
+
if (err < 0)
1840
+
return -1;
1841
+
1842
+
return 0;
1843
+
}
1844
+
1845
+
/* ============== DEVLINK_CMD_REGION_READ ============== */
1846
+
/* DEVLINK_CMD_REGION_READ - dump */
1847
+
int devlink_region_read_rsp_dump_parse(const struct nlmsghdr *nlh, void *data)
1848
+
{
1849
+
struct devlink_region_read_rsp_dump *dst;
1850
+
struct ynl_parse_arg *yarg = data;
1851
+
const struct nlattr *attr;
1852
+
1853
+
dst = yarg->data;
1854
+
1855
+
mnl_attr_for_each(attr, nlh, sizeof(struct genlmsghdr)) {
1856
+
unsigned int type = mnl_attr_get_type(attr);
1857
+
1858
+
if (type == DEVLINK_ATTR_BUS_NAME) {
1859
+
unsigned int len;
1860
+
1861
+
if (ynl_attr_validate(yarg, attr))
1862
+
return MNL_CB_ERROR;
1863
+
1864
+
len = strnlen(mnl_attr_get_str(attr), mnl_attr_get_payload_len(attr));
1865
+
dst->_present.bus_name_len = len;
1866
+
dst->bus_name = malloc(len + 1);
1867
+
memcpy(dst->bus_name, mnl_attr_get_str(attr), len);
1868
+
dst->bus_name[len] = 0;
1869
+
} else if (type == DEVLINK_ATTR_DEV_NAME) {
1870
+
unsigned int len;
1871
+
1872
+
if (ynl_attr_validate(yarg, attr))
1873
+
return MNL_CB_ERROR;
1874
+
1875
+
len = strnlen(mnl_attr_get_str(attr), mnl_attr_get_payload_len(attr));
1876
+
dst->_present.dev_name_len = len;
1877
+
dst->dev_name = malloc(len + 1);
1878
+
memcpy(dst->dev_name, mnl_attr_get_str(attr), len);
1879
+
dst->dev_name[len] = 0;
1880
+
} else if (type == DEVLINK_ATTR_PORT_INDEX) {
1881
+
if (ynl_attr_validate(yarg, attr))
1882
+
return MNL_CB_ERROR;
1883
+
dst->_present.port_index = 1;
1884
+
dst->port_index = mnl_attr_get_u32(attr);
1885
+
} else if (type == DEVLINK_ATTR_REGION_NAME) {
1886
+
unsigned int len;
1887
+
1888
+
if (ynl_attr_validate(yarg, attr))
1889
+
return MNL_CB_ERROR;
1890
+
1891
+
len = strnlen(mnl_attr_get_str(attr), mnl_attr_get_payload_len(attr));
1892
+
dst->_present.region_name_len = len;
1893
+
dst->region_name = malloc(len + 1);
1894
+
memcpy(dst->region_name, mnl_attr_get_str(attr), len);
1895
+
dst->region_name[len] = 0;
1896
+
}
1897
+
}
1898
+
1899
+
return MNL_CB_OK;
1900
+
}
1901
+
1902
+
void
1903
+
devlink_region_read_rsp_list_free(struct devlink_region_read_rsp_list *rsp)
1904
+
{
1905
+
struct devlink_region_read_rsp_list *next = rsp;
1906
+
1907
+
while ((void *)next != YNL_LIST_END) {
1908
+
rsp = next;
1909
+
next = rsp->next;
1910
+
1911
+
free(rsp->obj.bus_name);
1912
+
free(rsp->obj.dev_name);
1913
+
free(rsp->obj.region_name);
1914
+
free(rsp);
1915
+
}
1916
+
}
1917
+
1918
+
struct devlink_region_read_rsp_list *
1919
+
devlink_region_read_dump(struct ynl_sock *ys,
1920
+
struct devlink_region_read_req_dump *req)
1921
+
{
1922
+
struct ynl_dump_state yds = {};
1923
+
struct nlmsghdr *nlh;
1924
+
int err;
1925
+
1926
+
yds.ys = ys;
1927
+
yds.alloc_sz = sizeof(struct devlink_region_read_rsp_list);
1928
+
yds.cb = devlink_region_read_rsp_dump_parse;
1929
+
yds.rsp_cmd = DEVLINK_CMD_REGION_READ;
1930
+
yds.rsp_policy = &devlink_nest;
1931
+
1932
+
nlh = ynl_gemsg_start_dump(ys, ys->family_id, DEVLINK_CMD_REGION_READ, 1);
1933
+
ys->req_policy = &devlink_nest;
1934
+
1935
+
if (req->_present.bus_name_len)
1936
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_BUS_NAME, req->bus_name);
1937
+
if (req->_present.dev_name_len)
1938
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_DEV_NAME, req->dev_name);
1939
+
if (req->_present.port_index)
1940
+
mnl_attr_put_u32(nlh, DEVLINK_ATTR_PORT_INDEX, req->port_index);
1941
+
if (req->_present.region_name_len)
1942
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_REGION_NAME, req->region_name);
1943
+
if (req->_present.region_snapshot_id)
1944
+
mnl_attr_put_u32(nlh, DEVLINK_ATTR_REGION_SNAPSHOT_ID, req->region_snapshot_id);
1945
+
if (req->_present.region_direct)
1946
+
mnl_attr_put(nlh, DEVLINK_ATTR_REGION_DIRECT, 0, NULL);
1947
+
if (req->_present.region_chunk_addr)
1948
+
mnl_attr_put_u64(nlh, DEVLINK_ATTR_REGION_CHUNK_ADDR, req->region_chunk_addr);
1949
+
if (req->_present.region_chunk_len)
1950
+
mnl_attr_put_u64(nlh, DEVLINK_ATTR_REGION_CHUNK_LEN, req->region_chunk_len);
1951
+
1952
+
err = ynl_exec_dump(ys, nlh, &yds);
1953
+
if (err < 0)
1954
+
goto free_list;
1955
+
1956
+
return yds.first;
1957
+
1958
+
free_list:
1959
+
devlink_region_read_rsp_list_free(yds.first);
1960
+
return NULL;
1961
+
}
1962
+
1963
+
/* ============== DEVLINK_CMD_PORT_PARAM_GET ============== */
1964
+
/* DEVLINK_CMD_PORT_PARAM_GET - do */
1965
+
void devlink_port_param_get_req_free(struct devlink_port_param_get_req *req)
1966
+
{
1967
+
free(req->bus_name);
1968
+
free(req->dev_name);
1969
+
free(req);
1970
+
}
1971
+
1972
+
void devlink_port_param_get_rsp_free(struct devlink_port_param_get_rsp *rsp)
1973
+
{
1974
+
free(rsp->bus_name);
1975
+
free(rsp->dev_name);
1976
+
free(rsp);
1977
+
}
1978
+
1979
+
int devlink_port_param_get_rsp_parse(const struct nlmsghdr *nlh, void *data)
1980
+
{
1981
+
struct devlink_port_param_get_rsp *dst;
1982
+
struct ynl_parse_arg *yarg = data;
1983
+
const struct nlattr *attr;
1984
+
1985
+
dst = yarg->data;
1986
+
1987
+
mnl_attr_for_each(attr, nlh, sizeof(struct genlmsghdr)) {
1988
+
unsigned int type = mnl_attr_get_type(attr);
1989
+
1990
+
if (type == DEVLINK_ATTR_BUS_NAME) {
1991
+
unsigned int len;
1992
+
1993
+
if (ynl_attr_validate(yarg, attr))
1994
+
return MNL_CB_ERROR;
1995
+
1996
+
len = strnlen(mnl_attr_get_str(attr), mnl_attr_get_payload_len(attr));
1997
+
dst->_present.bus_name_len = len;
1998
+
dst->bus_name = malloc(len + 1);
1999
+
memcpy(dst->bus_name, mnl_attr_get_str(attr), len);
2000
+
dst->bus_name[len] = 0;
2001
+
} else if (type == DEVLINK_ATTR_DEV_NAME) {
2002
+
unsigned int len;
2003
+
2004
+
if (ynl_attr_validate(yarg, attr))
2005
+
return MNL_CB_ERROR;
2006
+
2007
+
len = strnlen(mnl_attr_get_str(attr), mnl_attr_get_payload_len(attr));
2008
+
dst->_present.dev_name_len = len;
2009
+
dst->dev_name = malloc(len + 1);
2010
+
memcpy(dst->dev_name, mnl_attr_get_str(attr), len);
2011
+
dst->dev_name[len] = 0;
2012
+
} else if (type == DEVLINK_ATTR_PORT_INDEX) {
2013
+
if (ynl_attr_validate(yarg, attr))
2014
+
return MNL_CB_ERROR;
2015
+
dst->_present.port_index = 1;
2016
+
dst->port_index = mnl_attr_get_u32(attr);
2017
+
}
2018
+
}
2019
+
2020
+
return MNL_CB_OK;
2021
+
}
2022
+
2023
+
struct devlink_port_param_get_rsp *
2024
+
devlink_port_param_get(struct ynl_sock *ys,
2025
+
struct devlink_port_param_get_req *req)
2026
+
{
2027
+
struct ynl_req_state yrs = { .yarg = { .ys = ys, }, };
2028
+
struct devlink_port_param_get_rsp *rsp;
2029
+
struct nlmsghdr *nlh;
2030
+
int err;
2031
+
2032
+
nlh = ynl_gemsg_start_req(ys, ys->family_id, DEVLINK_CMD_PORT_PARAM_GET, 1);
2033
+
ys->req_policy = &devlink_nest;
2034
+
yrs.yarg.rsp_policy = &devlink_nest;
2035
+
2036
+
if (req->_present.bus_name_len)
2037
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_BUS_NAME, req->bus_name);
2038
+
if (req->_present.dev_name_len)
2039
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_DEV_NAME, req->dev_name);
2040
+
if (req->_present.port_index)
2041
+
mnl_attr_put_u32(nlh, DEVLINK_ATTR_PORT_INDEX, req->port_index);
2042
+
2043
+
rsp = calloc(1, sizeof(*rsp));
2044
+
yrs.yarg.data = rsp;
2045
+
yrs.cb = devlink_port_param_get_rsp_parse;
2046
+
yrs.rsp_cmd = DEVLINK_CMD_PORT_PARAM_GET;
2047
+
2048
+
err = ynl_exec(ys, nlh, &yrs);
2049
+
if (err < 0)
2050
+
goto err_free;
2051
+
2052
+
return rsp;
2053
+
2054
+
err_free:
2055
+
devlink_port_param_get_rsp_free(rsp);
2056
+
return NULL;
2057
+
}
2058
+
2059
+
/* DEVLINK_CMD_PORT_PARAM_GET - dump */
2060
+
void devlink_port_param_get_list_free(struct devlink_port_param_get_list *rsp)
2061
+
{
2062
+
struct devlink_port_param_get_list *next = rsp;
2063
+
2064
+
while ((void *)next != YNL_LIST_END) {
2065
+
rsp = next;
2066
+
next = rsp->next;
2067
+
2068
+
free(rsp->obj.bus_name);
2069
+
free(rsp->obj.dev_name);
2070
+
free(rsp);
2071
+
}
2072
+
}
2073
+
2074
+
struct devlink_port_param_get_list *
2075
+
devlink_port_param_get_dump(struct ynl_sock *ys)
2076
+
{
2077
+
struct ynl_dump_state yds = {};
2078
+
struct nlmsghdr *nlh;
2079
+
int err;
2080
+
2081
+
yds.ys = ys;
2082
+
yds.alloc_sz = sizeof(struct devlink_port_param_get_list);
2083
+
yds.cb = devlink_port_param_get_rsp_parse;
2084
+
yds.rsp_cmd = DEVLINK_CMD_PORT_PARAM_GET;
2085
+
yds.rsp_policy = &devlink_nest;
2086
+
2087
+
nlh = ynl_gemsg_start_dump(ys, ys->family_id, DEVLINK_CMD_PORT_PARAM_GET, 1);
2088
+
2089
+
err = ynl_exec_dump(ys, nlh, &yds);
2090
+
if (err < 0)
2091
+
goto free_list;
2092
+
2093
+
return yds.first;
2094
+
2095
+
free_list:
2096
+
devlink_port_param_get_list_free(yds.first);
2097
+
return NULL;
2098
+
}
2099
+
2100
+
/* ============== DEVLINK_CMD_PORT_PARAM_SET ============== */
2101
+
/* DEVLINK_CMD_PORT_PARAM_SET - do */
2102
+
void devlink_port_param_set_req_free(struct devlink_port_param_set_req *req)
2103
+
{
2104
+
free(req->bus_name);
2105
+
free(req->dev_name);
2106
+
free(req);
2107
+
}
2108
+
2109
+
int devlink_port_param_set(struct ynl_sock *ys,
2110
+
struct devlink_port_param_set_req *req)
2111
+
{
2112
+
struct nlmsghdr *nlh;
2113
+
int err;
2114
+
2115
+
nlh = ynl_gemsg_start_req(ys, ys->family_id, DEVLINK_CMD_PORT_PARAM_SET, 1);
2116
+
ys->req_policy = &devlink_nest;
2117
+
2118
+
if (req->_present.bus_name_len)
2119
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_BUS_NAME, req->bus_name);
2120
+
if (req->_present.dev_name_len)
2121
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_DEV_NAME, req->dev_name);
2122
+
if (req->_present.port_index)
2123
+
mnl_attr_put_u32(nlh, DEVLINK_ATTR_PORT_INDEX, req->port_index);
2124
+
2125
+
err = ynl_exec(ys, nlh, NULL);
2126
+
if (err < 0)
2127
+
return -1;
2128
+
2129
+
return 0;
4501
2130
}
4502
2131
4503
2132
/* ============== DEVLINK_CMD_INFO_GET ============== */
···
5344
2093
return NULL;
5345
2094
}
5346
2095
2096
+
/* ============== DEVLINK_CMD_HEALTH_REPORTER_SET ============== */
2097
+
/* DEVLINK_CMD_HEALTH_REPORTER_SET - do */
2098
+
void
2099
+
devlink_health_reporter_set_req_free(struct devlink_health_reporter_set_req *req)
2100
+
{
2101
+
free(req->bus_name);
2102
+
free(req->dev_name);
2103
+
free(req->health_reporter_name);
2104
+
free(req);
2105
+
}
2106
+
2107
+
int devlink_health_reporter_set(struct ynl_sock *ys,
2108
+
struct devlink_health_reporter_set_req *req)
2109
+
{
2110
+
struct nlmsghdr *nlh;
2111
+
int err;
2112
+
2113
+
nlh = ynl_gemsg_start_req(ys, ys->family_id, DEVLINK_CMD_HEALTH_REPORTER_SET, 1);
2114
+
ys->req_policy = &devlink_nest;
2115
+
2116
+
if (req->_present.bus_name_len)
2117
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_BUS_NAME, req->bus_name);
2118
+
if (req->_present.dev_name_len)
2119
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_DEV_NAME, req->dev_name);
2120
+
if (req->_present.port_index)
2121
+
mnl_attr_put_u32(nlh, DEVLINK_ATTR_PORT_INDEX, req->port_index);
2122
+
if (req->_present.health_reporter_name_len)
2123
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_HEALTH_REPORTER_NAME, req->health_reporter_name);
2124
+
if (req->_present.health_reporter_graceful_period)
2125
+
mnl_attr_put_u64(nlh, DEVLINK_ATTR_HEALTH_REPORTER_GRACEFUL_PERIOD, req->health_reporter_graceful_period);
2126
+
if (req->_present.health_reporter_auto_recover)
2127
+
mnl_attr_put_u8(nlh, DEVLINK_ATTR_HEALTH_REPORTER_AUTO_RECOVER, req->health_reporter_auto_recover);
2128
+
if (req->_present.health_reporter_auto_dump)
2129
+
mnl_attr_put_u8(nlh, DEVLINK_ATTR_HEALTH_REPORTER_AUTO_DUMP, req->health_reporter_auto_dump);
2130
+
2131
+
err = ynl_exec(ys, nlh, NULL);
2132
+
if (err < 0)
2133
+
return -1;
2134
+
2135
+
return 0;
2136
+
}
2137
+
2138
+
/* ============== DEVLINK_CMD_HEALTH_REPORTER_RECOVER ============== */
2139
+
/* DEVLINK_CMD_HEALTH_REPORTER_RECOVER - do */
2140
+
void
2141
+
devlink_health_reporter_recover_req_free(struct devlink_health_reporter_recover_req *req)
2142
+
{
2143
+
free(req->bus_name);
2144
+
free(req->dev_name);
2145
+
free(req->health_reporter_name);
2146
+
free(req);
2147
+
}
2148
+
2149
+
int devlink_health_reporter_recover(struct ynl_sock *ys,
2150
+
struct devlink_health_reporter_recover_req *req)
2151
+
{
2152
+
struct nlmsghdr *nlh;
2153
+
int err;
2154
+
2155
+
nlh = ynl_gemsg_start_req(ys, ys->family_id, DEVLINK_CMD_HEALTH_REPORTER_RECOVER, 1);
2156
+
ys->req_policy = &devlink_nest;
2157
+
2158
+
if (req->_present.bus_name_len)
2159
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_BUS_NAME, req->bus_name);
2160
+
if (req->_present.dev_name_len)
2161
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_DEV_NAME, req->dev_name);
2162
+
if (req->_present.port_index)
2163
+
mnl_attr_put_u32(nlh, DEVLINK_ATTR_PORT_INDEX, req->port_index);
2164
+
if (req->_present.health_reporter_name_len)
2165
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_HEALTH_REPORTER_NAME, req->health_reporter_name);
2166
+
2167
+
err = ynl_exec(ys, nlh, NULL);
2168
+
if (err < 0)
2169
+
return -1;
2170
+
2171
+
return 0;
2172
+
}
2173
+
2174
+
/* ============== DEVLINK_CMD_HEALTH_REPORTER_DIAGNOSE ============== */
2175
+
/* DEVLINK_CMD_HEALTH_REPORTER_DIAGNOSE - do */
2176
+
void
2177
+
devlink_health_reporter_diagnose_req_free(struct devlink_health_reporter_diagnose_req *req)
2178
+
{
2179
+
free(req->bus_name);
2180
+
free(req->dev_name);
2181
+
free(req->health_reporter_name);
2182
+
free(req);
2183
+
}
2184
+
2185
+
int devlink_health_reporter_diagnose(struct ynl_sock *ys,
2186
+
struct devlink_health_reporter_diagnose_req *req)
2187
+
{
2188
+
struct nlmsghdr *nlh;
2189
+
int err;
2190
+
2191
+
nlh = ynl_gemsg_start_req(ys, ys->family_id, DEVLINK_CMD_HEALTH_REPORTER_DIAGNOSE, 1);
2192
+
ys->req_policy = &devlink_nest;
2193
+
2194
+
if (req->_present.bus_name_len)
2195
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_BUS_NAME, req->bus_name);
2196
+
if (req->_present.dev_name_len)
2197
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_DEV_NAME, req->dev_name);
2198
+
if (req->_present.port_index)
2199
+
mnl_attr_put_u32(nlh, DEVLINK_ATTR_PORT_INDEX, req->port_index);
2200
+
if (req->_present.health_reporter_name_len)
2201
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_HEALTH_REPORTER_NAME, req->health_reporter_name);
2202
+
2203
+
err = ynl_exec(ys, nlh, NULL);
2204
+
if (err < 0)
2205
+
return -1;
2206
+
2207
+
return 0;
2208
+
}
2209
+
2210
+
/* ============== DEVLINK_CMD_HEALTH_REPORTER_DUMP_GET ============== */
2211
+
/* DEVLINK_CMD_HEALTH_REPORTER_DUMP_GET - dump */
2212
+
int devlink_health_reporter_dump_get_rsp_dump_parse(const struct nlmsghdr *nlh,
2213
+
void *data)
2214
+
{
2215
+
struct devlink_health_reporter_dump_get_rsp_dump *dst;
2216
+
struct ynl_parse_arg *yarg = data;
2217
+
const struct nlattr *attr;
2218
+
struct ynl_parse_arg parg;
2219
+
2220
+
dst = yarg->data;
2221
+
parg.ys = yarg->ys;
2222
+
2223
+
mnl_attr_for_each(attr, nlh, sizeof(struct genlmsghdr)) {
2224
+
unsigned int type = mnl_attr_get_type(attr);
2225
+
2226
+
if (type == DEVLINK_ATTR_FMSG) {
2227
+
if (ynl_attr_validate(yarg, attr))
2228
+
return MNL_CB_ERROR;
2229
+
dst->_present.fmsg = 1;
2230
+
2231
+
parg.rsp_policy = &devlink_dl_fmsg_nest;
2232
+
parg.data = &dst->fmsg;
2233
+
if (devlink_dl_fmsg_parse(&parg, attr))
2234
+
return MNL_CB_ERROR;
2235
+
}
2236
+
}
2237
+
2238
+
return MNL_CB_OK;
2239
+
}
2240
+
2241
+
void
2242
+
devlink_health_reporter_dump_get_rsp_list_free(struct devlink_health_reporter_dump_get_rsp_list *rsp)
2243
+
{
2244
+
struct devlink_health_reporter_dump_get_rsp_list *next = rsp;
2245
+
2246
+
while ((void *)next != YNL_LIST_END) {
2247
+
rsp = next;
2248
+
next = rsp->next;
2249
+
2250
+
devlink_dl_fmsg_free(&rsp->obj.fmsg);
2251
+
free(rsp);
2252
+
}
2253
+
}
2254
+
2255
+
struct devlink_health_reporter_dump_get_rsp_list *
2256
+
devlink_health_reporter_dump_get_dump(struct ynl_sock *ys,
2257
+
struct devlink_health_reporter_dump_get_req_dump *req)
2258
+
{
2259
+
struct ynl_dump_state yds = {};
2260
+
struct nlmsghdr *nlh;
2261
+
int err;
2262
+
2263
+
yds.ys = ys;
2264
+
yds.alloc_sz = sizeof(struct devlink_health_reporter_dump_get_rsp_list);
2265
+
yds.cb = devlink_health_reporter_dump_get_rsp_dump_parse;
2266
+
yds.rsp_cmd = DEVLINK_CMD_HEALTH_REPORTER_DUMP_GET;
2267
+
yds.rsp_policy = &devlink_nest;
2268
+
2269
+
nlh = ynl_gemsg_start_dump(ys, ys->family_id, DEVLINK_CMD_HEALTH_REPORTER_DUMP_GET, 1);
2270
+
ys->req_policy = &devlink_nest;
2271
+
2272
+
if (req->_present.bus_name_len)
2273
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_BUS_NAME, req->bus_name);
2274
+
if (req->_present.dev_name_len)
2275
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_DEV_NAME, req->dev_name);
2276
+
if (req->_present.port_index)
2277
+
mnl_attr_put_u32(nlh, DEVLINK_ATTR_PORT_INDEX, req->port_index);
2278
+
if (req->_present.health_reporter_name_len)
2279
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_HEALTH_REPORTER_NAME, req->health_reporter_name);
2280
+
2281
+
err = ynl_exec_dump(ys, nlh, &yds);
2282
+
if (err < 0)
2283
+
goto free_list;
2284
+
2285
+
return yds.first;
2286
+
2287
+
free_list:
2288
+
devlink_health_reporter_dump_get_rsp_list_free(yds.first);
2289
+
return NULL;
2290
+
}
2291
+
2292
+
/* ============== DEVLINK_CMD_HEALTH_REPORTER_DUMP_CLEAR ============== */
2293
+
/* DEVLINK_CMD_HEALTH_REPORTER_DUMP_CLEAR - do */
2294
+
void
2295
+
devlink_health_reporter_dump_clear_req_free(struct devlink_health_reporter_dump_clear_req *req)
2296
+
{
2297
+
free(req->bus_name);
2298
+
free(req->dev_name);
2299
+
free(req->health_reporter_name);
2300
+
free(req);
2301
+
}
2302
+
2303
+
int devlink_health_reporter_dump_clear(struct ynl_sock *ys,
2304
+
struct devlink_health_reporter_dump_clear_req *req)
2305
+
{
2306
+
struct nlmsghdr *nlh;
2307
+
int err;
2308
+
2309
+
nlh = ynl_gemsg_start_req(ys, ys->family_id, DEVLINK_CMD_HEALTH_REPORTER_DUMP_CLEAR, 1);
2310
+
ys->req_policy = &devlink_nest;
2311
+
2312
+
if (req->_present.bus_name_len)
2313
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_BUS_NAME, req->bus_name);
2314
+
if (req->_present.dev_name_len)
2315
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_DEV_NAME, req->dev_name);
2316
+
if (req->_present.port_index)
2317
+
mnl_attr_put_u32(nlh, DEVLINK_ATTR_PORT_INDEX, req->port_index);
2318
+
if (req->_present.health_reporter_name_len)
2319
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_HEALTH_REPORTER_NAME, req->health_reporter_name);
2320
+
2321
+
err = ynl_exec(ys, nlh, NULL);
2322
+
if (err < 0)
2323
+
return -1;
2324
+
2325
+
return 0;
2326
+
}
2327
+
2328
+
/* ============== DEVLINK_CMD_FLASH_UPDATE ============== */
2329
+
/* DEVLINK_CMD_FLASH_UPDATE - do */
2330
+
void devlink_flash_update_req_free(struct devlink_flash_update_req *req)
2331
+
{
2332
+
free(req->bus_name);
2333
+
free(req->dev_name);
2334
+
free(req->flash_update_file_name);
2335
+
free(req->flash_update_component);
2336
+
free(req);
2337
+
}
2338
+
2339
+
int devlink_flash_update(struct ynl_sock *ys,
2340
+
struct devlink_flash_update_req *req)
2341
+
{
2342
+
struct nlmsghdr *nlh;
2343
+
int err;
2344
+
2345
+
nlh = ynl_gemsg_start_req(ys, ys->family_id, DEVLINK_CMD_FLASH_UPDATE, 1);
2346
+
ys->req_policy = &devlink_nest;
2347
+
2348
+
if (req->_present.bus_name_len)
2349
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_BUS_NAME, req->bus_name);
2350
+
if (req->_present.dev_name_len)
2351
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_DEV_NAME, req->dev_name);
2352
+
if (req->_present.flash_update_file_name_len)
2353
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_FLASH_UPDATE_FILE_NAME, req->flash_update_file_name);
2354
+
if (req->_present.flash_update_component_len)
2355
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_FLASH_UPDATE_COMPONENT, req->flash_update_component);
2356
+
if (req->_present.flash_update_overwrite_mask)
2357
+
mnl_attr_put(nlh, DEVLINK_ATTR_FLASH_UPDATE_OVERWRITE_MASK, sizeof(struct nla_bitfield32), &req->flash_update_overwrite_mask);
2358
+
2359
+
err = ynl_exec(ys, nlh, NULL);
2360
+
if (err < 0)
2361
+
return -1;
2362
+
2363
+
return 0;
2364
+
}
2365
+
5347
2366
/* ============== DEVLINK_CMD_TRAP_GET ============== */
5348
2367
/* DEVLINK_CMD_TRAP_GET - do */
5349
2368
void devlink_trap_get_req_free(struct devlink_trap_get_req *req)
···
5764
2243
free_list:
5765
2244
devlink_trap_get_list_free(yds.first);
5766
2245
return NULL;
2246
+
}
2247
+
2248
+
/* ============== DEVLINK_CMD_TRAP_SET ============== */
2249
+
/* DEVLINK_CMD_TRAP_SET - do */
2250
+
void devlink_trap_set_req_free(struct devlink_trap_set_req *req)
2251
+
{
2252
+
free(req->bus_name);
2253
+
free(req->dev_name);
2254
+
free(req->trap_name);
2255
+
free(req);
2256
+
}
2257
+
2258
+
int devlink_trap_set(struct ynl_sock *ys, struct devlink_trap_set_req *req)
2259
+
{
2260
+
struct nlmsghdr *nlh;
2261
+
int err;
2262
+
2263
+
nlh = ynl_gemsg_start_req(ys, ys->family_id, DEVLINK_CMD_TRAP_SET, 1);
2264
+
ys->req_policy = &devlink_nest;
2265
+
2266
+
if (req->_present.bus_name_len)
2267
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_BUS_NAME, req->bus_name);
2268
+
if (req->_present.dev_name_len)
2269
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_DEV_NAME, req->dev_name);
2270
+
if (req->_present.trap_name_len)
2271
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_TRAP_NAME, req->trap_name);
2272
+
if (req->_present.trap_action)
2273
+
mnl_attr_put_u8(nlh, DEVLINK_ATTR_TRAP_ACTION, req->trap_action);
2274
+
2275
+
err = ynl_exec(ys, nlh, NULL);
2276
+
if (err < 0)
2277
+
return -1;
2278
+
2279
+
return 0;
5767
2280
}
5768
2281
5769
2282
/* ============== DEVLINK_CMD_TRAP_GROUP_GET ============== */
···
5953
2398
return NULL;
5954
2399
}
5955
2400
2401
+
/* ============== DEVLINK_CMD_TRAP_GROUP_SET ============== */
2402
+
/* DEVLINK_CMD_TRAP_GROUP_SET - do */
2403
+
void devlink_trap_group_set_req_free(struct devlink_trap_group_set_req *req)
2404
+
{
2405
+
free(req->bus_name);
2406
+
free(req->dev_name);
2407
+
free(req->trap_group_name);
2408
+
free(req);
2409
+
}
2410
+
2411
+
int devlink_trap_group_set(struct ynl_sock *ys,
2412
+
struct devlink_trap_group_set_req *req)
2413
+
{
2414
+
struct nlmsghdr *nlh;
2415
+
int err;
2416
+
2417
+
nlh = ynl_gemsg_start_req(ys, ys->family_id, DEVLINK_CMD_TRAP_GROUP_SET, 1);
2418
+
ys->req_policy = &devlink_nest;
2419
+
2420
+
if (req->_present.bus_name_len)
2421
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_BUS_NAME, req->bus_name);
2422
+
if (req->_present.dev_name_len)
2423
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_DEV_NAME, req->dev_name);
2424
+
if (req->_present.trap_group_name_len)
2425
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_TRAP_GROUP_NAME, req->trap_group_name);
2426
+
if (req->_present.trap_action)
2427
+
mnl_attr_put_u8(nlh, DEVLINK_ATTR_TRAP_ACTION, req->trap_action);
2428
+
if (req->_present.trap_policer_id)
2429
+
mnl_attr_put_u32(nlh, DEVLINK_ATTR_TRAP_POLICER_ID, req->trap_policer_id);
2430
+
2431
+
err = ynl_exec(ys, nlh, NULL);
2432
+
if (err < 0)
2433
+
return -1;
2434
+
2435
+
return 0;
2436
+
}
2437
+
5956
2438
/* ============== DEVLINK_CMD_TRAP_POLICER_GET ============== */
5957
2439
/* DEVLINK_CMD_TRAP_POLICER_GET - do */
5958
2440
void
···
6135
2543
free_list:
6136
2544
devlink_trap_policer_get_list_free(yds.first);
6137
2545
return NULL;
2546
+
}
2547
+
2548
+
/* ============== DEVLINK_CMD_TRAP_POLICER_SET ============== */
2549
+
/* DEVLINK_CMD_TRAP_POLICER_SET - do */
2550
+
void
2551
+
devlink_trap_policer_set_req_free(struct devlink_trap_policer_set_req *req)
2552
+
{
2553
+
free(req->bus_name);
2554
+
free(req->dev_name);
2555
+
free(req);
2556
+
}
2557
+
2558
+
int devlink_trap_policer_set(struct ynl_sock *ys,
2559
+
struct devlink_trap_policer_set_req *req)
2560
+
{
2561
+
struct nlmsghdr *nlh;
2562
+
int err;
2563
+
2564
+
nlh = ynl_gemsg_start_req(ys, ys->family_id, DEVLINK_CMD_TRAP_POLICER_SET, 1);
2565
+
ys->req_policy = &devlink_nest;
2566
+
2567
+
if (req->_present.bus_name_len)
2568
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_BUS_NAME, req->bus_name);
2569
+
if (req->_present.dev_name_len)
2570
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_DEV_NAME, req->dev_name);
2571
+
if (req->_present.trap_policer_id)
2572
+
mnl_attr_put_u32(nlh, DEVLINK_ATTR_TRAP_POLICER_ID, req->trap_policer_id);
2573
+
if (req->_present.trap_policer_rate)
2574
+
mnl_attr_put_u64(nlh, DEVLINK_ATTR_TRAP_POLICER_RATE, req->trap_policer_rate);
2575
+
if (req->_present.trap_policer_burst)
2576
+
mnl_attr_put_u64(nlh, DEVLINK_ATTR_TRAP_POLICER_BURST, req->trap_policer_burst);
2577
+
2578
+
err = ynl_exec(ys, nlh, NULL);
2579
+
if (err < 0)
2580
+
return -1;
2581
+
2582
+
return 0;
2583
+
}
2584
+
2585
+
/* ============== DEVLINK_CMD_HEALTH_REPORTER_TEST ============== */
2586
+
/* DEVLINK_CMD_HEALTH_REPORTER_TEST - do */
2587
+
void
2588
+
devlink_health_reporter_test_req_free(struct devlink_health_reporter_test_req *req)
2589
+
{
2590
+
free(req->bus_name);
2591
+
free(req->dev_name);
2592
+
free(req->health_reporter_name);
2593
+
free(req);
2594
+
}
2595
+
2596
+
int devlink_health_reporter_test(struct ynl_sock *ys,
2597
+
struct devlink_health_reporter_test_req *req)
2598
+
{
2599
+
struct nlmsghdr *nlh;
2600
+
int err;
2601
+
2602
+
nlh = ynl_gemsg_start_req(ys, ys->family_id, DEVLINK_CMD_HEALTH_REPORTER_TEST, 1);
2603
+
ys->req_policy = &devlink_nest;
2604
+
2605
+
if (req->_present.bus_name_len)
2606
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_BUS_NAME, req->bus_name);
2607
+
if (req->_present.dev_name_len)
2608
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_DEV_NAME, req->dev_name);
2609
+
if (req->_present.port_index)
2610
+
mnl_attr_put_u32(nlh, DEVLINK_ATTR_PORT_INDEX, req->port_index);
2611
+
if (req->_present.health_reporter_name_len)
2612
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_HEALTH_REPORTER_NAME, req->health_reporter_name);
2613
+
2614
+
err = ynl_exec(ys, nlh, NULL);
2615
+
if (err < 0)
2616
+
return -1;
2617
+
2618
+
return 0;
6138
2619
}
6139
2620
6140
2621
/* ============== DEVLINK_CMD_RATE_GET ============== */
···
6369
2704
return NULL;
6370
2705
}
6371
2706
2707
+
/* ============== DEVLINK_CMD_RATE_SET ============== */
2708
+
/* DEVLINK_CMD_RATE_SET - do */
2709
+
void devlink_rate_set_req_free(struct devlink_rate_set_req *req)
2710
+
{
2711
+
free(req->bus_name);
2712
+
free(req->dev_name);
2713
+
free(req->rate_node_name);
2714
+
free(req->rate_parent_node_name);
2715
+
free(req);
2716
+
}
2717
+
2718
+
int devlink_rate_set(struct ynl_sock *ys, struct devlink_rate_set_req *req)
2719
+
{
2720
+
struct nlmsghdr *nlh;
2721
+
int err;
2722
+
2723
+
nlh = ynl_gemsg_start_req(ys, ys->family_id, DEVLINK_CMD_RATE_SET, 1);
2724
+
ys->req_policy = &devlink_nest;
2725
+
2726
+
if (req->_present.bus_name_len)
2727
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_BUS_NAME, req->bus_name);
2728
+
if (req->_present.dev_name_len)
2729
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_DEV_NAME, req->dev_name);
2730
+
if (req->_present.rate_node_name_len)
2731
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_RATE_NODE_NAME, req->rate_node_name);
2732
+
if (req->_present.rate_tx_share)
2733
+
mnl_attr_put_u64(nlh, DEVLINK_ATTR_RATE_TX_SHARE, req->rate_tx_share);
2734
+
if (req->_present.rate_tx_max)
2735
+
mnl_attr_put_u64(nlh, DEVLINK_ATTR_RATE_TX_MAX, req->rate_tx_max);
2736
+
if (req->_present.rate_tx_priority)
2737
+
mnl_attr_put_u32(nlh, DEVLINK_ATTR_RATE_TX_PRIORITY, req->rate_tx_priority);
2738
+
if (req->_present.rate_tx_weight)
2739
+
mnl_attr_put_u32(nlh, DEVLINK_ATTR_RATE_TX_WEIGHT, req->rate_tx_weight);
2740
+
if (req->_present.rate_parent_node_name_len)
2741
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_RATE_PARENT_NODE_NAME, req->rate_parent_node_name);
2742
+
2743
+
err = ynl_exec(ys, nlh, NULL);
2744
+
if (err < 0)
2745
+
return -1;
2746
+
2747
+
return 0;
2748
+
}
2749
+
2750
+
/* ============== DEVLINK_CMD_RATE_NEW ============== */
2751
+
/* DEVLINK_CMD_RATE_NEW - do */
2752
+
void devlink_rate_new_req_free(struct devlink_rate_new_req *req)
2753
+
{
2754
+
free(req->bus_name);
2755
+
free(req->dev_name);
2756
+
free(req->rate_node_name);
2757
+
free(req->rate_parent_node_name);
2758
+
free(req);
2759
+
}
2760
+
2761
+
int devlink_rate_new(struct ynl_sock *ys, struct devlink_rate_new_req *req)
2762
+
{
2763
+
struct nlmsghdr *nlh;
2764
+
int err;
2765
+
2766
+
nlh = ynl_gemsg_start_req(ys, ys->family_id, DEVLINK_CMD_RATE_NEW, 1);
2767
+
ys->req_policy = &devlink_nest;
2768
+
2769
+
if (req->_present.bus_name_len)
2770
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_BUS_NAME, req->bus_name);
2771
+
if (req->_present.dev_name_len)
2772
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_DEV_NAME, req->dev_name);
2773
+
if (req->_present.rate_node_name_len)
2774
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_RATE_NODE_NAME, req->rate_node_name);
2775
+
if (req->_present.rate_tx_share)
2776
+
mnl_attr_put_u64(nlh, DEVLINK_ATTR_RATE_TX_SHARE, req->rate_tx_share);
2777
+
if (req->_present.rate_tx_max)
2778
+
mnl_attr_put_u64(nlh, DEVLINK_ATTR_RATE_TX_MAX, req->rate_tx_max);
2779
+
if (req->_present.rate_tx_priority)
2780
+
mnl_attr_put_u32(nlh, DEVLINK_ATTR_RATE_TX_PRIORITY, req->rate_tx_priority);
2781
+
if (req->_present.rate_tx_weight)
2782
+
mnl_attr_put_u32(nlh, DEVLINK_ATTR_RATE_TX_WEIGHT, req->rate_tx_weight);
2783
+
if (req->_present.rate_parent_node_name_len)
2784
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_RATE_PARENT_NODE_NAME, req->rate_parent_node_name);
2785
+
2786
+
err = ynl_exec(ys, nlh, NULL);
2787
+
if (err < 0)
2788
+
return -1;
2789
+
2790
+
return 0;
2791
+
}
2792
+
2793
+
/* ============== DEVLINK_CMD_RATE_DEL ============== */
2794
+
/* DEVLINK_CMD_RATE_DEL - do */
2795
+
void devlink_rate_del_req_free(struct devlink_rate_del_req *req)
2796
+
{
2797
+
free(req->bus_name);
2798
+
free(req->dev_name);
2799
+
free(req->rate_node_name);
2800
+
free(req);
2801
+
}
2802
+
2803
+
int devlink_rate_del(struct ynl_sock *ys, struct devlink_rate_del_req *req)
2804
+
{
2805
+
struct nlmsghdr *nlh;
2806
+
int err;
2807
+
2808
+
nlh = ynl_gemsg_start_req(ys, ys->family_id, DEVLINK_CMD_RATE_DEL, 1);
2809
+
ys->req_policy = &devlink_nest;
2810
+
2811
+
if (req->_present.bus_name_len)
2812
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_BUS_NAME, req->bus_name);
2813
+
if (req->_present.dev_name_len)
2814
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_DEV_NAME, req->dev_name);
2815
+
if (req->_present.rate_node_name_len)
2816
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_RATE_NODE_NAME, req->rate_node_name);
2817
+
2818
+
err = ynl_exec(ys, nlh, NULL);
2819
+
if (err < 0)
2820
+
return -1;
2821
+
2822
+
return 0;
2823
+
}
2824
+
6372
2825
/* ============== DEVLINK_CMD_LINECARD_GET ============== */
6373
2826
/* DEVLINK_CMD_LINECARD_GET - do */
6374
2827
void devlink_linecard_get_req_free(struct devlink_linecard_get_req *req)
···
6630
2847
return NULL;
6631
2848
}
6632
2849
2850
+
/* ============== DEVLINK_CMD_LINECARD_SET ============== */
2851
+
/* DEVLINK_CMD_LINECARD_SET - do */
2852
+
void devlink_linecard_set_req_free(struct devlink_linecard_set_req *req)
2853
+
{
2854
+
free(req->bus_name);
2855
+
free(req->dev_name);
2856
+
free(req->linecard_type);
2857
+
free(req);
2858
+
}
2859
+
2860
+
int devlink_linecard_set(struct ynl_sock *ys,
2861
+
struct devlink_linecard_set_req *req)
2862
+
{
2863
+
struct nlmsghdr *nlh;
2864
+
int err;
2865
+
2866
+
nlh = ynl_gemsg_start_req(ys, ys->family_id, DEVLINK_CMD_LINECARD_SET, 1);
2867
+
ys->req_policy = &devlink_nest;
2868
+
2869
+
if (req->_present.bus_name_len)
2870
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_BUS_NAME, req->bus_name);
2871
+
if (req->_present.dev_name_len)
2872
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_DEV_NAME, req->dev_name);
2873
+
if (req->_present.linecard_index)
2874
+
mnl_attr_put_u32(nlh, DEVLINK_ATTR_LINECARD_INDEX, req->linecard_index);
2875
+
if (req->_present.linecard_type_len)
2876
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_LINECARD_TYPE, req->linecard_type);
2877
+
2878
+
err = ynl_exec(ys, nlh, NULL);
2879
+
if (err < 0)
2880
+
return -1;
2881
+
2882
+
return 0;
2883
+
}
2884
+
6633
2885
/* ============== DEVLINK_CMD_SELFTESTS_GET ============== */
6634
2886
/* DEVLINK_CMD_SELFTESTS_GET - do */
6635
2887
void devlink_selftests_get_req_free(struct devlink_selftests_get_req *req)
···
6793
2975
free_list:
6794
2976
devlink_selftests_get_list_free(yds.first);
6795
2977
return NULL;
2978
+
}
2979
+
2980
+
/* ============== DEVLINK_CMD_SELFTESTS_RUN ============== */
2981
+
/* DEVLINK_CMD_SELFTESTS_RUN - do */
2982
+
void devlink_selftests_run_req_free(struct devlink_selftests_run_req *req)
2983
+
{
2984
+
free(req->bus_name);
2985
+
free(req->dev_name);
2986
+
devlink_dl_selftest_id_free(&req->selftests);
2987
+
free(req);
2988
+
}
2989
+
2990
+
int devlink_selftests_run(struct ynl_sock *ys,
2991
+
struct devlink_selftests_run_req *req)
2992
+
{
2993
+
struct nlmsghdr *nlh;
2994
+
int err;
2995
+
2996
+
nlh = ynl_gemsg_start_req(ys, ys->family_id, DEVLINK_CMD_SELFTESTS_RUN, 1);
2997
+
ys->req_policy = &devlink_nest;
2998
+
2999
+
if (req->_present.bus_name_len)
3000
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_BUS_NAME, req->bus_name);
3001
+
if (req->_present.dev_name_len)
3002
+
mnl_attr_put_strz(nlh, DEVLINK_ATTR_DEV_NAME, req->dev_name);
3003
+
if (req->_present.selftests)
3004
+
devlink_dl_selftest_id_put(nlh, DEVLINK_ATTR_SELFTESTS, &req->selftests);
3005
+
3006
+
err = ynl_exec(ys, nlh, NULL);
3007
+
if (err < 0)
3008
+
return -1;
3009
+
3010
+
return 0;
6796
3011
}
6797
3012
6798
3013
const struct ynl_family ynl_devlink_family = {
+3266
-3
tools/net/ynl/generated/devlink-user.h
+3266
-3
tools/net/ynl/generated/devlink-user.h
···
9
9
#include <stdlib.h>
10
10
#include <string.h>
11
11
#include <linux/types.h>
12
+
#include <linux/netlink.h>
12
13
#include <linux/devlink.h>
13
14
14
15
struct ynl_sock;
···
19
18
/* Enums */
20
19
const char *devlink_op_str(int op);
21
20
const char *devlink_sb_pool_type_str(enum devlink_sb_pool_type value);
21
+
const char *devlink_port_type_str(enum devlink_port_type value);
22
+
const char *devlink_port_flavour_str(enum devlink_port_flavour value);
23
+
const char *devlink_port_fn_state_str(enum devlink_port_fn_state value);
24
+
const char *devlink_port_fn_opstate_str(enum devlink_port_fn_opstate value);
25
+
const char *devlink_port_fn_attr_cap_str(enum devlink_port_fn_attr_cap value);
26
+
const char *
27
+
devlink_sb_threshold_type_str(enum devlink_sb_threshold_type value);
28
+
const char *devlink_eswitch_mode_str(enum devlink_eswitch_mode value);
29
+
const char *
30
+
devlink_eswitch_inline_mode_str(enum devlink_eswitch_inline_mode value);
31
+
const char *
32
+
devlink_eswitch_encap_mode_str(enum devlink_eswitch_encap_mode value);
33
+
const char *devlink_dpipe_match_type_str(enum devlink_dpipe_match_type value);
34
+
const char *
35
+
devlink_dpipe_action_type_str(enum devlink_dpipe_action_type value);
36
+
const char *
37
+
devlink_dpipe_field_mapping_type_str(enum devlink_dpipe_field_mapping_type value);
38
+
const char *devlink_resource_unit_str(enum devlink_resource_unit value);
39
+
const char *devlink_reload_action_str(enum devlink_reload_action value);
40
+
const char *devlink_param_cmode_str(enum devlink_param_cmode value);
41
+
const char *devlink_flash_overwrite_str(enum devlink_flash_overwrite value);
42
+
const char *devlink_trap_action_str(enum devlink_trap_action value);
22
43
23
44
/* Common nested types */
45
+
struct devlink_dl_dpipe_match {
46
+
struct {
47
+
__u32 dpipe_match_type:1;
48
+
__u32 dpipe_header_id:1;
49
+
__u32 dpipe_header_global:1;
50
+
__u32 dpipe_header_index:1;
51
+
__u32 dpipe_field_id:1;
52
+
} _present;
53
+
54
+
enum devlink_dpipe_match_type dpipe_match_type;
55
+
__u32 dpipe_header_id;
56
+
__u8 dpipe_header_global;
57
+
__u32 dpipe_header_index;
58
+
__u32 dpipe_field_id;
59
+
};
60
+
61
+
struct devlink_dl_dpipe_match_value {
62
+
struct {
63
+
__u32 dpipe_value_len;
64
+
__u32 dpipe_value_mask_len;
65
+
__u32 dpipe_value_mapping:1;
66
+
} _present;
67
+
68
+
unsigned int n_dpipe_match;
69
+
struct devlink_dl_dpipe_match *dpipe_match;
70
+
void *dpipe_value;
71
+
void *dpipe_value_mask;
72
+
__u32 dpipe_value_mapping;
73
+
};
74
+
75
+
struct devlink_dl_dpipe_action {
76
+
struct {
77
+
__u32 dpipe_action_type:1;
78
+
__u32 dpipe_header_id:1;
79
+
__u32 dpipe_header_global:1;
80
+
__u32 dpipe_header_index:1;
81
+
__u32 dpipe_field_id:1;
82
+
} _present;
83
+
84
+
enum devlink_dpipe_action_type dpipe_action_type;
85
+
__u32 dpipe_header_id;
86
+
__u8 dpipe_header_global;
87
+
__u32 dpipe_header_index;
88
+
__u32 dpipe_field_id;
89
+
};
90
+
91
+
struct devlink_dl_dpipe_action_value {
92
+
struct {
93
+
__u32 dpipe_value_len;
94
+
__u32 dpipe_value_mask_len;
95
+
__u32 dpipe_value_mapping:1;
96
+
} _present;
97
+
98
+
unsigned int n_dpipe_action;
99
+
struct devlink_dl_dpipe_action *dpipe_action;
100
+
void *dpipe_value;
101
+
void *dpipe_value_mask;
102
+
__u32 dpipe_value_mapping;
103
+
};
104
+
105
+
struct devlink_dl_dpipe_field {
106
+
struct {
107
+
__u32 dpipe_field_name_len;
108
+
__u32 dpipe_field_id:1;
109
+
__u32 dpipe_field_bitwidth:1;
110
+
__u32 dpipe_field_mapping_type:1;
111
+
} _present;
112
+
113
+
char *dpipe_field_name;
114
+
__u32 dpipe_field_id;
115
+
__u32 dpipe_field_bitwidth;
116
+
enum devlink_dpipe_field_mapping_type dpipe_field_mapping_type;
117
+
};
118
+
119
+
struct devlink_dl_resource {
120
+
struct {
121
+
__u32 resource_name_len;
122
+
__u32 resource_id:1;
123
+
__u32 resource_size:1;
124
+
__u32 resource_size_new:1;
125
+
__u32 resource_size_valid:1;
126
+
__u32 resource_size_min:1;
127
+
__u32 resource_size_max:1;
128
+
__u32 resource_size_gran:1;
129
+
__u32 resource_unit:1;
130
+
__u32 resource_occ:1;
131
+
} _present;
132
+
133
+
char *resource_name;
134
+
__u64 resource_id;
135
+
__u64 resource_size;
136
+
__u64 resource_size_new;
137
+
__u8 resource_size_valid;
138
+
__u64 resource_size_min;
139
+
__u64 resource_size_max;
140
+
__u64 resource_size_gran;
141
+
enum devlink_resource_unit resource_unit;
142
+
__u64 resource_occ;
143
+
};
144
+
24
145
struct devlink_dl_info_version {
25
146
struct {
26
147
__u32 info_version_name_len;
···
151
28
152
29
char *info_version_name;
153
30
char *info_version_value;
31
+
};
32
+
33
+
struct devlink_dl_fmsg {
34
+
struct {
35
+
__u32 fmsg_obj_nest_start:1;
36
+
__u32 fmsg_pair_nest_start:1;
37
+
__u32 fmsg_arr_nest_start:1;
38
+
__u32 fmsg_nest_end:1;
39
+
__u32 fmsg_obj_name_len;
40
+
} _present;
41
+
42
+
char *fmsg_obj_name;
43
+
};
44
+
45
+
struct devlink_dl_port_function {
46
+
struct {
47
+
__u32 hw_addr_len;
48
+
__u32 state:1;
49
+
__u32 opstate:1;
50
+
__u32 caps:1;
51
+
} _present;
52
+
53
+
void *hw_addr;
54
+
enum devlink_port_fn_state state;
55
+
enum devlink_port_fn_opstate opstate;
56
+
struct nla_bitfield32 caps;
154
57
};
155
58
156
59
struct devlink_dl_reload_stats_entry {
···
194
45
struct devlink_dl_reload_stats_entry *reload_stats_entry;
195
46
};
196
47
48
+
struct devlink_dl_selftest_id {
49
+
struct {
50
+
__u32 flash:1;
51
+
} _present;
52
+
};
53
+
54
+
struct devlink_dl_dpipe_table_matches {
55
+
unsigned int n_dpipe_match;
56
+
struct devlink_dl_dpipe_match *dpipe_match;
57
+
};
58
+
59
+
struct devlink_dl_dpipe_table_actions {
60
+
unsigned int n_dpipe_action;
61
+
struct devlink_dl_dpipe_action *dpipe_action;
62
+
};
63
+
64
+
struct devlink_dl_dpipe_entry_match_values {
65
+
unsigned int n_dpipe_match_value;
66
+
struct devlink_dl_dpipe_match_value *dpipe_match_value;
67
+
};
68
+
69
+
struct devlink_dl_dpipe_entry_action_values {
70
+
unsigned int n_dpipe_action_value;
71
+
struct devlink_dl_dpipe_action_value *dpipe_action_value;
72
+
};
73
+
74
+
struct devlink_dl_dpipe_header_fields {
75
+
unsigned int n_dpipe_field;
76
+
struct devlink_dl_dpipe_field *dpipe_field;
77
+
};
78
+
79
+
struct devlink_dl_resource_list {
80
+
unsigned int n_resource;
81
+
struct devlink_dl_resource *resource;
82
+
};
83
+
197
84
struct devlink_dl_reload_act_info {
198
85
struct {
199
86
__u32 reload_action:1;
200
87
} _present;
201
88
202
-
__u8 reload_action;
89
+
enum devlink_reload_action reload_action;
203
90
unsigned int n_reload_action_stats;
204
91
struct devlink_dl_reload_act_stats *reload_action_stats;
92
+
};
93
+
94
+
struct devlink_dl_dpipe_table {
95
+
struct {
96
+
__u32 dpipe_table_name_len;
97
+
__u32 dpipe_table_size:1;
98
+
__u32 dpipe_table_matches:1;
99
+
__u32 dpipe_table_actions:1;
100
+
__u32 dpipe_table_counters_enabled:1;
101
+
__u32 dpipe_table_resource_id:1;
102
+
__u32 dpipe_table_resource_units:1;
103
+
} _present;
104
+
105
+
char *dpipe_table_name;
106
+
__u64 dpipe_table_size;
107
+
struct devlink_dl_dpipe_table_matches dpipe_table_matches;
108
+
struct devlink_dl_dpipe_table_actions dpipe_table_actions;
109
+
__u8 dpipe_table_counters_enabled;
110
+
__u64 dpipe_table_resource_id;
111
+
__u64 dpipe_table_resource_units;
112
+
};
113
+
114
+
struct devlink_dl_dpipe_entry {
115
+
struct {
116
+
__u32 dpipe_entry_index:1;
117
+
__u32 dpipe_entry_match_values:1;
118
+
__u32 dpipe_entry_action_values:1;
119
+
__u32 dpipe_entry_counter:1;
120
+
} _present;
121
+
122
+
__u64 dpipe_entry_index;
123
+
struct devlink_dl_dpipe_entry_match_values dpipe_entry_match_values;
124
+
struct devlink_dl_dpipe_entry_action_values dpipe_entry_action_values;
125
+
__u64 dpipe_entry_counter;
126
+
};
127
+
128
+
struct devlink_dl_dpipe_header {
129
+
struct {
130
+
__u32 dpipe_header_name_len;
131
+
__u32 dpipe_header_id:1;
132
+
__u32 dpipe_header_global:1;
133
+
__u32 dpipe_header_fields:1;
134
+
} _present;
135
+
136
+
char *dpipe_header_name;
137
+
__u32 dpipe_header_id;
138
+
__u8 dpipe_header_global;
139
+
struct devlink_dl_dpipe_header_fields dpipe_header_fields;
205
140
};
206
141
207
142
struct devlink_dl_reload_stats {
208
143
unsigned int n_reload_action_info;
209
144
struct devlink_dl_reload_act_info *reload_action_info;
145
+
};
146
+
147
+
struct devlink_dl_dpipe_tables {
148
+
unsigned int n_dpipe_table;
149
+
struct devlink_dl_dpipe_table *dpipe_table;
150
+
};
151
+
152
+
struct devlink_dl_dpipe_entries {
153
+
unsigned int n_dpipe_entry;
154
+
struct devlink_dl_dpipe_entry *dpipe_entry;
155
+
};
156
+
157
+
struct devlink_dl_dpipe_headers {
158
+
unsigned int n_dpipe_header;
159
+
struct devlink_dl_dpipe_header *dpipe_header;
210
160
};
211
161
212
162
struct devlink_dl_dev_stats {
···
360
112
__u32 bus_name_len;
361
113
__u32 dev_name_len;
362
114
__u32 reload_failed:1;
363
-
__u32 reload_action:1;
364
115
__u32 dev_stats:1;
365
116
} _present;
366
117
367
118
char *bus_name;
368
119
char *dev_name;
369
120
__u8 reload_failed;
370
-
__u8 reload_action;
371
121
struct devlink_dl_dev_stats dev_stats;
372
122
};
373
123
···
516
270
struct devlink_port_get_rsp_list *
517
271
devlink_port_get_dump(struct ynl_sock *ys,
518
272
struct devlink_port_get_req_dump *req);
273
+
274
+
/* ============== DEVLINK_CMD_PORT_SET ============== */
275
+
/* DEVLINK_CMD_PORT_SET - do */
276
+
struct devlink_port_set_req {
277
+
struct {
278
+
__u32 bus_name_len;
279
+
__u32 dev_name_len;
280
+
__u32 port_index:1;
281
+
__u32 port_type:1;
282
+
__u32 port_function:1;
283
+
} _present;
284
+
285
+
char *bus_name;
286
+
char *dev_name;
287
+
__u32 port_index;
288
+
enum devlink_port_type port_type;
289
+
struct devlink_dl_port_function port_function;
290
+
};
291
+
292
+
static inline struct devlink_port_set_req *devlink_port_set_req_alloc(void)
293
+
{
294
+
return calloc(1, sizeof(struct devlink_port_set_req));
295
+
}
296
+
void devlink_port_set_req_free(struct devlink_port_set_req *req);
297
+
298
+
static inline void
299
+
devlink_port_set_req_set_bus_name(struct devlink_port_set_req *req,
300
+
const char *bus_name)
301
+
{
302
+
free(req->bus_name);
303
+
req->_present.bus_name_len = strlen(bus_name);
304
+
req->bus_name = malloc(req->_present.bus_name_len + 1);
305
+
memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
306
+
req->bus_name[req->_present.bus_name_len] = 0;
307
+
}
308
+
static inline void
309
+
devlink_port_set_req_set_dev_name(struct devlink_port_set_req *req,
310
+
const char *dev_name)
311
+
{
312
+
free(req->dev_name);
313
+
req->_present.dev_name_len = strlen(dev_name);
314
+
req->dev_name = malloc(req->_present.dev_name_len + 1);
315
+
memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
316
+
req->dev_name[req->_present.dev_name_len] = 0;
317
+
}
318
+
static inline void
319
+
devlink_port_set_req_set_port_index(struct devlink_port_set_req *req,
320
+
__u32 port_index)
321
+
{
322
+
req->_present.port_index = 1;
323
+
req->port_index = port_index;
324
+
}
325
+
static inline void
326
+
devlink_port_set_req_set_port_type(struct devlink_port_set_req *req,
327
+
enum devlink_port_type port_type)
328
+
{
329
+
req->_present.port_type = 1;
330
+
req->port_type = port_type;
331
+
}
332
+
static inline void
333
+
devlink_port_set_req_set_port_function_hw_addr(struct devlink_port_set_req *req,
334
+
const void *hw_addr, size_t len)
335
+
{
336
+
free(req->port_function.hw_addr);
337
+
req->port_function._present.hw_addr_len = len;
338
+
req->port_function.hw_addr = malloc(req->port_function._present.hw_addr_len);
339
+
memcpy(req->port_function.hw_addr, hw_addr, req->port_function._present.hw_addr_len);
340
+
}
341
+
static inline void
342
+
devlink_port_set_req_set_port_function_state(struct devlink_port_set_req *req,
343
+
enum devlink_port_fn_state state)
344
+
{
345
+
req->_present.port_function = 1;
346
+
req->port_function._present.state = 1;
347
+
req->port_function.state = state;
348
+
}
349
+
static inline void
350
+
devlink_port_set_req_set_port_function_opstate(struct devlink_port_set_req *req,
351
+
enum devlink_port_fn_opstate opstate)
352
+
{
353
+
req->_present.port_function = 1;
354
+
req->port_function._present.opstate = 1;
355
+
req->port_function.opstate = opstate;
356
+
}
357
+
static inline void
358
+
devlink_port_set_req_set_port_function_caps(struct devlink_port_set_req *req,
359
+
struct nla_bitfield32 *caps)
360
+
{
361
+
req->_present.port_function = 1;
362
+
req->port_function._present.caps = 1;
363
+
memcpy(&req->port_function.caps, caps, sizeof(struct nla_bitfield32));
364
+
}
365
+
366
+
/*
367
+
* Set devlink port instances.
368
+
*/
369
+
int devlink_port_set(struct ynl_sock *ys, struct devlink_port_set_req *req);
370
+
371
+
/* ============== DEVLINK_CMD_PORT_NEW ============== */
372
+
/* DEVLINK_CMD_PORT_NEW - do */
373
+
struct devlink_port_new_req {
374
+
struct {
375
+
__u32 bus_name_len;
376
+
__u32 dev_name_len;
377
+
__u32 port_index:1;
378
+
__u32 port_flavour:1;
379
+
__u32 port_pci_pf_number:1;
380
+
__u32 port_pci_sf_number:1;
381
+
__u32 port_controller_number:1;
382
+
} _present;
383
+
384
+
char *bus_name;
385
+
char *dev_name;
386
+
__u32 port_index;
387
+
enum devlink_port_flavour port_flavour;
388
+
__u16 port_pci_pf_number;
389
+
__u32 port_pci_sf_number;
390
+
__u32 port_controller_number;
391
+
};
392
+
393
+
static inline struct devlink_port_new_req *devlink_port_new_req_alloc(void)
394
+
{
395
+
return calloc(1, sizeof(struct devlink_port_new_req));
396
+
}
397
+
void devlink_port_new_req_free(struct devlink_port_new_req *req);
398
+
399
+
static inline void
400
+
devlink_port_new_req_set_bus_name(struct devlink_port_new_req *req,
401
+
const char *bus_name)
402
+
{
403
+
free(req->bus_name);
404
+
req->_present.bus_name_len = strlen(bus_name);
405
+
req->bus_name = malloc(req->_present.bus_name_len + 1);
406
+
memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
407
+
req->bus_name[req->_present.bus_name_len] = 0;
408
+
}
409
+
static inline void
410
+
devlink_port_new_req_set_dev_name(struct devlink_port_new_req *req,
411
+
const char *dev_name)
412
+
{
413
+
free(req->dev_name);
414
+
req->_present.dev_name_len = strlen(dev_name);
415
+
req->dev_name = malloc(req->_present.dev_name_len + 1);
416
+
memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
417
+
req->dev_name[req->_present.dev_name_len] = 0;
418
+
}
419
+
static inline void
420
+
devlink_port_new_req_set_port_index(struct devlink_port_new_req *req,
421
+
__u32 port_index)
422
+
{
423
+
req->_present.port_index = 1;
424
+
req->port_index = port_index;
425
+
}
426
+
static inline void
427
+
devlink_port_new_req_set_port_flavour(struct devlink_port_new_req *req,
428
+
enum devlink_port_flavour port_flavour)
429
+
{
430
+
req->_present.port_flavour = 1;
431
+
req->port_flavour = port_flavour;
432
+
}
433
+
static inline void
434
+
devlink_port_new_req_set_port_pci_pf_number(struct devlink_port_new_req *req,
435
+
__u16 port_pci_pf_number)
436
+
{
437
+
req->_present.port_pci_pf_number = 1;
438
+
req->port_pci_pf_number = port_pci_pf_number;
439
+
}
440
+
static inline void
441
+
devlink_port_new_req_set_port_pci_sf_number(struct devlink_port_new_req *req,
442
+
__u32 port_pci_sf_number)
443
+
{
444
+
req->_present.port_pci_sf_number = 1;
445
+
req->port_pci_sf_number = port_pci_sf_number;
446
+
}
447
+
static inline void
448
+
devlink_port_new_req_set_port_controller_number(struct devlink_port_new_req *req,
449
+
__u32 port_controller_number)
450
+
{
451
+
req->_present.port_controller_number = 1;
452
+
req->port_controller_number = port_controller_number;
453
+
}
454
+
455
+
struct devlink_port_new_rsp {
456
+
struct {
457
+
__u32 bus_name_len;
458
+
__u32 dev_name_len;
459
+
__u32 port_index:1;
460
+
} _present;
461
+
462
+
char *bus_name;
463
+
char *dev_name;
464
+
__u32 port_index;
465
+
};
466
+
467
+
void devlink_port_new_rsp_free(struct devlink_port_new_rsp *rsp);
468
+
469
+
/*
470
+
* Create devlink port instances.
471
+
*/
472
+
struct devlink_port_new_rsp *
473
+
devlink_port_new(struct ynl_sock *ys, struct devlink_port_new_req *req);
474
+
475
+
/* ============== DEVLINK_CMD_PORT_DEL ============== */
476
+
/* DEVLINK_CMD_PORT_DEL - do */
477
+
struct devlink_port_del_req {
478
+
struct {
479
+
__u32 bus_name_len;
480
+
__u32 dev_name_len;
481
+
__u32 port_index:1;
482
+
} _present;
483
+
484
+
char *bus_name;
485
+
char *dev_name;
486
+
__u32 port_index;
487
+
};
488
+
489
+
static inline struct devlink_port_del_req *devlink_port_del_req_alloc(void)
490
+
{
491
+
return calloc(1, sizeof(struct devlink_port_del_req));
492
+
}
493
+
void devlink_port_del_req_free(struct devlink_port_del_req *req);
494
+
495
+
static inline void
496
+
devlink_port_del_req_set_bus_name(struct devlink_port_del_req *req,
497
+
const char *bus_name)
498
+
{
499
+
free(req->bus_name);
500
+
req->_present.bus_name_len = strlen(bus_name);
501
+
req->bus_name = malloc(req->_present.bus_name_len + 1);
502
+
memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
503
+
req->bus_name[req->_present.bus_name_len] = 0;
504
+
}
505
+
static inline void
506
+
devlink_port_del_req_set_dev_name(struct devlink_port_del_req *req,
507
+
const char *dev_name)
508
+
{
509
+
free(req->dev_name);
510
+
req->_present.dev_name_len = strlen(dev_name);
511
+
req->dev_name = malloc(req->_present.dev_name_len + 1);
512
+
memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
513
+
req->dev_name[req->_present.dev_name_len] = 0;
514
+
}
515
+
static inline void
516
+
devlink_port_del_req_set_port_index(struct devlink_port_del_req *req,
517
+
__u32 port_index)
518
+
{
519
+
req->_present.port_index = 1;
520
+
req->port_index = port_index;
521
+
}
522
+
523
+
/*
524
+
* Delete devlink port instances.
525
+
*/
526
+
int devlink_port_del(struct ynl_sock *ys, struct devlink_port_del_req *req);
527
+
528
+
/* ============== DEVLINK_CMD_PORT_SPLIT ============== */
529
+
/* DEVLINK_CMD_PORT_SPLIT - do */
530
+
struct devlink_port_split_req {
531
+
struct {
532
+
__u32 bus_name_len;
533
+
__u32 dev_name_len;
534
+
__u32 port_index:1;
535
+
__u32 port_split_count:1;
536
+
} _present;
537
+
538
+
char *bus_name;
539
+
char *dev_name;
540
+
__u32 port_index;
541
+
__u32 port_split_count;
542
+
};
543
+
544
+
static inline struct devlink_port_split_req *devlink_port_split_req_alloc(void)
545
+
{
546
+
return calloc(1, sizeof(struct devlink_port_split_req));
547
+
}
548
+
void devlink_port_split_req_free(struct devlink_port_split_req *req);
549
+
550
+
static inline void
551
+
devlink_port_split_req_set_bus_name(struct devlink_port_split_req *req,
552
+
const char *bus_name)
553
+
{
554
+
free(req->bus_name);
555
+
req->_present.bus_name_len = strlen(bus_name);
556
+
req->bus_name = malloc(req->_present.bus_name_len + 1);
557
+
memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
558
+
req->bus_name[req->_present.bus_name_len] = 0;
559
+
}
560
+
static inline void
561
+
devlink_port_split_req_set_dev_name(struct devlink_port_split_req *req,
562
+
const char *dev_name)
563
+
{
564
+
free(req->dev_name);
565
+
req->_present.dev_name_len = strlen(dev_name);
566
+
req->dev_name = malloc(req->_present.dev_name_len + 1);
567
+
memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
568
+
req->dev_name[req->_present.dev_name_len] = 0;
569
+
}
570
+
static inline void
571
+
devlink_port_split_req_set_port_index(struct devlink_port_split_req *req,
572
+
__u32 port_index)
573
+
{
574
+
req->_present.port_index = 1;
575
+
req->port_index = port_index;
576
+
}
577
+
static inline void
578
+
devlink_port_split_req_set_port_split_count(struct devlink_port_split_req *req,
579
+
__u32 port_split_count)
580
+
{
581
+
req->_present.port_split_count = 1;
582
+
req->port_split_count = port_split_count;
583
+
}
584
+
585
+
/*
586
+
* Split devlink port instances.
587
+
*/
588
+
int devlink_port_split(struct ynl_sock *ys, struct devlink_port_split_req *req);
589
+
590
+
/* ============== DEVLINK_CMD_PORT_UNSPLIT ============== */
591
+
/* DEVLINK_CMD_PORT_UNSPLIT - do */
592
+
struct devlink_port_unsplit_req {
593
+
struct {
594
+
__u32 bus_name_len;
595
+
__u32 dev_name_len;
596
+
__u32 port_index:1;
597
+
} _present;
598
+
599
+
char *bus_name;
600
+
char *dev_name;
601
+
__u32 port_index;
602
+
};
603
+
604
+
static inline struct devlink_port_unsplit_req *
605
+
devlink_port_unsplit_req_alloc(void)
606
+
{
607
+
return calloc(1, sizeof(struct devlink_port_unsplit_req));
608
+
}
609
+
void devlink_port_unsplit_req_free(struct devlink_port_unsplit_req *req);
610
+
611
+
static inline void
612
+
devlink_port_unsplit_req_set_bus_name(struct devlink_port_unsplit_req *req,
613
+
const char *bus_name)
614
+
{
615
+
free(req->bus_name);
616
+
req->_present.bus_name_len = strlen(bus_name);
617
+
req->bus_name = malloc(req->_present.bus_name_len + 1);
618
+
memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
619
+
req->bus_name[req->_present.bus_name_len] = 0;
620
+
}
621
+
static inline void
622
+
devlink_port_unsplit_req_set_dev_name(struct devlink_port_unsplit_req *req,
623
+
const char *dev_name)
624
+
{
625
+
free(req->dev_name);
626
+
req->_present.dev_name_len = strlen(dev_name);
627
+
req->dev_name = malloc(req->_present.dev_name_len + 1);
628
+
memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
629
+
req->dev_name[req->_present.dev_name_len] = 0;
630
+
}
631
+
static inline void
632
+
devlink_port_unsplit_req_set_port_index(struct devlink_port_unsplit_req *req,
633
+
__u32 port_index)
634
+
{
635
+
req->_present.port_index = 1;
636
+
req->port_index = port_index;
637
+
}
638
+
639
+
/*
640
+
* Unplit devlink port instances.
641
+
*/
642
+
int devlink_port_unsplit(struct ynl_sock *ys,
643
+
struct devlink_port_unsplit_req *req);
519
644
520
645
/* ============== DEVLINK_CMD_SB_GET ============== */
521
646
/* DEVLINK_CMD_SB_GET - do */
···
1135
518
devlink_sb_pool_get_dump(struct ynl_sock *ys,
1136
519
struct devlink_sb_pool_get_req_dump *req);
1137
520
521
+
/* ============== DEVLINK_CMD_SB_POOL_SET ============== */
522
+
/* DEVLINK_CMD_SB_POOL_SET - do */
523
+
struct devlink_sb_pool_set_req {
524
+
struct {
525
+
__u32 bus_name_len;
526
+
__u32 dev_name_len;
527
+
__u32 sb_index:1;
528
+
__u32 sb_pool_index:1;
529
+
__u32 sb_pool_threshold_type:1;
530
+
__u32 sb_pool_size:1;
531
+
} _present;
532
+
533
+
char *bus_name;
534
+
char *dev_name;
535
+
__u32 sb_index;
536
+
__u16 sb_pool_index;
537
+
enum devlink_sb_threshold_type sb_pool_threshold_type;
538
+
__u32 sb_pool_size;
539
+
};
540
+
541
+
static inline struct devlink_sb_pool_set_req *
542
+
devlink_sb_pool_set_req_alloc(void)
543
+
{
544
+
return calloc(1, sizeof(struct devlink_sb_pool_set_req));
545
+
}
546
+
void devlink_sb_pool_set_req_free(struct devlink_sb_pool_set_req *req);
547
+
548
+
static inline void
549
+
devlink_sb_pool_set_req_set_bus_name(struct devlink_sb_pool_set_req *req,
550
+
const char *bus_name)
551
+
{
552
+
free(req->bus_name);
553
+
req->_present.bus_name_len = strlen(bus_name);
554
+
req->bus_name = malloc(req->_present.bus_name_len + 1);
555
+
memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
556
+
req->bus_name[req->_present.bus_name_len] = 0;
557
+
}
558
+
static inline void
559
+
devlink_sb_pool_set_req_set_dev_name(struct devlink_sb_pool_set_req *req,
560
+
const char *dev_name)
561
+
{
562
+
free(req->dev_name);
563
+
req->_present.dev_name_len = strlen(dev_name);
564
+
req->dev_name = malloc(req->_present.dev_name_len + 1);
565
+
memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
566
+
req->dev_name[req->_present.dev_name_len] = 0;
567
+
}
568
+
static inline void
569
+
devlink_sb_pool_set_req_set_sb_index(struct devlink_sb_pool_set_req *req,
570
+
__u32 sb_index)
571
+
{
572
+
req->_present.sb_index = 1;
573
+
req->sb_index = sb_index;
574
+
}
575
+
static inline void
576
+
devlink_sb_pool_set_req_set_sb_pool_index(struct devlink_sb_pool_set_req *req,
577
+
__u16 sb_pool_index)
578
+
{
579
+
req->_present.sb_pool_index = 1;
580
+
req->sb_pool_index = sb_pool_index;
581
+
}
582
+
static inline void
583
+
devlink_sb_pool_set_req_set_sb_pool_threshold_type(struct devlink_sb_pool_set_req *req,
584
+
enum devlink_sb_threshold_type sb_pool_threshold_type)
585
+
{
586
+
req->_present.sb_pool_threshold_type = 1;
587
+
req->sb_pool_threshold_type = sb_pool_threshold_type;
588
+
}
589
+
static inline void
590
+
devlink_sb_pool_set_req_set_sb_pool_size(struct devlink_sb_pool_set_req *req,
591
+
__u32 sb_pool_size)
592
+
{
593
+
req->_present.sb_pool_size = 1;
594
+
req->sb_pool_size = sb_pool_size;
595
+
}
596
+
597
+
/*
598
+
* Set shared buffer pool instances.
599
+
*/
600
+
int devlink_sb_pool_set(struct ynl_sock *ys,
601
+
struct devlink_sb_pool_set_req *req);
602
+
1138
603
/* ============== DEVLINK_CMD_SB_PORT_POOL_GET ============== */
1139
604
/* DEVLINK_CMD_SB_PORT_POOL_GET - do */
1140
605
struct devlink_sb_port_pool_get_req {
···
1362
663
struct devlink_sb_port_pool_get_list *
1363
664
devlink_sb_port_pool_get_dump(struct ynl_sock *ys,
1364
665
struct devlink_sb_port_pool_get_req_dump *req);
666
+
667
+
/* ============== DEVLINK_CMD_SB_PORT_POOL_SET ============== */
668
+
/* DEVLINK_CMD_SB_PORT_POOL_SET - do */
669
+
struct devlink_sb_port_pool_set_req {
670
+
struct {
671
+
__u32 bus_name_len;
672
+
__u32 dev_name_len;
673
+
__u32 port_index:1;
674
+
__u32 sb_index:1;
675
+
__u32 sb_pool_index:1;
676
+
__u32 sb_threshold:1;
677
+
} _present;
678
+
679
+
char *bus_name;
680
+
char *dev_name;
681
+
__u32 port_index;
682
+
__u32 sb_index;
683
+
__u16 sb_pool_index;
684
+
__u32 sb_threshold;
685
+
};
686
+
687
+
static inline struct devlink_sb_port_pool_set_req *
688
+
devlink_sb_port_pool_set_req_alloc(void)
689
+
{
690
+
return calloc(1, sizeof(struct devlink_sb_port_pool_set_req));
691
+
}
692
+
void
693
+
devlink_sb_port_pool_set_req_free(struct devlink_sb_port_pool_set_req *req);
694
+
695
+
static inline void
696
+
devlink_sb_port_pool_set_req_set_bus_name(struct devlink_sb_port_pool_set_req *req,
697
+
const char *bus_name)
698
+
{
699
+
free(req->bus_name);
700
+
req->_present.bus_name_len = strlen(bus_name);
701
+
req->bus_name = malloc(req->_present.bus_name_len + 1);
702
+
memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
703
+
req->bus_name[req->_present.bus_name_len] = 0;
704
+
}
705
+
static inline void
706
+
devlink_sb_port_pool_set_req_set_dev_name(struct devlink_sb_port_pool_set_req *req,
707
+
const char *dev_name)
708
+
{
709
+
free(req->dev_name);
710
+
req->_present.dev_name_len = strlen(dev_name);
711
+
req->dev_name = malloc(req->_present.dev_name_len + 1);
712
+
memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
713
+
req->dev_name[req->_present.dev_name_len] = 0;
714
+
}
715
+
static inline void
716
+
devlink_sb_port_pool_set_req_set_port_index(struct devlink_sb_port_pool_set_req *req,
717
+
__u32 port_index)
718
+
{
719
+
req->_present.port_index = 1;
720
+
req->port_index = port_index;
721
+
}
722
+
static inline void
723
+
devlink_sb_port_pool_set_req_set_sb_index(struct devlink_sb_port_pool_set_req *req,
724
+
__u32 sb_index)
725
+
{
726
+
req->_present.sb_index = 1;
727
+
req->sb_index = sb_index;
728
+
}
729
+
static inline void
730
+
devlink_sb_port_pool_set_req_set_sb_pool_index(struct devlink_sb_port_pool_set_req *req,
731
+
__u16 sb_pool_index)
732
+
{
733
+
req->_present.sb_pool_index = 1;
734
+
req->sb_pool_index = sb_pool_index;
735
+
}
736
+
static inline void
737
+
devlink_sb_port_pool_set_req_set_sb_threshold(struct devlink_sb_port_pool_set_req *req,
738
+
__u32 sb_threshold)
739
+
{
740
+
req->_present.sb_threshold = 1;
741
+
req->sb_threshold = sb_threshold;
742
+
}
743
+
744
+
/*
745
+
* Set shared buffer port-pool combinations and threshold.
746
+
*/
747
+
int devlink_sb_port_pool_set(struct ynl_sock *ys,
748
+
struct devlink_sb_port_pool_set_req *req);
1365
749
1366
750
/* ============== DEVLINK_CMD_SB_TC_POOL_BIND_GET ============== */
1367
751
/* DEVLINK_CMD_SB_TC_POOL_BIND_GET - do */
···
1603
821
devlink_sb_tc_pool_bind_get_dump(struct ynl_sock *ys,
1604
822
struct devlink_sb_tc_pool_bind_get_req_dump *req);
1605
823
824
+
/* ============== DEVLINK_CMD_SB_TC_POOL_BIND_SET ============== */
825
+
/* DEVLINK_CMD_SB_TC_POOL_BIND_SET - do */
826
+
struct devlink_sb_tc_pool_bind_set_req {
827
+
struct {
828
+
__u32 bus_name_len;
829
+
__u32 dev_name_len;
830
+
__u32 port_index:1;
831
+
__u32 sb_index:1;
832
+
__u32 sb_pool_index:1;
833
+
__u32 sb_pool_type:1;
834
+
__u32 sb_tc_index:1;
835
+
__u32 sb_threshold:1;
836
+
} _present;
837
+
838
+
char *bus_name;
839
+
char *dev_name;
840
+
__u32 port_index;
841
+
__u32 sb_index;
842
+
__u16 sb_pool_index;
843
+
enum devlink_sb_pool_type sb_pool_type;
844
+
__u16 sb_tc_index;
845
+
__u32 sb_threshold;
846
+
};
847
+
848
+
static inline struct devlink_sb_tc_pool_bind_set_req *
849
+
devlink_sb_tc_pool_bind_set_req_alloc(void)
850
+
{
851
+
return calloc(1, sizeof(struct devlink_sb_tc_pool_bind_set_req));
852
+
}
853
+
void
854
+
devlink_sb_tc_pool_bind_set_req_free(struct devlink_sb_tc_pool_bind_set_req *req);
855
+
856
+
static inline void
857
+
devlink_sb_tc_pool_bind_set_req_set_bus_name(struct devlink_sb_tc_pool_bind_set_req *req,
858
+
const char *bus_name)
859
+
{
860
+
free(req->bus_name);
861
+
req->_present.bus_name_len = strlen(bus_name);
862
+
req->bus_name = malloc(req->_present.bus_name_len + 1);
863
+
memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
864
+
req->bus_name[req->_present.bus_name_len] = 0;
865
+
}
866
+
static inline void
867
+
devlink_sb_tc_pool_bind_set_req_set_dev_name(struct devlink_sb_tc_pool_bind_set_req *req,
868
+
const char *dev_name)
869
+
{
870
+
free(req->dev_name);
871
+
req->_present.dev_name_len = strlen(dev_name);
872
+
req->dev_name = malloc(req->_present.dev_name_len + 1);
873
+
memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
874
+
req->dev_name[req->_present.dev_name_len] = 0;
875
+
}
876
+
static inline void
877
+
devlink_sb_tc_pool_bind_set_req_set_port_index(struct devlink_sb_tc_pool_bind_set_req *req,
878
+
__u32 port_index)
879
+
{
880
+
req->_present.port_index = 1;
881
+
req->port_index = port_index;
882
+
}
883
+
static inline void
884
+
devlink_sb_tc_pool_bind_set_req_set_sb_index(struct devlink_sb_tc_pool_bind_set_req *req,
885
+
__u32 sb_index)
886
+
{
887
+
req->_present.sb_index = 1;
888
+
req->sb_index = sb_index;
889
+
}
890
+
static inline void
891
+
devlink_sb_tc_pool_bind_set_req_set_sb_pool_index(struct devlink_sb_tc_pool_bind_set_req *req,
892
+
__u16 sb_pool_index)
893
+
{
894
+
req->_present.sb_pool_index = 1;
895
+
req->sb_pool_index = sb_pool_index;
896
+
}
897
+
static inline void
898
+
devlink_sb_tc_pool_bind_set_req_set_sb_pool_type(struct devlink_sb_tc_pool_bind_set_req *req,
899
+
enum devlink_sb_pool_type sb_pool_type)
900
+
{
901
+
req->_present.sb_pool_type = 1;
902
+
req->sb_pool_type = sb_pool_type;
903
+
}
904
+
static inline void
905
+
devlink_sb_tc_pool_bind_set_req_set_sb_tc_index(struct devlink_sb_tc_pool_bind_set_req *req,
906
+
__u16 sb_tc_index)
907
+
{
908
+
req->_present.sb_tc_index = 1;
909
+
req->sb_tc_index = sb_tc_index;
910
+
}
911
+
static inline void
912
+
devlink_sb_tc_pool_bind_set_req_set_sb_threshold(struct devlink_sb_tc_pool_bind_set_req *req,
913
+
__u32 sb_threshold)
914
+
{
915
+
req->_present.sb_threshold = 1;
916
+
req->sb_threshold = sb_threshold;
917
+
}
918
+
919
+
/*
920
+
* Set shared buffer port-TC to pool bindings and threshold.
921
+
*/
922
+
int devlink_sb_tc_pool_bind_set(struct ynl_sock *ys,
923
+
struct devlink_sb_tc_pool_bind_set_req *req);
924
+
925
+
/* ============== DEVLINK_CMD_SB_OCC_SNAPSHOT ============== */
926
+
/* DEVLINK_CMD_SB_OCC_SNAPSHOT - do */
927
+
struct devlink_sb_occ_snapshot_req {
928
+
struct {
929
+
__u32 bus_name_len;
930
+
__u32 dev_name_len;
931
+
__u32 sb_index:1;
932
+
} _present;
933
+
934
+
char *bus_name;
935
+
char *dev_name;
936
+
__u32 sb_index;
937
+
};
938
+
939
+
static inline struct devlink_sb_occ_snapshot_req *
940
+
devlink_sb_occ_snapshot_req_alloc(void)
941
+
{
942
+
return calloc(1, sizeof(struct devlink_sb_occ_snapshot_req));
943
+
}
944
+
void devlink_sb_occ_snapshot_req_free(struct devlink_sb_occ_snapshot_req *req);
945
+
946
+
static inline void
947
+
devlink_sb_occ_snapshot_req_set_bus_name(struct devlink_sb_occ_snapshot_req *req,
948
+
const char *bus_name)
949
+
{
950
+
free(req->bus_name);
951
+
req->_present.bus_name_len = strlen(bus_name);
952
+
req->bus_name = malloc(req->_present.bus_name_len + 1);
953
+
memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
954
+
req->bus_name[req->_present.bus_name_len] = 0;
955
+
}
956
+
static inline void
957
+
devlink_sb_occ_snapshot_req_set_dev_name(struct devlink_sb_occ_snapshot_req *req,
958
+
const char *dev_name)
959
+
{
960
+
free(req->dev_name);
961
+
req->_present.dev_name_len = strlen(dev_name);
962
+
req->dev_name = malloc(req->_present.dev_name_len + 1);
963
+
memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
964
+
req->dev_name[req->_present.dev_name_len] = 0;
965
+
}
966
+
static inline void
967
+
devlink_sb_occ_snapshot_req_set_sb_index(struct devlink_sb_occ_snapshot_req *req,
968
+
__u32 sb_index)
969
+
{
970
+
req->_present.sb_index = 1;
971
+
req->sb_index = sb_index;
972
+
}
973
+
974
+
/*
975
+
* Take occupancy snapshot of shared buffer.
976
+
*/
977
+
int devlink_sb_occ_snapshot(struct ynl_sock *ys,
978
+
struct devlink_sb_occ_snapshot_req *req);
979
+
980
+
/* ============== DEVLINK_CMD_SB_OCC_MAX_CLEAR ============== */
981
+
/* DEVLINK_CMD_SB_OCC_MAX_CLEAR - do */
982
+
struct devlink_sb_occ_max_clear_req {
983
+
struct {
984
+
__u32 bus_name_len;
985
+
__u32 dev_name_len;
986
+
__u32 sb_index:1;
987
+
} _present;
988
+
989
+
char *bus_name;
990
+
char *dev_name;
991
+
__u32 sb_index;
992
+
};
993
+
994
+
static inline struct devlink_sb_occ_max_clear_req *
995
+
devlink_sb_occ_max_clear_req_alloc(void)
996
+
{
997
+
return calloc(1, sizeof(struct devlink_sb_occ_max_clear_req));
998
+
}
999
+
void
1000
+
devlink_sb_occ_max_clear_req_free(struct devlink_sb_occ_max_clear_req *req);
1001
+
1002
+
static inline void
1003
+
devlink_sb_occ_max_clear_req_set_bus_name(struct devlink_sb_occ_max_clear_req *req,
1004
+
const char *bus_name)
1005
+
{
1006
+
free(req->bus_name);
1007
+
req->_present.bus_name_len = strlen(bus_name);
1008
+
req->bus_name = malloc(req->_present.bus_name_len + 1);
1009
+
memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
1010
+
req->bus_name[req->_present.bus_name_len] = 0;
1011
+
}
1012
+
static inline void
1013
+
devlink_sb_occ_max_clear_req_set_dev_name(struct devlink_sb_occ_max_clear_req *req,
1014
+
const char *dev_name)
1015
+
{
1016
+
free(req->dev_name);
1017
+
req->_present.dev_name_len = strlen(dev_name);
1018
+
req->dev_name = malloc(req->_present.dev_name_len + 1);
1019
+
memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
1020
+
req->dev_name[req->_present.dev_name_len] = 0;
1021
+
}
1022
+
static inline void
1023
+
devlink_sb_occ_max_clear_req_set_sb_index(struct devlink_sb_occ_max_clear_req *req,
1024
+
__u32 sb_index)
1025
+
{
1026
+
req->_present.sb_index = 1;
1027
+
req->sb_index = sb_index;
1028
+
}
1029
+
1030
+
/*
1031
+
* Clear occupancy watermarks of shared buffer.
1032
+
*/
1033
+
int devlink_sb_occ_max_clear(struct ynl_sock *ys,
1034
+
struct devlink_sb_occ_max_clear_req *req);
1035
+
1036
+
/* ============== DEVLINK_CMD_ESWITCH_GET ============== */
1037
+
/* DEVLINK_CMD_ESWITCH_GET - do */
1038
+
struct devlink_eswitch_get_req {
1039
+
struct {
1040
+
__u32 bus_name_len;
1041
+
__u32 dev_name_len;
1042
+
} _present;
1043
+
1044
+
char *bus_name;
1045
+
char *dev_name;
1046
+
};
1047
+
1048
+
static inline struct devlink_eswitch_get_req *
1049
+
devlink_eswitch_get_req_alloc(void)
1050
+
{
1051
+
return calloc(1, sizeof(struct devlink_eswitch_get_req));
1052
+
}
1053
+
void devlink_eswitch_get_req_free(struct devlink_eswitch_get_req *req);
1054
+
1055
+
static inline void
1056
+
devlink_eswitch_get_req_set_bus_name(struct devlink_eswitch_get_req *req,
1057
+
const char *bus_name)
1058
+
{
1059
+
free(req->bus_name);
1060
+
req->_present.bus_name_len = strlen(bus_name);
1061
+
req->bus_name = malloc(req->_present.bus_name_len + 1);
1062
+
memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
1063
+
req->bus_name[req->_present.bus_name_len] = 0;
1064
+
}
1065
+
static inline void
1066
+
devlink_eswitch_get_req_set_dev_name(struct devlink_eswitch_get_req *req,
1067
+
const char *dev_name)
1068
+
{
1069
+
free(req->dev_name);
1070
+
req->_present.dev_name_len = strlen(dev_name);
1071
+
req->dev_name = malloc(req->_present.dev_name_len + 1);
1072
+
memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
1073
+
req->dev_name[req->_present.dev_name_len] = 0;
1074
+
}
1075
+
1076
+
struct devlink_eswitch_get_rsp {
1077
+
struct {
1078
+
__u32 bus_name_len;
1079
+
__u32 dev_name_len;
1080
+
__u32 eswitch_mode:1;
1081
+
__u32 eswitch_inline_mode:1;
1082
+
__u32 eswitch_encap_mode:1;
1083
+
} _present;
1084
+
1085
+
char *bus_name;
1086
+
char *dev_name;
1087
+
enum devlink_eswitch_mode eswitch_mode;
1088
+
enum devlink_eswitch_inline_mode eswitch_inline_mode;
1089
+
enum devlink_eswitch_encap_mode eswitch_encap_mode;
1090
+
};
1091
+
1092
+
void devlink_eswitch_get_rsp_free(struct devlink_eswitch_get_rsp *rsp);
1093
+
1094
+
/*
1095
+
* Get eswitch attributes.
1096
+
*/
1097
+
struct devlink_eswitch_get_rsp *
1098
+
devlink_eswitch_get(struct ynl_sock *ys, struct devlink_eswitch_get_req *req);
1099
+
1100
+
/* ============== DEVLINK_CMD_ESWITCH_SET ============== */
1101
+
/* DEVLINK_CMD_ESWITCH_SET - do */
1102
+
struct devlink_eswitch_set_req {
1103
+
struct {
1104
+
__u32 bus_name_len;
1105
+
__u32 dev_name_len;
1106
+
__u32 eswitch_mode:1;
1107
+
__u32 eswitch_inline_mode:1;
1108
+
__u32 eswitch_encap_mode:1;
1109
+
} _present;
1110
+
1111
+
char *bus_name;
1112
+
char *dev_name;
1113
+
enum devlink_eswitch_mode eswitch_mode;
1114
+
enum devlink_eswitch_inline_mode eswitch_inline_mode;
1115
+
enum devlink_eswitch_encap_mode eswitch_encap_mode;
1116
+
};
1117
+
1118
+
static inline struct devlink_eswitch_set_req *
1119
+
devlink_eswitch_set_req_alloc(void)
1120
+
{
1121
+
return calloc(1, sizeof(struct devlink_eswitch_set_req));
1122
+
}
1123
+
void devlink_eswitch_set_req_free(struct devlink_eswitch_set_req *req);
1124
+
1125
+
static inline void
1126
+
devlink_eswitch_set_req_set_bus_name(struct devlink_eswitch_set_req *req,
1127
+
const char *bus_name)
1128
+
{
1129
+
free(req->bus_name);
1130
+
req->_present.bus_name_len = strlen(bus_name);
1131
+
req->bus_name = malloc(req->_present.bus_name_len + 1);
1132
+
memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
1133
+
req->bus_name[req->_present.bus_name_len] = 0;
1134
+
}
1135
+
static inline void
1136
+
devlink_eswitch_set_req_set_dev_name(struct devlink_eswitch_set_req *req,
1137
+
const char *dev_name)
1138
+
{
1139
+
free(req->dev_name);
1140
+
req->_present.dev_name_len = strlen(dev_name);
1141
+
req->dev_name = malloc(req->_present.dev_name_len + 1);
1142
+
memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
1143
+
req->dev_name[req->_present.dev_name_len] = 0;
1144
+
}
1145
+
static inline void
1146
+
devlink_eswitch_set_req_set_eswitch_mode(struct devlink_eswitch_set_req *req,
1147
+
enum devlink_eswitch_mode eswitch_mode)
1148
+
{
1149
+
req->_present.eswitch_mode = 1;
1150
+
req->eswitch_mode = eswitch_mode;
1151
+
}
1152
+
static inline void
1153
+
devlink_eswitch_set_req_set_eswitch_inline_mode(struct devlink_eswitch_set_req *req,
1154
+
enum devlink_eswitch_inline_mode eswitch_inline_mode)
1155
+
{
1156
+
req->_present.eswitch_inline_mode = 1;
1157
+
req->eswitch_inline_mode = eswitch_inline_mode;
1158
+
}
1159
+
static inline void
1160
+
devlink_eswitch_set_req_set_eswitch_encap_mode(struct devlink_eswitch_set_req *req,
1161
+
enum devlink_eswitch_encap_mode eswitch_encap_mode)
1162
+
{
1163
+
req->_present.eswitch_encap_mode = 1;
1164
+
req->eswitch_encap_mode = eswitch_encap_mode;
1165
+
}
1166
+
1167
+
/*
1168
+
* Set eswitch attributes.
1169
+
*/
1170
+
int devlink_eswitch_set(struct ynl_sock *ys,
1171
+
struct devlink_eswitch_set_req *req);
1172
+
1173
+
/* ============== DEVLINK_CMD_DPIPE_TABLE_GET ============== */
1174
+
/* DEVLINK_CMD_DPIPE_TABLE_GET - do */
1175
+
struct devlink_dpipe_table_get_req {
1176
+
struct {
1177
+
__u32 bus_name_len;
1178
+
__u32 dev_name_len;
1179
+
__u32 dpipe_table_name_len;
1180
+
} _present;
1181
+
1182
+
char *bus_name;
1183
+
char *dev_name;
1184
+
char *dpipe_table_name;
1185
+
};
1186
+
1187
+
static inline struct devlink_dpipe_table_get_req *
1188
+
devlink_dpipe_table_get_req_alloc(void)
1189
+
{
1190
+
return calloc(1, sizeof(struct devlink_dpipe_table_get_req));
1191
+
}
1192
+
void devlink_dpipe_table_get_req_free(struct devlink_dpipe_table_get_req *req);
1193
+
1194
+
static inline void
1195
+
devlink_dpipe_table_get_req_set_bus_name(struct devlink_dpipe_table_get_req *req,
1196
+
const char *bus_name)
1197
+
{
1198
+
free(req->bus_name);
1199
+
req->_present.bus_name_len = strlen(bus_name);
1200
+
req->bus_name = malloc(req->_present.bus_name_len + 1);
1201
+
memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
1202
+
req->bus_name[req->_present.bus_name_len] = 0;
1203
+
}
1204
+
static inline void
1205
+
devlink_dpipe_table_get_req_set_dev_name(struct devlink_dpipe_table_get_req *req,
1206
+
const char *dev_name)
1207
+
{
1208
+
free(req->dev_name);
1209
+
req->_present.dev_name_len = strlen(dev_name);
1210
+
req->dev_name = malloc(req->_present.dev_name_len + 1);
1211
+
memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
1212
+
req->dev_name[req->_present.dev_name_len] = 0;
1213
+
}
1214
+
static inline void
1215
+
devlink_dpipe_table_get_req_set_dpipe_table_name(struct devlink_dpipe_table_get_req *req,
1216
+
const char *dpipe_table_name)
1217
+
{
1218
+
free(req->dpipe_table_name);
1219
+
req->_present.dpipe_table_name_len = strlen(dpipe_table_name);
1220
+
req->dpipe_table_name = malloc(req->_present.dpipe_table_name_len + 1);
1221
+
memcpy(req->dpipe_table_name, dpipe_table_name, req->_present.dpipe_table_name_len);
1222
+
req->dpipe_table_name[req->_present.dpipe_table_name_len] = 0;
1223
+
}
1224
+
1225
+
struct devlink_dpipe_table_get_rsp {
1226
+
struct {
1227
+
__u32 bus_name_len;
1228
+
__u32 dev_name_len;
1229
+
__u32 dpipe_tables:1;
1230
+
} _present;
1231
+
1232
+
char *bus_name;
1233
+
char *dev_name;
1234
+
struct devlink_dl_dpipe_tables dpipe_tables;
1235
+
};
1236
+
1237
+
void devlink_dpipe_table_get_rsp_free(struct devlink_dpipe_table_get_rsp *rsp);
1238
+
1239
+
/*
1240
+
* Get dpipe table attributes.
1241
+
*/
1242
+
struct devlink_dpipe_table_get_rsp *
1243
+
devlink_dpipe_table_get(struct ynl_sock *ys,
1244
+
struct devlink_dpipe_table_get_req *req);
1245
+
1246
+
/* ============== DEVLINK_CMD_DPIPE_ENTRIES_GET ============== */
1247
+
/* DEVLINK_CMD_DPIPE_ENTRIES_GET - do */
1248
+
struct devlink_dpipe_entries_get_req {
1249
+
struct {
1250
+
__u32 bus_name_len;
1251
+
__u32 dev_name_len;
1252
+
__u32 dpipe_table_name_len;
1253
+
} _present;
1254
+
1255
+
char *bus_name;
1256
+
char *dev_name;
1257
+
char *dpipe_table_name;
1258
+
};
1259
+
1260
+
static inline struct devlink_dpipe_entries_get_req *
1261
+
devlink_dpipe_entries_get_req_alloc(void)
1262
+
{
1263
+
return calloc(1, sizeof(struct devlink_dpipe_entries_get_req));
1264
+
}
1265
+
void
1266
+
devlink_dpipe_entries_get_req_free(struct devlink_dpipe_entries_get_req *req);
1267
+
1268
+
static inline void
1269
+
devlink_dpipe_entries_get_req_set_bus_name(struct devlink_dpipe_entries_get_req *req,
1270
+
const char *bus_name)
1271
+
{
1272
+
free(req->bus_name);
1273
+
req->_present.bus_name_len = strlen(bus_name);
1274
+
req->bus_name = malloc(req->_present.bus_name_len + 1);
1275
+
memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
1276
+
req->bus_name[req->_present.bus_name_len] = 0;
1277
+
}
1278
+
static inline void
1279
+
devlink_dpipe_entries_get_req_set_dev_name(struct devlink_dpipe_entries_get_req *req,
1280
+
const char *dev_name)
1281
+
{
1282
+
free(req->dev_name);
1283
+
req->_present.dev_name_len = strlen(dev_name);
1284
+
req->dev_name = malloc(req->_present.dev_name_len + 1);
1285
+
memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
1286
+
req->dev_name[req->_present.dev_name_len] = 0;
1287
+
}
1288
+
static inline void
1289
+
devlink_dpipe_entries_get_req_set_dpipe_table_name(struct devlink_dpipe_entries_get_req *req,
1290
+
const char *dpipe_table_name)
1291
+
{
1292
+
free(req->dpipe_table_name);
1293
+
req->_present.dpipe_table_name_len = strlen(dpipe_table_name);
1294
+
req->dpipe_table_name = malloc(req->_present.dpipe_table_name_len + 1);
1295
+
memcpy(req->dpipe_table_name, dpipe_table_name, req->_present.dpipe_table_name_len);
1296
+
req->dpipe_table_name[req->_present.dpipe_table_name_len] = 0;
1297
+
}
1298
+
1299
+
struct devlink_dpipe_entries_get_rsp {
1300
+
struct {
1301
+
__u32 bus_name_len;
1302
+
__u32 dev_name_len;
1303
+
__u32 dpipe_entries:1;
1304
+
} _present;
1305
+
1306
+
char *bus_name;
1307
+
char *dev_name;
1308
+
struct devlink_dl_dpipe_entries dpipe_entries;
1309
+
};
1310
+
1311
+
void
1312
+
devlink_dpipe_entries_get_rsp_free(struct devlink_dpipe_entries_get_rsp *rsp);
1313
+
1314
+
/*
1315
+
* Get dpipe entries attributes.
1316
+
*/
1317
+
struct devlink_dpipe_entries_get_rsp *
1318
+
devlink_dpipe_entries_get(struct ynl_sock *ys,
1319
+
struct devlink_dpipe_entries_get_req *req);
1320
+
1321
+
/* ============== DEVLINK_CMD_DPIPE_HEADERS_GET ============== */
1322
+
/* DEVLINK_CMD_DPIPE_HEADERS_GET - do */
1323
+
struct devlink_dpipe_headers_get_req {
1324
+
struct {
1325
+
__u32 bus_name_len;
1326
+
__u32 dev_name_len;
1327
+
} _present;
1328
+
1329
+
char *bus_name;
1330
+
char *dev_name;
1331
+
};
1332
+
1333
+
static inline struct devlink_dpipe_headers_get_req *
1334
+
devlink_dpipe_headers_get_req_alloc(void)
1335
+
{
1336
+
return calloc(1, sizeof(struct devlink_dpipe_headers_get_req));
1337
+
}
1338
+
void
1339
+
devlink_dpipe_headers_get_req_free(struct devlink_dpipe_headers_get_req *req);
1340
+
1341
+
static inline void
1342
+
devlink_dpipe_headers_get_req_set_bus_name(struct devlink_dpipe_headers_get_req *req,
1343
+
const char *bus_name)
1344
+
{
1345
+
free(req->bus_name);
1346
+
req->_present.bus_name_len = strlen(bus_name);
1347
+
req->bus_name = malloc(req->_present.bus_name_len + 1);
1348
+
memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
1349
+
req->bus_name[req->_present.bus_name_len] = 0;
1350
+
}
1351
+
static inline void
1352
+
devlink_dpipe_headers_get_req_set_dev_name(struct devlink_dpipe_headers_get_req *req,
1353
+
const char *dev_name)
1354
+
{
1355
+
free(req->dev_name);
1356
+
req->_present.dev_name_len = strlen(dev_name);
1357
+
req->dev_name = malloc(req->_present.dev_name_len + 1);
1358
+
memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
1359
+
req->dev_name[req->_present.dev_name_len] = 0;
1360
+
}
1361
+
1362
+
struct devlink_dpipe_headers_get_rsp {
1363
+
struct {
1364
+
__u32 bus_name_len;
1365
+
__u32 dev_name_len;
1366
+
__u32 dpipe_headers:1;
1367
+
} _present;
1368
+
1369
+
char *bus_name;
1370
+
char *dev_name;
1371
+
struct devlink_dl_dpipe_headers dpipe_headers;
1372
+
};
1373
+
1374
+
void
1375
+
devlink_dpipe_headers_get_rsp_free(struct devlink_dpipe_headers_get_rsp *rsp);
1376
+
1377
+
/*
1378
+
* Get dpipe headers attributes.
1379
+
*/
1380
+
struct devlink_dpipe_headers_get_rsp *
1381
+
devlink_dpipe_headers_get(struct ynl_sock *ys,
1382
+
struct devlink_dpipe_headers_get_req *req);
1383
+
1384
+
/* ============== DEVLINK_CMD_DPIPE_TABLE_COUNTERS_SET ============== */
1385
+
/* DEVLINK_CMD_DPIPE_TABLE_COUNTERS_SET - do */
1386
+
struct devlink_dpipe_table_counters_set_req {
1387
+
struct {
1388
+
__u32 bus_name_len;
1389
+
__u32 dev_name_len;
1390
+
__u32 dpipe_table_name_len;
1391
+
__u32 dpipe_table_counters_enabled:1;
1392
+
} _present;
1393
+
1394
+
char *bus_name;
1395
+
char *dev_name;
1396
+
char *dpipe_table_name;
1397
+
__u8 dpipe_table_counters_enabled;
1398
+
};
1399
+
1400
+
static inline struct devlink_dpipe_table_counters_set_req *
1401
+
devlink_dpipe_table_counters_set_req_alloc(void)
1402
+
{
1403
+
return calloc(1, sizeof(struct devlink_dpipe_table_counters_set_req));
1404
+
}
1405
+
void
1406
+
devlink_dpipe_table_counters_set_req_free(struct devlink_dpipe_table_counters_set_req *req);
1407
+
1408
+
static inline void
1409
+
devlink_dpipe_table_counters_set_req_set_bus_name(struct devlink_dpipe_table_counters_set_req *req,
1410
+
const char *bus_name)
1411
+
{
1412
+
free(req->bus_name);
1413
+
req->_present.bus_name_len = strlen(bus_name);
1414
+
req->bus_name = malloc(req->_present.bus_name_len + 1);
1415
+
memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
1416
+
req->bus_name[req->_present.bus_name_len] = 0;
1417
+
}
1418
+
static inline void
1419
+
devlink_dpipe_table_counters_set_req_set_dev_name(struct devlink_dpipe_table_counters_set_req *req,
1420
+
const char *dev_name)
1421
+
{
1422
+
free(req->dev_name);
1423
+
req->_present.dev_name_len = strlen(dev_name);
1424
+
req->dev_name = malloc(req->_present.dev_name_len + 1);
1425
+
memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
1426
+
req->dev_name[req->_present.dev_name_len] = 0;
1427
+
}
1428
+
static inline void
1429
+
devlink_dpipe_table_counters_set_req_set_dpipe_table_name(struct devlink_dpipe_table_counters_set_req *req,
1430
+
const char *dpipe_table_name)
1431
+
{
1432
+
free(req->dpipe_table_name);
1433
+
req->_present.dpipe_table_name_len = strlen(dpipe_table_name);
1434
+
req->dpipe_table_name = malloc(req->_present.dpipe_table_name_len + 1);
1435
+
memcpy(req->dpipe_table_name, dpipe_table_name, req->_present.dpipe_table_name_len);
1436
+
req->dpipe_table_name[req->_present.dpipe_table_name_len] = 0;
1437
+
}
1438
+
static inline void
1439
+
devlink_dpipe_table_counters_set_req_set_dpipe_table_counters_enabled(struct devlink_dpipe_table_counters_set_req *req,
1440
+
__u8 dpipe_table_counters_enabled)
1441
+
{
1442
+
req->_present.dpipe_table_counters_enabled = 1;
1443
+
req->dpipe_table_counters_enabled = dpipe_table_counters_enabled;
1444
+
}
1445
+
1446
+
/*
1447
+
* Set dpipe counter attributes.
1448
+
*/
1449
+
int devlink_dpipe_table_counters_set(struct ynl_sock *ys,
1450
+
struct devlink_dpipe_table_counters_set_req *req);
1451
+
1452
+
/* ============== DEVLINK_CMD_RESOURCE_SET ============== */
1453
+
/* DEVLINK_CMD_RESOURCE_SET - do */
1454
+
struct devlink_resource_set_req {
1455
+
struct {
1456
+
__u32 bus_name_len;
1457
+
__u32 dev_name_len;
1458
+
__u32 resource_id:1;
1459
+
__u32 resource_size:1;
1460
+
} _present;
1461
+
1462
+
char *bus_name;
1463
+
char *dev_name;
1464
+
__u64 resource_id;
1465
+
__u64 resource_size;
1466
+
};
1467
+
1468
+
static inline struct devlink_resource_set_req *
1469
+
devlink_resource_set_req_alloc(void)
1470
+
{
1471
+
return calloc(1, sizeof(struct devlink_resource_set_req));
1472
+
}
1473
+
void devlink_resource_set_req_free(struct devlink_resource_set_req *req);
1474
+
1475
+
static inline void
1476
+
devlink_resource_set_req_set_bus_name(struct devlink_resource_set_req *req,
1477
+
const char *bus_name)
1478
+
{
1479
+
free(req->bus_name);
1480
+
req->_present.bus_name_len = strlen(bus_name);
1481
+
req->bus_name = malloc(req->_present.bus_name_len + 1);
1482
+
memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
1483
+
req->bus_name[req->_present.bus_name_len] = 0;
1484
+
}
1485
+
static inline void
1486
+
devlink_resource_set_req_set_dev_name(struct devlink_resource_set_req *req,
1487
+
const char *dev_name)
1488
+
{
1489
+
free(req->dev_name);
1490
+
req->_present.dev_name_len = strlen(dev_name);
1491
+
req->dev_name = malloc(req->_present.dev_name_len + 1);
1492
+
memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
1493
+
req->dev_name[req->_present.dev_name_len] = 0;
1494
+
}
1495
+
static inline void
1496
+
devlink_resource_set_req_set_resource_id(struct devlink_resource_set_req *req,
1497
+
__u64 resource_id)
1498
+
{
1499
+
req->_present.resource_id = 1;
1500
+
req->resource_id = resource_id;
1501
+
}
1502
+
static inline void
1503
+
devlink_resource_set_req_set_resource_size(struct devlink_resource_set_req *req,
1504
+
__u64 resource_size)
1505
+
{
1506
+
req->_present.resource_size = 1;
1507
+
req->resource_size = resource_size;
1508
+
}
1509
+
1510
+
/*
1511
+
* Set resource attributes.
1512
+
*/
1513
+
int devlink_resource_set(struct ynl_sock *ys,
1514
+
struct devlink_resource_set_req *req);
1515
+
1516
+
/* ============== DEVLINK_CMD_RESOURCE_DUMP ============== */
1517
+
/* DEVLINK_CMD_RESOURCE_DUMP - do */
1518
+
struct devlink_resource_dump_req {
1519
+
struct {
1520
+
__u32 bus_name_len;
1521
+
__u32 dev_name_len;
1522
+
} _present;
1523
+
1524
+
char *bus_name;
1525
+
char *dev_name;
1526
+
};
1527
+
1528
+
static inline struct devlink_resource_dump_req *
1529
+
devlink_resource_dump_req_alloc(void)
1530
+
{
1531
+
return calloc(1, sizeof(struct devlink_resource_dump_req));
1532
+
}
1533
+
void devlink_resource_dump_req_free(struct devlink_resource_dump_req *req);
1534
+
1535
+
static inline void
1536
+
devlink_resource_dump_req_set_bus_name(struct devlink_resource_dump_req *req,
1537
+
const char *bus_name)
1538
+
{
1539
+
free(req->bus_name);
1540
+
req->_present.bus_name_len = strlen(bus_name);
1541
+
req->bus_name = malloc(req->_present.bus_name_len + 1);
1542
+
memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
1543
+
req->bus_name[req->_present.bus_name_len] = 0;
1544
+
}
1545
+
static inline void
1546
+
devlink_resource_dump_req_set_dev_name(struct devlink_resource_dump_req *req,
1547
+
const char *dev_name)
1548
+
{
1549
+
free(req->dev_name);
1550
+
req->_present.dev_name_len = strlen(dev_name);
1551
+
req->dev_name = malloc(req->_present.dev_name_len + 1);
1552
+
memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
1553
+
req->dev_name[req->_present.dev_name_len] = 0;
1554
+
}
1555
+
1556
+
struct devlink_resource_dump_rsp {
1557
+
struct {
1558
+
__u32 bus_name_len;
1559
+
__u32 dev_name_len;
1560
+
__u32 resource_list:1;
1561
+
} _present;
1562
+
1563
+
char *bus_name;
1564
+
char *dev_name;
1565
+
struct devlink_dl_resource_list resource_list;
1566
+
};
1567
+
1568
+
void devlink_resource_dump_rsp_free(struct devlink_resource_dump_rsp *rsp);
1569
+
1570
+
/*
1571
+
* Get resource attributes.
1572
+
*/
1573
+
struct devlink_resource_dump_rsp *
1574
+
devlink_resource_dump(struct ynl_sock *ys,
1575
+
struct devlink_resource_dump_req *req);
1576
+
1577
+
/* ============== DEVLINK_CMD_RELOAD ============== */
1578
+
/* DEVLINK_CMD_RELOAD - do */
1579
+
struct devlink_reload_req {
1580
+
struct {
1581
+
__u32 bus_name_len;
1582
+
__u32 dev_name_len;
1583
+
__u32 reload_action:1;
1584
+
__u32 reload_limits:1;
1585
+
__u32 netns_pid:1;
1586
+
__u32 netns_fd:1;
1587
+
__u32 netns_id:1;
1588
+
} _present;
1589
+
1590
+
char *bus_name;
1591
+
char *dev_name;
1592
+
enum devlink_reload_action reload_action;
1593
+
struct nla_bitfield32 reload_limits;
1594
+
__u32 netns_pid;
1595
+
__u32 netns_fd;
1596
+
__u32 netns_id;
1597
+
};
1598
+
1599
+
static inline struct devlink_reload_req *devlink_reload_req_alloc(void)
1600
+
{
1601
+
return calloc(1, sizeof(struct devlink_reload_req));
1602
+
}
1603
+
void devlink_reload_req_free(struct devlink_reload_req *req);
1604
+
1605
+
static inline void
1606
+
devlink_reload_req_set_bus_name(struct devlink_reload_req *req,
1607
+
const char *bus_name)
1608
+
{
1609
+
free(req->bus_name);
1610
+
req->_present.bus_name_len = strlen(bus_name);
1611
+
req->bus_name = malloc(req->_present.bus_name_len + 1);
1612
+
memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
1613
+
req->bus_name[req->_present.bus_name_len] = 0;
1614
+
}
1615
+
static inline void
1616
+
devlink_reload_req_set_dev_name(struct devlink_reload_req *req,
1617
+
const char *dev_name)
1618
+
{
1619
+
free(req->dev_name);
1620
+
req->_present.dev_name_len = strlen(dev_name);
1621
+
req->dev_name = malloc(req->_present.dev_name_len + 1);
1622
+
memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
1623
+
req->dev_name[req->_present.dev_name_len] = 0;
1624
+
}
1625
+
static inline void
1626
+
devlink_reload_req_set_reload_action(struct devlink_reload_req *req,
1627
+
enum devlink_reload_action reload_action)
1628
+
{
1629
+
req->_present.reload_action = 1;
1630
+
req->reload_action = reload_action;
1631
+
}
1632
+
static inline void
1633
+
devlink_reload_req_set_reload_limits(struct devlink_reload_req *req,
1634
+
struct nla_bitfield32 *reload_limits)
1635
+
{
1636
+
req->_present.reload_limits = 1;
1637
+
memcpy(&req->reload_limits, reload_limits, sizeof(struct nla_bitfield32));
1638
+
}
1639
+
static inline void
1640
+
devlink_reload_req_set_netns_pid(struct devlink_reload_req *req,
1641
+
__u32 netns_pid)
1642
+
{
1643
+
req->_present.netns_pid = 1;
1644
+
req->netns_pid = netns_pid;
1645
+
}
1646
+
static inline void
1647
+
devlink_reload_req_set_netns_fd(struct devlink_reload_req *req, __u32 netns_fd)
1648
+
{
1649
+
req->_present.netns_fd = 1;
1650
+
req->netns_fd = netns_fd;
1651
+
}
1652
+
static inline void
1653
+
devlink_reload_req_set_netns_id(struct devlink_reload_req *req, __u32 netns_id)
1654
+
{
1655
+
req->_present.netns_id = 1;
1656
+
req->netns_id = netns_id;
1657
+
}
1658
+
1659
+
struct devlink_reload_rsp {
1660
+
struct {
1661
+
__u32 bus_name_len;
1662
+
__u32 dev_name_len;
1663
+
__u32 reload_actions_performed:1;
1664
+
} _present;
1665
+
1666
+
char *bus_name;
1667
+
char *dev_name;
1668
+
struct nla_bitfield32 reload_actions_performed;
1669
+
};
1670
+
1671
+
void devlink_reload_rsp_free(struct devlink_reload_rsp *rsp);
1672
+
1673
+
/*
1674
+
* Reload devlink.
1675
+
*/
1676
+
struct devlink_reload_rsp *
1677
+
devlink_reload(struct ynl_sock *ys, struct devlink_reload_req *req);
1678
+
1606
1679
/* ============== DEVLINK_CMD_PARAM_GET ============== */
1607
1680
/* DEVLINK_CMD_PARAM_GET - do */
1608
1681
struct devlink_param_get_req {
···
2578
941
struct devlink_param_get_list *
2579
942
devlink_param_get_dump(struct ynl_sock *ys,
2580
943
struct devlink_param_get_req_dump *req);
944
+
945
+
/* ============== DEVLINK_CMD_PARAM_SET ============== */
946
+
/* DEVLINK_CMD_PARAM_SET - do */
947
+
struct devlink_param_set_req {
948
+
struct {
949
+
__u32 bus_name_len;
950
+
__u32 dev_name_len;
951
+
__u32 param_name_len;
952
+
__u32 param_type:1;
953
+
__u32 param_value_cmode:1;
954
+
} _present;
955
+
956
+
char *bus_name;
957
+
char *dev_name;
958
+
char *param_name;
959
+
__u8 param_type;
960
+
enum devlink_param_cmode param_value_cmode;
961
+
};
962
+
963
+
static inline struct devlink_param_set_req *devlink_param_set_req_alloc(void)
964
+
{
965
+
return calloc(1, sizeof(struct devlink_param_set_req));
966
+
}
967
+
void devlink_param_set_req_free(struct devlink_param_set_req *req);
968
+
969
+
static inline void
970
+
devlink_param_set_req_set_bus_name(struct devlink_param_set_req *req,
971
+
const char *bus_name)
972
+
{
973
+
free(req->bus_name);
974
+
req->_present.bus_name_len = strlen(bus_name);
975
+
req->bus_name = malloc(req->_present.bus_name_len + 1);
976
+
memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
977
+
req->bus_name[req->_present.bus_name_len] = 0;
978
+
}
979
+
static inline void
980
+
devlink_param_set_req_set_dev_name(struct devlink_param_set_req *req,
981
+
const char *dev_name)
982
+
{
983
+
free(req->dev_name);
984
+
req->_present.dev_name_len = strlen(dev_name);
985
+
req->dev_name = malloc(req->_present.dev_name_len + 1);
986
+
memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
987
+
req->dev_name[req->_present.dev_name_len] = 0;
988
+
}
989
+
static inline void
990
+
devlink_param_set_req_set_param_name(struct devlink_param_set_req *req,
991
+
const char *param_name)
992
+
{
993
+
free(req->param_name);
994
+
req->_present.param_name_len = strlen(param_name);
995
+
req->param_name = malloc(req->_present.param_name_len + 1);
996
+
memcpy(req->param_name, param_name, req->_present.param_name_len);
997
+
req->param_name[req->_present.param_name_len] = 0;
998
+
}
999
+
static inline void
1000
+
devlink_param_set_req_set_param_type(struct devlink_param_set_req *req,
1001
+
__u8 param_type)
1002
+
{
1003
+
req->_present.param_type = 1;
1004
+
req->param_type = param_type;
1005
+
}
1006
+
static inline void
1007
+
devlink_param_set_req_set_param_value_cmode(struct devlink_param_set_req *req,
1008
+
enum devlink_param_cmode param_value_cmode)
1009
+
{
1010
+
req->_present.param_value_cmode = 1;
1011
+
req->param_value_cmode = param_value_cmode;
1012
+
}
1013
+
1014
+
/*
1015
+
* Set param instances.
1016
+
*/
1017
+
int devlink_param_set(struct ynl_sock *ys, struct devlink_param_set_req *req);
2581
1018
2582
1019
/* ============== DEVLINK_CMD_REGION_GET ============== */
2583
1020
/* DEVLINK_CMD_REGION_GET - do */
···
2784
1073
struct devlink_region_get_list *
2785
1074
devlink_region_get_dump(struct ynl_sock *ys,
2786
1075
struct devlink_region_get_req_dump *req);
1076
+
1077
+
/* ============== DEVLINK_CMD_REGION_NEW ============== */
1078
+
/* DEVLINK_CMD_REGION_NEW - do */
1079
+
struct devlink_region_new_req {
1080
+
struct {
1081
+
__u32 bus_name_len;
1082
+
__u32 dev_name_len;
1083
+
__u32 port_index:1;
1084
+
__u32 region_name_len;
1085
+
__u32 region_snapshot_id:1;
1086
+
} _present;
1087
+
1088
+
char *bus_name;
1089
+
char *dev_name;
1090
+
__u32 port_index;
1091
+
char *region_name;
1092
+
__u32 region_snapshot_id;
1093
+
};
1094
+
1095
+
static inline struct devlink_region_new_req *devlink_region_new_req_alloc(void)
1096
+
{
1097
+
return calloc(1, sizeof(struct devlink_region_new_req));
1098
+
}
1099
+
void devlink_region_new_req_free(struct devlink_region_new_req *req);
1100
+
1101
+
static inline void
1102
+
devlink_region_new_req_set_bus_name(struct devlink_region_new_req *req,
1103
+
const char *bus_name)
1104
+
{
1105
+
free(req->bus_name);
1106
+
req->_present.bus_name_len = strlen(bus_name);
1107
+
req->bus_name = malloc(req->_present.bus_name_len + 1);
1108
+
memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
1109
+
req->bus_name[req->_present.bus_name_len] = 0;
1110
+
}
1111
+
static inline void
1112
+
devlink_region_new_req_set_dev_name(struct devlink_region_new_req *req,
1113
+
const char *dev_name)
1114
+
{
1115
+
free(req->dev_name);
1116
+
req->_present.dev_name_len = strlen(dev_name);
1117
+
req->dev_name = malloc(req->_present.dev_name_len + 1);
1118
+
memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
1119
+
req->dev_name[req->_present.dev_name_len] = 0;
1120
+
}
1121
+
static inline void
1122
+
devlink_region_new_req_set_port_index(struct devlink_region_new_req *req,
1123
+
__u32 port_index)
1124
+
{
1125
+
req->_present.port_index = 1;
1126
+
req->port_index = port_index;
1127
+
}
1128
+
static inline void
1129
+
devlink_region_new_req_set_region_name(struct devlink_region_new_req *req,
1130
+
const char *region_name)
1131
+
{
1132
+
free(req->region_name);
1133
+
req->_present.region_name_len = strlen(region_name);
1134
+
req->region_name = malloc(req->_present.region_name_len + 1);
1135
+
memcpy(req->region_name, region_name, req->_present.region_name_len);
1136
+
req->region_name[req->_present.region_name_len] = 0;
1137
+
}
1138
+
static inline void
1139
+
devlink_region_new_req_set_region_snapshot_id(struct devlink_region_new_req *req,
1140
+
__u32 region_snapshot_id)
1141
+
{
1142
+
req->_present.region_snapshot_id = 1;
1143
+
req->region_snapshot_id = region_snapshot_id;
1144
+
}
1145
+
1146
+
struct devlink_region_new_rsp {
1147
+
struct {
1148
+
__u32 bus_name_len;
1149
+
__u32 dev_name_len;
1150
+
__u32 port_index:1;
1151
+
__u32 region_name_len;
1152
+
__u32 region_snapshot_id:1;
1153
+
} _present;
1154
+
1155
+
char *bus_name;
1156
+
char *dev_name;
1157
+
__u32 port_index;
1158
+
char *region_name;
1159
+
__u32 region_snapshot_id;
1160
+
};
1161
+
1162
+
void devlink_region_new_rsp_free(struct devlink_region_new_rsp *rsp);
1163
+
1164
+
/*
1165
+
* Create region snapshot.
1166
+
*/
1167
+
struct devlink_region_new_rsp *
1168
+
devlink_region_new(struct ynl_sock *ys, struct devlink_region_new_req *req);
1169
+
1170
+
/* ============== DEVLINK_CMD_REGION_DEL ============== */
1171
+
/* DEVLINK_CMD_REGION_DEL - do */
1172
+
struct devlink_region_del_req {
1173
+
struct {
1174
+
__u32 bus_name_len;
1175
+
__u32 dev_name_len;
1176
+
__u32 port_index:1;
1177
+
__u32 region_name_len;
1178
+
__u32 region_snapshot_id:1;
1179
+
} _present;
1180
+
1181
+
char *bus_name;
1182
+
char *dev_name;
1183
+
__u32 port_index;
1184
+
char *region_name;
1185
+
__u32 region_snapshot_id;
1186
+
};
1187
+
1188
+
static inline struct devlink_region_del_req *devlink_region_del_req_alloc(void)
1189
+
{
1190
+
return calloc(1, sizeof(struct devlink_region_del_req));
1191
+
}
1192
+
void devlink_region_del_req_free(struct devlink_region_del_req *req);
1193
+
1194
+
static inline void
1195
+
devlink_region_del_req_set_bus_name(struct devlink_region_del_req *req,
1196
+
const char *bus_name)
1197
+
{
1198
+
free(req->bus_name);
1199
+
req->_present.bus_name_len = strlen(bus_name);
1200
+
req->bus_name = malloc(req->_present.bus_name_len + 1);
1201
+
memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
1202
+
req->bus_name[req->_present.bus_name_len] = 0;
1203
+
}
1204
+
static inline void
1205
+
devlink_region_del_req_set_dev_name(struct devlink_region_del_req *req,
1206
+
const char *dev_name)
1207
+
{
1208
+
free(req->dev_name);
1209
+
req->_present.dev_name_len = strlen(dev_name);
1210
+
req->dev_name = malloc(req->_present.dev_name_len + 1);
1211
+
memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
1212
+
req->dev_name[req->_present.dev_name_len] = 0;
1213
+
}
1214
+
static inline void
1215
+
devlink_region_del_req_set_port_index(struct devlink_region_del_req *req,
1216
+
__u32 port_index)
1217
+
{
1218
+
req->_present.port_index = 1;
1219
+
req->port_index = port_index;
1220
+
}
1221
+
static inline void
1222
+
devlink_region_del_req_set_region_name(struct devlink_region_del_req *req,
1223
+
const char *region_name)
1224
+
{
1225
+
free(req->region_name);
1226
+
req->_present.region_name_len = strlen(region_name);
1227
+
req->region_name = malloc(req->_present.region_name_len + 1);
1228
+
memcpy(req->region_name, region_name, req->_present.region_name_len);
1229
+
req->region_name[req->_present.region_name_len] = 0;
1230
+
}
1231
+
static inline void
1232
+
devlink_region_del_req_set_region_snapshot_id(struct devlink_region_del_req *req,
1233
+
__u32 region_snapshot_id)
1234
+
{
1235
+
req->_present.region_snapshot_id = 1;
1236
+
req->region_snapshot_id = region_snapshot_id;
1237
+
}
1238
+
1239
+
/*
1240
+
* Delete region snapshot.
1241
+
*/
1242
+
int devlink_region_del(struct ynl_sock *ys, struct devlink_region_del_req *req);
1243
+
1244
+
/* ============== DEVLINK_CMD_REGION_READ ============== */
1245
+
/* DEVLINK_CMD_REGION_READ - dump */
1246
+
struct devlink_region_read_req_dump {
1247
+
struct {
1248
+
__u32 bus_name_len;
1249
+
__u32 dev_name_len;
1250
+
__u32 port_index:1;
1251
+
__u32 region_name_len;
1252
+
__u32 region_snapshot_id:1;
1253
+
__u32 region_direct:1;
1254
+
__u32 region_chunk_addr:1;
1255
+
__u32 region_chunk_len:1;
1256
+
} _present;
1257
+
1258
+
char *bus_name;
1259
+
char *dev_name;
1260
+
__u32 port_index;
1261
+
char *region_name;
1262
+
__u32 region_snapshot_id;
1263
+
__u64 region_chunk_addr;
1264
+
__u64 region_chunk_len;
1265
+
};
1266
+
1267
+
static inline struct devlink_region_read_req_dump *
1268
+
devlink_region_read_req_dump_alloc(void)
1269
+
{
1270
+
return calloc(1, sizeof(struct devlink_region_read_req_dump));
1271
+
}
1272
+
void
1273
+
devlink_region_read_req_dump_free(struct devlink_region_read_req_dump *req);
1274
+
1275
+
static inline void
1276
+
devlink_region_read_req_dump_set_bus_name(struct devlink_region_read_req_dump *req,
1277
+
const char *bus_name)
1278
+
{
1279
+
free(req->bus_name);
1280
+
req->_present.bus_name_len = strlen(bus_name);
1281
+
req->bus_name = malloc(req->_present.bus_name_len + 1);
1282
+
memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
1283
+
req->bus_name[req->_present.bus_name_len] = 0;
1284
+
}
1285
+
static inline void
1286
+
devlink_region_read_req_dump_set_dev_name(struct devlink_region_read_req_dump *req,
1287
+
const char *dev_name)
1288
+
{
1289
+
free(req->dev_name);
1290
+
req->_present.dev_name_len = strlen(dev_name);
1291
+
req->dev_name = malloc(req->_present.dev_name_len + 1);
1292
+
memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
1293
+
req->dev_name[req->_present.dev_name_len] = 0;
1294
+
}
1295
+
static inline void
1296
+
devlink_region_read_req_dump_set_port_index(struct devlink_region_read_req_dump *req,
1297
+
__u32 port_index)
1298
+
{
1299
+
req->_present.port_index = 1;
1300
+
req->port_index = port_index;
1301
+
}
1302
+
static inline void
1303
+
devlink_region_read_req_dump_set_region_name(struct devlink_region_read_req_dump *req,
1304
+
const char *region_name)
1305
+
{
1306
+
free(req->region_name);
1307
+
req->_present.region_name_len = strlen(region_name);
1308
+
req->region_name = malloc(req->_present.region_name_len + 1);
1309
+
memcpy(req->region_name, region_name, req->_present.region_name_len);
1310
+
req->region_name[req->_present.region_name_len] = 0;
1311
+
}
1312
+
static inline void
1313
+
devlink_region_read_req_dump_set_region_snapshot_id(struct devlink_region_read_req_dump *req,
1314
+
__u32 region_snapshot_id)
1315
+
{
1316
+
req->_present.region_snapshot_id = 1;
1317
+
req->region_snapshot_id = region_snapshot_id;
1318
+
}
1319
+
static inline void
1320
+
devlink_region_read_req_dump_set_region_direct(struct devlink_region_read_req_dump *req)
1321
+
{
1322
+
req->_present.region_direct = 1;
1323
+
}
1324
+
static inline void
1325
+
devlink_region_read_req_dump_set_region_chunk_addr(struct devlink_region_read_req_dump *req,
1326
+
__u64 region_chunk_addr)
1327
+
{
1328
+
req->_present.region_chunk_addr = 1;
1329
+
req->region_chunk_addr = region_chunk_addr;
1330
+
}
1331
+
static inline void
1332
+
devlink_region_read_req_dump_set_region_chunk_len(struct devlink_region_read_req_dump *req,
1333
+
__u64 region_chunk_len)
1334
+
{
1335
+
req->_present.region_chunk_len = 1;
1336
+
req->region_chunk_len = region_chunk_len;
1337
+
}
1338
+
1339
+
struct devlink_region_read_rsp_dump {
1340
+
struct {
1341
+
__u32 bus_name_len;
1342
+
__u32 dev_name_len;
1343
+
__u32 port_index:1;
1344
+
__u32 region_name_len;
1345
+
} _present;
1346
+
1347
+
char *bus_name;
1348
+
char *dev_name;
1349
+
__u32 port_index;
1350
+
char *region_name;
1351
+
};
1352
+
1353
+
struct devlink_region_read_rsp_list {
1354
+
struct devlink_region_read_rsp_list *next;
1355
+
struct devlink_region_read_rsp_dump obj __attribute__((aligned(8)));
1356
+
};
1357
+
1358
+
void
1359
+
devlink_region_read_rsp_list_free(struct devlink_region_read_rsp_list *rsp);
1360
+
1361
+
struct devlink_region_read_rsp_list *
1362
+
devlink_region_read_dump(struct ynl_sock *ys,
1363
+
struct devlink_region_read_req_dump *req);
1364
+
1365
+
/* ============== DEVLINK_CMD_PORT_PARAM_GET ============== */
1366
+
/* DEVLINK_CMD_PORT_PARAM_GET - do */
1367
+
struct devlink_port_param_get_req {
1368
+
struct {
1369
+
__u32 bus_name_len;
1370
+
__u32 dev_name_len;
1371
+
__u32 port_index:1;
1372
+
} _present;
1373
+
1374
+
char *bus_name;
1375
+
char *dev_name;
1376
+
__u32 port_index;
1377
+
};
1378
+
1379
+
static inline struct devlink_port_param_get_req *
1380
+
devlink_port_param_get_req_alloc(void)
1381
+
{
1382
+
return calloc(1, sizeof(struct devlink_port_param_get_req));
1383
+
}
1384
+
void devlink_port_param_get_req_free(struct devlink_port_param_get_req *req);
1385
+
1386
+
static inline void
1387
+
devlink_port_param_get_req_set_bus_name(struct devlink_port_param_get_req *req,
1388
+
const char *bus_name)
1389
+
{
1390
+
free(req->bus_name);
1391
+
req->_present.bus_name_len = strlen(bus_name);
1392
+
req->bus_name = malloc(req->_present.bus_name_len + 1);
1393
+
memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
1394
+
req->bus_name[req->_present.bus_name_len] = 0;
1395
+
}
1396
+
static inline void
1397
+
devlink_port_param_get_req_set_dev_name(struct devlink_port_param_get_req *req,
1398
+
const char *dev_name)
1399
+
{
1400
+
free(req->dev_name);
1401
+
req->_present.dev_name_len = strlen(dev_name);
1402
+
req->dev_name = malloc(req->_present.dev_name_len + 1);
1403
+
memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
1404
+
req->dev_name[req->_present.dev_name_len] = 0;
1405
+
}
1406
+
static inline void
1407
+
devlink_port_param_get_req_set_port_index(struct devlink_port_param_get_req *req,
1408
+
__u32 port_index)
1409
+
{
1410
+
req->_present.port_index = 1;
1411
+
req->port_index = port_index;
1412
+
}
1413
+
1414
+
struct devlink_port_param_get_rsp {
1415
+
struct {
1416
+
__u32 bus_name_len;
1417
+
__u32 dev_name_len;
1418
+
__u32 port_index:1;
1419
+
} _present;
1420
+
1421
+
char *bus_name;
1422
+
char *dev_name;
1423
+
__u32 port_index;
1424
+
};
1425
+
1426
+
void devlink_port_param_get_rsp_free(struct devlink_port_param_get_rsp *rsp);
1427
+
1428
+
/*
1429
+
* Get port param instances.
1430
+
*/
1431
+
struct devlink_port_param_get_rsp *
1432
+
devlink_port_param_get(struct ynl_sock *ys,
1433
+
struct devlink_port_param_get_req *req);
1434
+
1435
+
/* DEVLINK_CMD_PORT_PARAM_GET - dump */
1436
+
struct devlink_port_param_get_list {
1437
+
struct devlink_port_param_get_list *next;
1438
+
struct devlink_port_param_get_rsp obj __attribute__((aligned(8)));
1439
+
};
1440
+
1441
+
void devlink_port_param_get_list_free(struct devlink_port_param_get_list *rsp);
1442
+
1443
+
struct devlink_port_param_get_list *
1444
+
devlink_port_param_get_dump(struct ynl_sock *ys);
1445
+
1446
+
/* ============== DEVLINK_CMD_PORT_PARAM_SET ============== */
1447
+
/* DEVLINK_CMD_PORT_PARAM_SET - do */
1448
+
struct devlink_port_param_set_req {
1449
+
struct {
1450
+
__u32 bus_name_len;
1451
+
__u32 dev_name_len;
1452
+
__u32 port_index:1;
1453
+
} _present;
1454
+
1455
+
char *bus_name;
1456
+
char *dev_name;
1457
+
__u32 port_index;
1458
+
};
1459
+
1460
+
static inline struct devlink_port_param_set_req *
1461
+
devlink_port_param_set_req_alloc(void)
1462
+
{
1463
+
return calloc(1, sizeof(struct devlink_port_param_set_req));
1464
+
}
1465
+
void devlink_port_param_set_req_free(struct devlink_port_param_set_req *req);
1466
+
1467
+
static inline void
1468
+
devlink_port_param_set_req_set_bus_name(struct devlink_port_param_set_req *req,
1469
+
const char *bus_name)
1470
+
{
1471
+
free(req->bus_name);
1472
+
req->_present.bus_name_len = strlen(bus_name);
1473
+
req->bus_name = malloc(req->_present.bus_name_len + 1);
1474
+
memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
1475
+
req->bus_name[req->_present.bus_name_len] = 0;
1476
+
}
1477
+
static inline void
1478
+
devlink_port_param_set_req_set_dev_name(struct devlink_port_param_set_req *req,
1479
+
const char *dev_name)
1480
+
{
1481
+
free(req->dev_name);
1482
+
req->_present.dev_name_len = strlen(dev_name);
1483
+
req->dev_name = malloc(req->_present.dev_name_len + 1);
1484
+
memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
1485
+
req->dev_name[req->_present.dev_name_len] = 0;
1486
+
}
1487
+
static inline void
1488
+
devlink_port_param_set_req_set_port_index(struct devlink_port_param_set_req *req,
1489
+
__u32 port_index)
1490
+
{
1491
+
req->_present.port_index = 1;
1492
+
req->port_index = port_index;
1493
+
}
1494
+
1495
+
/*
1496
+
* Set port param instances.
1497
+
*/
1498
+
int devlink_port_param_set(struct ynl_sock *ys,
1499
+
struct devlink_port_param_set_req *req);
2787
1500
2788
1501
/* ============== DEVLINK_CMD_INFO_GET ============== */
2789
1502
/* DEVLINK_CMD_INFO_GET - do */
···
3433
1298
devlink_health_reporter_get_dump(struct ynl_sock *ys,
3434
1299
struct devlink_health_reporter_get_req_dump *req);
3435
1300
1301
+
/* ============== DEVLINK_CMD_HEALTH_REPORTER_SET ============== */
1302
+
/* DEVLINK_CMD_HEALTH_REPORTER_SET - do */
1303
+
struct devlink_health_reporter_set_req {
1304
+
struct {
1305
+
__u32 bus_name_len;
1306
+
__u32 dev_name_len;
1307
+
__u32 port_index:1;
1308
+
__u32 health_reporter_name_len;
1309
+
__u32 health_reporter_graceful_period:1;
1310
+
__u32 health_reporter_auto_recover:1;
1311
+
__u32 health_reporter_auto_dump:1;
1312
+
} _present;
1313
+
1314
+
char *bus_name;
1315
+
char *dev_name;
1316
+
__u32 port_index;
1317
+
char *health_reporter_name;
1318
+
__u64 health_reporter_graceful_period;
1319
+
__u8 health_reporter_auto_recover;
1320
+
__u8 health_reporter_auto_dump;
1321
+
};
1322
+
1323
+
static inline struct devlink_health_reporter_set_req *
1324
+
devlink_health_reporter_set_req_alloc(void)
1325
+
{
1326
+
return calloc(1, sizeof(struct devlink_health_reporter_set_req));
1327
+
}
1328
+
void
1329
+
devlink_health_reporter_set_req_free(struct devlink_health_reporter_set_req *req);
1330
+
1331
+
static inline void
1332
+
devlink_health_reporter_set_req_set_bus_name(struct devlink_health_reporter_set_req *req,
1333
+
const char *bus_name)
1334
+
{
1335
+
free(req->bus_name);
1336
+
req->_present.bus_name_len = strlen(bus_name);
1337
+
req->bus_name = malloc(req->_present.bus_name_len + 1);
1338
+
memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
1339
+
req->bus_name[req->_present.bus_name_len] = 0;
1340
+
}
1341
+
static inline void
1342
+
devlink_health_reporter_set_req_set_dev_name(struct devlink_health_reporter_set_req *req,
1343
+
const char *dev_name)
1344
+
{
1345
+
free(req->dev_name);
1346
+
req->_present.dev_name_len = strlen(dev_name);
1347
+
req->dev_name = malloc(req->_present.dev_name_len + 1);
1348
+
memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
1349
+
req->dev_name[req->_present.dev_name_len] = 0;
1350
+
}
1351
+
static inline void
1352
+
devlink_health_reporter_set_req_set_port_index(struct devlink_health_reporter_set_req *req,
1353
+
__u32 port_index)
1354
+
{
1355
+
req->_present.port_index = 1;
1356
+
req->port_index = port_index;
1357
+
}
1358
+
static inline void
1359
+
devlink_health_reporter_set_req_set_health_reporter_name(struct devlink_health_reporter_set_req *req,
1360
+
const char *health_reporter_name)
1361
+
{
1362
+
free(req->health_reporter_name);
1363
+
req->_present.health_reporter_name_len = strlen(health_reporter_name);
1364
+
req->health_reporter_name = malloc(req->_present.health_reporter_name_len + 1);
1365
+
memcpy(req->health_reporter_name, health_reporter_name, req->_present.health_reporter_name_len);
1366
+
req->health_reporter_name[req->_present.health_reporter_name_len] = 0;
1367
+
}
1368
+
static inline void
1369
+
devlink_health_reporter_set_req_set_health_reporter_graceful_period(struct devlink_health_reporter_set_req *req,
1370
+
__u64 health_reporter_graceful_period)
1371
+
{
1372
+
req->_present.health_reporter_graceful_period = 1;
1373
+
req->health_reporter_graceful_period = health_reporter_graceful_period;
1374
+
}
1375
+
static inline void
1376
+
devlink_health_reporter_set_req_set_health_reporter_auto_recover(struct devlink_health_reporter_set_req *req,
1377
+
__u8 health_reporter_auto_recover)
1378
+
{
1379
+
req->_present.health_reporter_auto_recover = 1;
1380
+
req->health_reporter_auto_recover = health_reporter_auto_recover;
1381
+
}
1382
+
static inline void
1383
+
devlink_health_reporter_set_req_set_health_reporter_auto_dump(struct devlink_health_reporter_set_req *req,
1384
+
__u8 health_reporter_auto_dump)
1385
+
{
1386
+
req->_present.health_reporter_auto_dump = 1;
1387
+
req->health_reporter_auto_dump = health_reporter_auto_dump;
1388
+
}
1389
+
1390
+
/*
1391
+
* Set health reporter instances.
1392
+
*/
1393
+
int devlink_health_reporter_set(struct ynl_sock *ys,
1394
+
struct devlink_health_reporter_set_req *req);
1395
+
1396
+
/* ============== DEVLINK_CMD_HEALTH_REPORTER_RECOVER ============== */
1397
+
/* DEVLINK_CMD_HEALTH_REPORTER_RECOVER - do */
1398
+
struct devlink_health_reporter_recover_req {
1399
+
struct {
1400
+
__u32 bus_name_len;
1401
+
__u32 dev_name_len;
1402
+
__u32 port_index:1;
1403
+
__u32 health_reporter_name_len;
1404
+
} _present;
1405
+
1406
+
char *bus_name;
1407
+
char *dev_name;
1408
+
__u32 port_index;
1409
+
char *health_reporter_name;
1410
+
};
1411
+
1412
+
static inline struct devlink_health_reporter_recover_req *
1413
+
devlink_health_reporter_recover_req_alloc(void)
1414
+
{
1415
+
return calloc(1, sizeof(struct devlink_health_reporter_recover_req));
1416
+
}
1417
+
void
1418
+
devlink_health_reporter_recover_req_free(struct devlink_health_reporter_recover_req *req);
1419
+
1420
+
static inline void
1421
+
devlink_health_reporter_recover_req_set_bus_name(struct devlink_health_reporter_recover_req *req,
1422
+
const char *bus_name)
1423
+
{
1424
+
free(req->bus_name);
1425
+
req->_present.bus_name_len = strlen(bus_name);
1426
+
req->bus_name = malloc(req->_present.bus_name_len + 1);
1427
+
memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
1428
+
req->bus_name[req->_present.bus_name_len] = 0;
1429
+
}
1430
+
static inline void
1431
+
devlink_health_reporter_recover_req_set_dev_name(struct devlink_health_reporter_recover_req *req,
1432
+
const char *dev_name)
1433
+
{
1434
+
free(req->dev_name);
1435
+
req->_present.dev_name_len = strlen(dev_name);
1436
+
req->dev_name = malloc(req->_present.dev_name_len + 1);
1437
+
memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
1438
+
req->dev_name[req->_present.dev_name_len] = 0;
1439
+
}
1440
+
static inline void
1441
+
devlink_health_reporter_recover_req_set_port_index(struct devlink_health_reporter_recover_req *req,
1442
+
__u32 port_index)
1443
+
{
1444
+
req->_present.port_index = 1;
1445
+
req->port_index = port_index;
1446
+
}
1447
+
static inline void
1448
+
devlink_health_reporter_recover_req_set_health_reporter_name(struct devlink_health_reporter_recover_req *req,
1449
+
const char *health_reporter_name)
1450
+
{
1451
+
free(req->health_reporter_name);
1452
+
req->_present.health_reporter_name_len = strlen(health_reporter_name);
1453
+
req->health_reporter_name = malloc(req->_present.health_reporter_name_len + 1);
1454
+
memcpy(req->health_reporter_name, health_reporter_name, req->_present.health_reporter_name_len);
1455
+
req->health_reporter_name[req->_present.health_reporter_name_len] = 0;
1456
+
}
1457
+
1458
+
/*
1459
+
* Recover health reporter instances.
1460
+
*/
1461
+
int devlink_health_reporter_recover(struct ynl_sock *ys,
1462
+
struct devlink_health_reporter_recover_req *req);
1463
+
1464
+
/* ============== DEVLINK_CMD_HEALTH_REPORTER_DIAGNOSE ============== */
1465
+
/* DEVLINK_CMD_HEALTH_REPORTER_DIAGNOSE - do */
1466
+
struct devlink_health_reporter_diagnose_req {
1467
+
struct {
1468
+
__u32 bus_name_len;
1469
+
__u32 dev_name_len;
1470
+
__u32 port_index:1;
1471
+
__u32 health_reporter_name_len;
1472
+
} _present;
1473
+
1474
+
char *bus_name;
1475
+
char *dev_name;
1476
+
__u32 port_index;
1477
+
char *health_reporter_name;
1478
+
};
1479
+
1480
+
static inline struct devlink_health_reporter_diagnose_req *
1481
+
devlink_health_reporter_diagnose_req_alloc(void)
1482
+
{
1483
+
return calloc(1, sizeof(struct devlink_health_reporter_diagnose_req));
1484
+
}
1485
+
void
1486
+
devlink_health_reporter_diagnose_req_free(struct devlink_health_reporter_diagnose_req *req);
1487
+
1488
+
static inline void
1489
+
devlink_health_reporter_diagnose_req_set_bus_name(struct devlink_health_reporter_diagnose_req *req,
1490
+
const char *bus_name)
1491
+
{
1492
+
free(req->bus_name);
1493
+
req->_present.bus_name_len = strlen(bus_name);
1494
+
req->bus_name = malloc(req->_present.bus_name_len + 1);
1495
+
memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
1496
+
req->bus_name[req->_present.bus_name_len] = 0;
1497
+
}
1498
+
static inline void
1499
+
devlink_health_reporter_diagnose_req_set_dev_name(struct devlink_health_reporter_diagnose_req *req,
1500
+
const char *dev_name)
1501
+
{
1502
+
free(req->dev_name);
1503
+
req->_present.dev_name_len = strlen(dev_name);
1504
+
req->dev_name = malloc(req->_present.dev_name_len + 1);
1505
+
memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
1506
+
req->dev_name[req->_present.dev_name_len] = 0;
1507
+
}
1508
+
static inline void
1509
+
devlink_health_reporter_diagnose_req_set_port_index(struct devlink_health_reporter_diagnose_req *req,
1510
+
__u32 port_index)
1511
+
{
1512
+
req->_present.port_index = 1;
1513
+
req->port_index = port_index;
1514
+
}
1515
+
static inline void
1516
+
devlink_health_reporter_diagnose_req_set_health_reporter_name(struct devlink_health_reporter_diagnose_req *req,
1517
+
const char *health_reporter_name)
1518
+
{
1519
+
free(req->health_reporter_name);
1520
+
req->_present.health_reporter_name_len = strlen(health_reporter_name);
1521
+
req->health_reporter_name = malloc(req->_present.health_reporter_name_len + 1);
1522
+
memcpy(req->health_reporter_name, health_reporter_name, req->_present.health_reporter_name_len);
1523
+
req->health_reporter_name[req->_present.health_reporter_name_len] = 0;
1524
+
}
1525
+
1526
+
/*
1527
+
* Diagnose health reporter instances.
1528
+
*/
1529
+
int devlink_health_reporter_diagnose(struct ynl_sock *ys,
1530
+
struct devlink_health_reporter_diagnose_req *req);
1531
+
1532
+
/* ============== DEVLINK_CMD_HEALTH_REPORTER_DUMP_GET ============== */
1533
+
/* DEVLINK_CMD_HEALTH_REPORTER_DUMP_GET - dump */
1534
+
struct devlink_health_reporter_dump_get_req_dump {
1535
+
struct {
1536
+
__u32 bus_name_len;
1537
+
__u32 dev_name_len;
1538
+
__u32 port_index:1;
1539
+
__u32 health_reporter_name_len;
1540
+
} _present;
1541
+
1542
+
char *bus_name;
1543
+
char *dev_name;
1544
+
__u32 port_index;
1545
+
char *health_reporter_name;
1546
+
};
1547
+
1548
+
static inline struct devlink_health_reporter_dump_get_req_dump *
1549
+
devlink_health_reporter_dump_get_req_dump_alloc(void)
1550
+
{
1551
+
return calloc(1, sizeof(struct devlink_health_reporter_dump_get_req_dump));
1552
+
}
1553
+
void
1554
+
devlink_health_reporter_dump_get_req_dump_free(struct devlink_health_reporter_dump_get_req_dump *req);
1555
+
1556
+
static inline void
1557
+
devlink_health_reporter_dump_get_req_dump_set_bus_name(struct devlink_health_reporter_dump_get_req_dump *req,
1558
+
const char *bus_name)
1559
+
{
1560
+
free(req->bus_name);
1561
+
req->_present.bus_name_len = strlen(bus_name);
1562
+
req->bus_name = malloc(req->_present.bus_name_len + 1);
1563
+
memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
1564
+
req->bus_name[req->_present.bus_name_len] = 0;
1565
+
}
1566
+
static inline void
1567
+
devlink_health_reporter_dump_get_req_dump_set_dev_name(struct devlink_health_reporter_dump_get_req_dump *req,
1568
+
const char *dev_name)
1569
+
{
1570
+
free(req->dev_name);
1571
+
req->_present.dev_name_len = strlen(dev_name);
1572
+
req->dev_name = malloc(req->_present.dev_name_len + 1);
1573
+
memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
1574
+
req->dev_name[req->_present.dev_name_len] = 0;
1575
+
}
1576
+
static inline void
1577
+
devlink_health_reporter_dump_get_req_dump_set_port_index(struct devlink_health_reporter_dump_get_req_dump *req,
1578
+
__u32 port_index)
1579
+
{
1580
+
req->_present.port_index = 1;
1581
+
req->port_index = port_index;
1582
+
}
1583
+
static inline void
1584
+
devlink_health_reporter_dump_get_req_dump_set_health_reporter_name(struct devlink_health_reporter_dump_get_req_dump *req,
1585
+
const char *health_reporter_name)
1586
+
{
1587
+
free(req->health_reporter_name);
1588
+
req->_present.health_reporter_name_len = strlen(health_reporter_name);
1589
+
req->health_reporter_name = malloc(req->_present.health_reporter_name_len + 1);
1590
+
memcpy(req->health_reporter_name, health_reporter_name, req->_present.health_reporter_name_len);
1591
+
req->health_reporter_name[req->_present.health_reporter_name_len] = 0;
1592
+
}
1593
+
1594
+
struct devlink_health_reporter_dump_get_rsp_dump {
1595
+
struct {
1596
+
__u32 fmsg:1;
1597
+
} _present;
1598
+
1599
+
struct devlink_dl_fmsg fmsg;
1600
+
};
1601
+
1602
+
struct devlink_health_reporter_dump_get_rsp_list {
1603
+
struct devlink_health_reporter_dump_get_rsp_list *next;
1604
+
struct devlink_health_reporter_dump_get_rsp_dump obj __attribute__((aligned(8)));
1605
+
};
1606
+
1607
+
void
1608
+
devlink_health_reporter_dump_get_rsp_list_free(struct devlink_health_reporter_dump_get_rsp_list *rsp);
1609
+
1610
+
struct devlink_health_reporter_dump_get_rsp_list *
1611
+
devlink_health_reporter_dump_get_dump(struct ynl_sock *ys,
1612
+
struct devlink_health_reporter_dump_get_req_dump *req);
1613
+
1614
+
/* ============== DEVLINK_CMD_HEALTH_REPORTER_DUMP_CLEAR ============== */
1615
+
/* DEVLINK_CMD_HEALTH_REPORTER_DUMP_CLEAR - do */
1616
+
struct devlink_health_reporter_dump_clear_req {
1617
+
struct {
1618
+
__u32 bus_name_len;
1619
+
__u32 dev_name_len;
1620
+
__u32 port_index:1;
1621
+
__u32 health_reporter_name_len;
1622
+
} _present;
1623
+
1624
+
char *bus_name;
1625
+
char *dev_name;
1626
+
__u32 port_index;
1627
+
char *health_reporter_name;
1628
+
};
1629
+
1630
+
static inline struct devlink_health_reporter_dump_clear_req *
1631
+
devlink_health_reporter_dump_clear_req_alloc(void)
1632
+
{
1633
+
return calloc(1, sizeof(struct devlink_health_reporter_dump_clear_req));
1634
+
}
1635
+
void
1636
+
devlink_health_reporter_dump_clear_req_free(struct devlink_health_reporter_dump_clear_req *req);
1637
+
1638
+
static inline void
1639
+
devlink_health_reporter_dump_clear_req_set_bus_name(struct devlink_health_reporter_dump_clear_req *req,
1640
+
const char *bus_name)
1641
+
{
1642
+
free(req->bus_name);
1643
+
req->_present.bus_name_len = strlen(bus_name);
1644
+
req->bus_name = malloc(req->_present.bus_name_len + 1);
1645
+
memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
1646
+
req->bus_name[req->_present.bus_name_len] = 0;
1647
+
}
1648
+
static inline void
1649
+
devlink_health_reporter_dump_clear_req_set_dev_name(struct devlink_health_reporter_dump_clear_req *req,
1650
+
const char *dev_name)
1651
+
{
1652
+
free(req->dev_name);
1653
+
req->_present.dev_name_len = strlen(dev_name);
1654
+
req->dev_name = malloc(req->_present.dev_name_len + 1);
1655
+
memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
1656
+
req->dev_name[req->_present.dev_name_len] = 0;
1657
+
}
1658
+
static inline void
1659
+
devlink_health_reporter_dump_clear_req_set_port_index(struct devlink_health_reporter_dump_clear_req *req,
1660
+
__u32 port_index)
1661
+
{
1662
+
req->_present.port_index = 1;
1663
+
req->port_index = port_index;
1664
+
}
1665
+
static inline void
1666
+
devlink_health_reporter_dump_clear_req_set_health_reporter_name(struct devlink_health_reporter_dump_clear_req *req,
1667
+
const char *health_reporter_name)
1668
+
{
1669
+
free(req->health_reporter_name);
1670
+
req->_present.health_reporter_name_len = strlen(health_reporter_name);
1671
+
req->health_reporter_name = malloc(req->_present.health_reporter_name_len + 1);
1672
+
memcpy(req->health_reporter_name, health_reporter_name, req->_present.health_reporter_name_len);
1673
+
req->health_reporter_name[req->_present.health_reporter_name_len] = 0;
1674
+
}
1675
+
1676
+
/*
1677
+
* Clear dump of health reporter instances.
1678
+
*/
1679
+
int devlink_health_reporter_dump_clear(struct ynl_sock *ys,
1680
+
struct devlink_health_reporter_dump_clear_req *req);
1681
+
1682
+
/* ============== DEVLINK_CMD_FLASH_UPDATE ============== */
1683
+
/* DEVLINK_CMD_FLASH_UPDATE - do */
1684
+
struct devlink_flash_update_req {
1685
+
struct {
1686
+
__u32 bus_name_len;
1687
+
__u32 dev_name_len;
1688
+
__u32 flash_update_file_name_len;
1689
+
__u32 flash_update_component_len;
1690
+
__u32 flash_update_overwrite_mask:1;
1691
+
} _present;
1692
+
1693
+
char *bus_name;
1694
+
char *dev_name;
1695
+
char *flash_update_file_name;
1696
+
char *flash_update_component;
1697
+
struct nla_bitfield32 flash_update_overwrite_mask;
1698
+
};
1699
+
1700
+
static inline struct devlink_flash_update_req *
1701
+
devlink_flash_update_req_alloc(void)
1702
+
{
1703
+
return calloc(1, sizeof(struct devlink_flash_update_req));
1704
+
}
1705
+
void devlink_flash_update_req_free(struct devlink_flash_update_req *req);
1706
+
1707
+
static inline void
1708
+
devlink_flash_update_req_set_bus_name(struct devlink_flash_update_req *req,
1709
+
const char *bus_name)
1710
+
{
1711
+
free(req->bus_name);
1712
+
req->_present.bus_name_len = strlen(bus_name);
1713
+
req->bus_name = malloc(req->_present.bus_name_len + 1);
1714
+
memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
1715
+
req->bus_name[req->_present.bus_name_len] = 0;
1716
+
}
1717
+
static inline void
1718
+
devlink_flash_update_req_set_dev_name(struct devlink_flash_update_req *req,
1719
+
const char *dev_name)
1720
+
{
1721
+
free(req->dev_name);
1722
+
req->_present.dev_name_len = strlen(dev_name);
1723
+
req->dev_name = malloc(req->_present.dev_name_len + 1);
1724
+
memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
1725
+
req->dev_name[req->_present.dev_name_len] = 0;
1726
+
}
1727
+
static inline void
1728
+
devlink_flash_update_req_set_flash_update_file_name(struct devlink_flash_update_req *req,
1729
+
const char *flash_update_file_name)
1730
+
{
1731
+
free(req->flash_update_file_name);
1732
+
req->_present.flash_update_file_name_len = strlen(flash_update_file_name);
1733
+
req->flash_update_file_name = malloc(req->_present.flash_update_file_name_len + 1);
1734
+
memcpy(req->flash_update_file_name, flash_update_file_name, req->_present.flash_update_file_name_len);
1735
+
req->flash_update_file_name[req->_present.flash_update_file_name_len] = 0;
1736
+
}
1737
+
static inline void
1738
+
devlink_flash_update_req_set_flash_update_component(struct devlink_flash_update_req *req,
1739
+
const char *flash_update_component)
1740
+
{
1741
+
free(req->flash_update_component);
1742
+
req->_present.flash_update_component_len = strlen(flash_update_component);
1743
+
req->flash_update_component = malloc(req->_present.flash_update_component_len + 1);
1744
+
memcpy(req->flash_update_component, flash_update_component, req->_present.flash_update_component_len);
1745
+
req->flash_update_component[req->_present.flash_update_component_len] = 0;
1746
+
}
1747
+
static inline void
1748
+
devlink_flash_update_req_set_flash_update_overwrite_mask(struct devlink_flash_update_req *req,
1749
+
struct nla_bitfield32 *flash_update_overwrite_mask)
1750
+
{
1751
+
req->_present.flash_update_overwrite_mask = 1;
1752
+
memcpy(&req->flash_update_overwrite_mask, flash_update_overwrite_mask, sizeof(struct nla_bitfield32));
1753
+
}
1754
+
1755
+
/*
1756
+
* Flash update devlink instances.
1757
+
*/
1758
+
int devlink_flash_update(struct ynl_sock *ys,
1759
+
struct devlink_flash_update_req *req);
1760
+
3436
1761
/* ============== DEVLINK_CMD_TRAP_GET ============== */
3437
1762
/* DEVLINK_CMD_TRAP_GET - do */
3438
1763
struct devlink_trap_get_req {
···
4013
1418
struct devlink_trap_get_list *
4014
1419
devlink_trap_get_dump(struct ynl_sock *ys,
4015
1420
struct devlink_trap_get_req_dump *req);
1421
+
1422
+
/* ============== DEVLINK_CMD_TRAP_SET ============== */
1423
+
/* DEVLINK_CMD_TRAP_SET - do */
1424
+
struct devlink_trap_set_req {
1425
+
struct {
1426
+
__u32 bus_name_len;
1427
+
__u32 dev_name_len;
1428
+
__u32 trap_name_len;
1429
+
__u32 trap_action:1;
1430
+
} _present;
1431
+
1432
+
char *bus_name;
1433
+
char *dev_name;
1434
+
char *trap_name;
1435
+
enum devlink_trap_action trap_action;
1436
+
};
1437
+
1438
+
static inline struct devlink_trap_set_req *devlink_trap_set_req_alloc(void)
1439
+
{
1440
+
return calloc(1, sizeof(struct devlink_trap_set_req));
1441
+
}
1442
+
void devlink_trap_set_req_free(struct devlink_trap_set_req *req);
1443
+
1444
+
static inline void
1445
+
devlink_trap_set_req_set_bus_name(struct devlink_trap_set_req *req,
1446
+
const char *bus_name)
1447
+
{
1448
+
free(req->bus_name);
1449
+
req->_present.bus_name_len = strlen(bus_name);
1450
+
req->bus_name = malloc(req->_present.bus_name_len + 1);
1451
+
memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
1452
+
req->bus_name[req->_present.bus_name_len] = 0;
1453
+
}
1454
+
static inline void
1455
+
devlink_trap_set_req_set_dev_name(struct devlink_trap_set_req *req,
1456
+
const char *dev_name)
1457
+
{
1458
+
free(req->dev_name);
1459
+
req->_present.dev_name_len = strlen(dev_name);
1460
+
req->dev_name = malloc(req->_present.dev_name_len + 1);
1461
+
memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
1462
+
req->dev_name[req->_present.dev_name_len] = 0;
1463
+
}
1464
+
static inline void
1465
+
devlink_trap_set_req_set_trap_name(struct devlink_trap_set_req *req,
1466
+
const char *trap_name)
1467
+
{
1468
+
free(req->trap_name);
1469
+
req->_present.trap_name_len = strlen(trap_name);
1470
+
req->trap_name = malloc(req->_present.trap_name_len + 1);
1471
+
memcpy(req->trap_name, trap_name, req->_present.trap_name_len);
1472
+
req->trap_name[req->_present.trap_name_len] = 0;
1473
+
}
1474
+
static inline void
1475
+
devlink_trap_set_req_set_trap_action(struct devlink_trap_set_req *req,
1476
+
enum devlink_trap_action trap_action)
1477
+
{
1478
+
req->_present.trap_action = 1;
1479
+
req->trap_action = trap_action;
1480
+
}
1481
+
1482
+
/*
1483
+
* Set trap instances.
1484
+
*/
1485
+
int devlink_trap_set(struct ynl_sock *ys, struct devlink_trap_set_req *req);
4016
1486
4017
1487
/* ============== DEVLINK_CMD_TRAP_GROUP_GET ============== */
4018
1488
/* DEVLINK_CMD_TRAP_GROUP_GET - do */
···
4203
1543
devlink_trap_group_get_dump(struct ynl_sock *ys,
4204
1544
struct devlink_trap_group_get_req_dump *req);
4205
1545
1546
+
/* ============== DEVLINK_CMD_TRAP_GROUP_SET ============== */
1547
+
/* DEVLINK_CMD_TRAP_GROUP_SET - do */
1548
+
struct devlink_trap_group_set_req {
1549
+
struct {
1550
+
__u32 bus_name_len;
1551
+
__u32 dev_name_len;
1552
+
__u32 trap_group_name_len;
1553
+
__u32 trap_action:1;
1554
+
__u32 trap_policer_id:1;
1555
+
} _present;
1556
+
1557
+
char *bus_name;
1558
+
char *dev_name;
1559
+
char *trap_group_name;
1560
+
enum devlink_trap_action trap_action;
1561
+
__u32 trap_policer_id;
1562
+
};
1563
+
1564
+
static inline struct devlink_trap_group_set_req *
1565
+
devlink_trap_group_set_req_alloc(void)
1566
+
{
1567
+
return calloc(1, sizeof(struct devlink_trap_group_set_req));
1568
+
}
1569
+
void devlink_trap_group_set_req_free(struct devlink_trap_group_set_req *req);
1570
+
1571
+
static inline void
1572
+
devlink_trap_group_set_req_set_bus_name(struct devlink_trap_group_set_req *req,
1573
+
const char *bus_name)
1574
+
{
1575
+
free(req->bus_name);
1576
+
req->_present.bus_name_len = strlen(bus_name);
1577
+
req->bus_name = malloc(req->_present.bus_name_len + 1);
1578
+
memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
1579
+
req->bus_name[req->_present.bus_name_len] = 0;
1580
+
}
1581
+
static inline void
1582
+
devlink_trap_group_set_req_set_dev_name(struct devlink_trap_group_set_req *req,
1583
+
const char *dev_name)
1584
+
{
1585
+
free(req->dev_name);
1586
+
req->_present.dev_name_len = strlen(dev_name);
1587
+
req->dev_name = malloc(req->_present.dev_name_len + 1);
1588
+
memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
1589
+
req->dev_name[req->_present.dev_name_len] = 0;
1590
+
}
1591
+
static inline void
1592
+
devlink_trap_group_set_req_set_trap_group_name(struct devlink_trap_group_set_req *req,
1593
+
const char *trap_group_name)
1594
+
{
1595
+
free(req->trap_group_name);
1596
+
req->_present.trap_group_name_len = strlen(trap_group_name);
1597
+
req->trap_group_name = malloc(req->_present.trap_group_name_len + 1);
1598
+
memcpy(req->trap_group_name, trap_group_name, req->_present.trap_group_name_len);
1599
+
req->trap_group_name[req->_present.trap_group_name_len] = 0;
1600
+
}
1601
+
static inline void
1602
+
devlink_trap_group_set_req_set_trap_action(struct devlink_trap_group_set_req *req,
1603
+
enum devlink_trap_action trap_action)
1604
+
{
1605
+
req->_present.trap_action = 1;
1606
+
req->trap_action = trap_action;
1607
+
}
1608
+
static inline void
1609
+
devlink_trap_group_set_req_set_trap_policer_id(struct devlink_trap_group_set_req *req,
1610
+
__u32 trap_policer_id)
1611
+
{
1612
+
req->_present.trap_policer_id = 1;
1613
+
req->trap_policer_id = trap_policer_id;
1614
+
}
1615
+
1616
+
/*
1617
+
* Set trap group instances.
1618
+
*/
1619
+
int devlink_trap_group_set(struct ynl_sock *ys,
1620
+
struct devlink_trap_group_set_req *req);
1621
+
4206
1622
/* ============== DEVLINK_CMD_TRAP_POLICER_GET ============== */
4207
1623
/* DEVLINK_CMD_TRAP_POLICER_GET - do */
4208
1624
struct devlink_trap_policer_get_req {
···
4402
1666
struct devlink_trap_policer_get_list *
4403
1667
devlink_trap_policer_get_dump(struct ynl_sock *ys,
4404
1668
struct devlink_trap_policer_get_req_dump *req);
1669
+
1670
+
/* ============== DEVLINK_CMD_TRAP_POLICER_SET ============== */
1671
+
/* DEVLINK_CMD_TRAP_POLICER_SET - do */
1672
+
struct devlink_trap_policer_set_req {
1673
+
struct {
1674
+
__u32 bus_name_len;
1675
+
__u32 dev_name_len;
1676
+
__u32 trap_policer_id:1;
1677
+
__u32 trap_policer_rate:1;
1678
+
__u32 trap_policer_burst:1;
1679
+
} _present;
1680
+
1681
+
char *bus_name;
1682
+
char *dev_name;
1683
+
__u32 trap_policer_id;
1684
+
__u64 trap_policer_rate;
1685
+
__u64 trap_policer_burst;
1686
+
};
1687
+
1688
+
static inline struct devlink_trap_policer_set_req *
1689
+
devlink_trap_policer_set_req_alloc(void)
1690
+
{
1691
+
return calloc(1, sizeof(struct devlink_trap_policer_set_req));
1692
+
}
1693
+
void
1694
+
devlink_trap_policer_set_req_free(struct devlink_trap_policer_set_req *req);
1695
+
1696
+
static inline void
1697
+
devlink_trap_policer_set_req_set_bus_name(struct devlink_trap_policer_set_req *req,
1698
+
const char *bus_name)
1699
+
{
1700
+
free(req->bus_name);
1701
+
req->_present.bus_name_len = strlen(bus_name);
1702
+
req->bus_name = malloc(req->_present.bus_name_len + 1);
1703
+
memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
1704
+
req->bus_name[req->_present.bus_name_len] = 0;
1705
+
}
1706
+
static inline void
1707
+
devlink_trap_policer_set_req_set_dev_name(struct devlink_trap_policer_set_req *req,
1708
+
const char *dev_name)
1709
+
{
1710
+
free(req->dev_name);
1711
+
req->_present.dev_name_len = strlen(dev_name);
1712
+
req->dev_name = malloc(req->_present.dev_name_len + 1);
1713
+
memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
1714
+
req->dev_name[req->_present.dev_name_len] = 0;
1715
+
}
1716
+
static inline void
1717
+
devlink_trap_policer_set_req_set_trap_policer_id(struct devlink_trap_policer_set_req *req,
1718
+
__u32 trap_policer_id)
1719
+
{
1720
+
req->_present.trap_policer_id = 1;
1721
+
req->trap_policer_id = trap_policer_id;
1722
+
}
1723
+
static inline void
1724
+
devlink_trap_policer_set_req_set_trap_policer_rate(struct devlink_trap_policer_set_req *req,
1725
+
__u64 trap_policer_rate)
1726
+
{
1727
+
req->_present.trap_policer_rate = 1;
1728
+
req->trap_policer_rate = trap_policer_rate;
1729
+
}
1730
+
static inline void
1731
+
devlink_trap_policer_set_req_set_trap_policer_burst(struct devlink_trap_policer_set_req *req,
1732
+
__u64 trap_policer_burst)
1733
+
{
1734
+
req->_present.trap_policer_burst = 1;
1735
+
req->trap_policer_burst = trap_policer_burst;
1736
+
}
1737
+
1738
+
/*
1739
+
* Get trap policer instances.
1740
+
*/
1741
+
int devlink_trap_policer_set(struct ynl_sock *ys,
1742
+
struct devlink_trap_policer_set_req *req);
1743
+
1744
+
/* ============== DEVLINK_CMD_HEALTH_REPORTER_TEST ============== */
1745
+
/* DEVLINK_CMD_HEALTH_REPORTER_TEST - do */
1746
+
struct devlink_health_reporter_test_req {
1747
+
struct {
1748
+
__u32 bus_name_len;
1749
+
__u32 dev_name_len;
1750
+
__u32 port_index:1;
1751
+
__u32 health_reporter_name_len;
1752
+
} _present;
1753
+
1754
+
char *bus_name;
1755
+
char *dev_name;
1756
+
__u32 port_index;
1757
+
char *health_reporter_name;
1758
+
};
1759
+
1760
+
static inline struct devlink_health_reporter_test_req *
1761
+
devlink_health_reporter_test_req_alloc(void)
1762
+
{
1763
+
return calloc(1, sizeof(struct devlink_health_reporter_test_req));
1764
+
}
1765
+
void
1766
+
devlink_health_reporter_test_req_free(struct devlink_health_reporter_test_req *req);
1767
+
1768
+
static inline void
1769
+
devlink_health_reporter_test_req_set_bus_name(struct devlink_health_reporter_test_req *req,
1770
+
const char *bus_name)
1771
+
{
1772
+
free(req->bus_name);
1773
+
req->_present.bus_name_len = strlen(bus_name);
1774
+
req->bus_name = malloc(req->_present.bus_name_len + 1);
1775
+
memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
1776
+
req->bus_name[req->_present.bus_name_len] = 0;
1777
+
}
1778
+
static inline void
1779
+
devlink_health_reporter_test_req_set_dev_name(struct devlink_health_reporter_test_req *req,
1780
+
const char *dev_name)
1781
+
{
1782
+
free(req->dev_name);
1783
+
req->_present.dev_name_len = strlen(dev_name);
1784
+
req->dev_name = malloc(req->_present.dev_name_len + 1);
1785
+
memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
1786
+
req->dev_name[req->_present.dev_name_len] = 0;
1787
+
}
1788
+
static inline void
1789
+
devlink_health_reporter_test_req_set_port_index(struct devlink_health_reporter_test_req *req,
1790
+
__u32 port_index)
1791
+
{
1792
+
req->_present.port_index = 1;
1793
+
req->port_index = port_index;
1794
+
}
1795
+
static inline void
1796
+
devlink_health_reporter_test_req_set_health_reporter_name(struct devlink_health_reporter_test_req *req,
1797
+
const char *health_reporter_name)
1798
+
{
1799
+
free(req->health_reporter_name);
1800
+
req->_present.health_reporter_name_len = strlen(health_reporter_name);
1801
+
req->health_reporter_name = malloc(req->_present.health_reporter_name_len + 1);
1802
+
memcpy(req->health_reporter_name, health_reporter_name, req->_present.health_reporter_name_len);
1803
+
req->health_reporter_name[req->_present.health_reporter_name_len] = 0;
1804
+
}
1805
+
1806
+
/*
1807
+
* Test health reporter instances.
1808
+
*/
1809
+
int devlink_health_reporter_test(struct ynl_sock *ys,
1810
+
struct devlink_health_reporter_test_req *req);
4405
1811
4406
1812
/* ============== DEVLINK_CMD_RATE_GET ============== */
4407
1813
/* DEVLINK_CMD_RATE_GET - do */
···
4677
1799
devlink_rate_get_dump(struct ynl_sock *ys,
4678
1800
struct devlink_rate_get_req_dump *req);
4679
1801
1802
+
/* ============== DEVLINK_CMD_RATE_SET ============== */
1803
+
/* DEVLINK_CMD_RATE_SET - do */
1804
+
struct devlink_rate_set_req {
1805
+
struct {
1806
+
__u32 bus_name_len;
1807
+
__u32 dev_name_len;
1808
+
__u32 rate_node_name_len;
1809
+
__u32 rate_tx_share:1;
1810
+
__u32 rate_tx_max:1;
1811
+
__u32 rate_tx_priority:1;
1812
+
__u32 rate_tx_weight:1;
1813
+
__u32 rate_parent_node_name_len;
1814
+
} _present;
1815
+
1816
+
char *bus_name;
1817
+
char *dev_name;
1818
+
char *rate_node_name;
1819
+
__u64 rate_tx_share;
1820
+
__u64 rate_tx_max;
1821
+
__u32 rate_tx_priority;
1822
+
__u32 rate_tx_weight;
1823
+
char *rate_parent_node_name;
1824
+
};
1825
+
1826
+
static inline struct devlink_rate_set_req *devlink_rate_set_req_alloc(void)
1827
+
{
1828
+
return calloc(1, sizeof(struct devlink_rate_set_req));
1829
+
}
1830
+
void devlink_rate_set_req_free(struct devlink_rate_set_req *req);
1831
+
1832
+
static inline void
1833
+
devlink_rate_set_req_set_bus_name(struct devlink_rate_set_req *req,
1834
+
const char *bus_name)
1835
+
{
1836
+
free(req->bus_name);
1837
+
req->_present.bus_name_len = strlen(bus_name);
1838
+
req->bus_name = malloc(req->_present.bus_name_len + 1);
1839
+
memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
1840
+
req->bus_name[req->_present.bus_name_len] = 0;
1841
+
}
1842
+
static inline void
1843
+
devlink_rate_set_req_set_dev_name(struct devlink_rate_set_req *req,
1844
+
const char *dev_name)
1845
+
{
1846
+
free(req->dev_name);
1847
+
req->_present.dev_name_len = strlen(dev_name);
1848
+
req->dev_name = malloc(req->_present.dev_name_len + 1);
1849
+
memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
1850
+
req->dev_name[req->_present.dev_name_len] = 0;
1851
+
}
1852
+
static inline void
1853
+
devlink_rate_set_req_set_rate_node_name(struct devlink_rate_set_req *req,
1854
+
const char *rate_node_name)
1855
+
{
1856
+
free(req->rate_node_name);
1857
+
req->_present.rate_node_name_len = strlen(rate_node_name);
1858
+
req->rate_node_name = malloc(req->_present.rate_node_name_len + 1);
1859
+
memcpy(req->rate_node_name, rate_node_name, req->_present.rate_node_name_len);
1860
+
req->rate_node_name[req->_present.rate_node_name_len] = 0;
1861
+
}
1862
+
static inline void
1863
+
devlink_rate_set_req_set_rate_tx_share(struct devlink_rate_set_req *req,
1864
+
__u64 rate_tx_share)
1865
+
{
1866
+
req->_present.rate_tx_share = 1;
1867
+
req->rate_tx_share = rate_tx_share;
1868
+
}
1869
+
static inline void
1870
+
devlink_rate_set_req_set_rate_tx_max(struct devlink_rate_set_req *req,
1871
+
__u64 rate_tx_max)
1872
+
{
1873
+
req->_present.rate_tx_max = 1;
1874
+
req->rate_tx_max = rate_tx_max;
1875
+
}
1876
+
static inline void
1877
+
devlink_rate_set_req_set_rate_tx_priority(struct devlink_rate_set_req *req,
1878
+
__u32 rate_tx_priority)
1879
+
{
1880
+
req->_present.rate_tx_priority = 1;
1881
+
req->rate_tx_priority = rate_tx_priority;
1882
+
}
1883
+
static inline void
1884
+
devlink_rate_set_req_set_rate_tx_weight(struct devlink_rate_set_req *req,
1885
+
__u32 rate_tx_weight)
1886
+
{
1887
+
req->_present.rate_tx_weight = 1;
1888
+
req->rate_tx_weight = rate_tx_weight;
1889
+
}
1890
+
static inline void
1891
+
devlink_rate_set_req_set_rate_parent_node_name(struct devlink_rate_set_req *req,
1892
+
const char *rate_parent_node_name)
1893
+
{
1894
+
free(req->rate_parent_node_name);
1895
+
req->_present.rate_parent_node_name_len = strlen(rate_parent_node_name);
1896
+
req->rate_parent_node_name = malloc(req->_present.rate_parent_node_name_len + 1);
1897
+
memcpy(req->rate_parent_node_name, rate_parent_node_name, req->_present.rate_parent_node_name_len);
1898
+
req->rate_parent_node_name[req->_present.rate_parent_node_name_len] = 0;
1899
+
}
1900
+
1901
+
/*
1902
+
* Set rate instances.
1903
+
*/
1904
+
int devlink_rate_set(struct ynl_sock *ys, struct devlink_rate_set_req *req);
1905
+
1906
+
/* ============== DEVLINK_CMD_RATE_NEW ============== */
1907
+
/* DEVLINK_CMD_RATE_NEW - do */
1908
+
struct devlink_rate_new_req {
1909
+
struct {
1910
+
__u32 bus_name_len;
1911
+
__u32 dev_name_len;
1912
+
__u32 rate_node_name_len;
1913
+
__u32 rate_tx_share:1;
1914
+
__u32 rate_tx_max:1;
1915
+
__u32 rate_tx_priority:1;
1916
+
__u32 rate_tx_weight:1;
1917
+
__u32 rate_parent_node_name_len;
1918
+
} _present;
1919
+
1920
+
char *bus_name;
1921
+
char *dev_name;
1922
+
char *rate_node_name;
1923
+
__u64 rate_tx_share;
1924
+
__u64 rate_tx_max;
1925
+
__u32 rate_tx_priority;
1926
+
__u32 rate_tx_weight;
1927
+
char *rate_parent_node_name;
1928
+
};
1929
+
1930
+
static inline struct devlink_rate_new_req *devlink_rate_new_req_alloc(void)
1931
+
{
1932
+
return calloc(1, sizeof(struct devlink_rate_new_req));
1933
+
}
1934
+
void devlink_rate_new_req_free(struct devlink_rate_new_req *req);
1935
+
1936
+
static inline void
1937
+
devlink_rate_new_req_set_bus_name(struct devlink_rate_new_req *req,
1938
+
const char *bus_name)
1939
+
{
1940
+
free(req->bus_name);
1941
+
req->_present.bus_name_len = strlen(bus_name);
1942
+
req->bus_name = malloc(req->_present.bus_name_len + 1);
1943
+
memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
1944
+
req->bus_name[req->_present.bus_name_len] = 0;
1945
+
}
1946
+
static inline void
1947
+
devlink_rate_new_req_set_dev_name(struct devlink_rate_new_req *req,
1948
+
const char *dev_name)
1949
+
{
1950
+
free(req->dev_name);
1951
+
req->_present.dev_name_len = strlen(dev_name);
1952
+
req->dev_name = malloc(req->_present.dev_name_len + 1);
1953
+
memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
1954
+
req->dev_name[req->_present.dev_name_len] = 0;
1955
+
}
1956
+
static inline void
1957
+
devlink_rate_new_req_set_rate_node_name(struct devlink_rate_new_req *req,
1958
+
const char *rate_node_name)
1959
+
{
1960
+
free(req->rate_node_name);
1961
+
req->_present.rate_node_name_len = strlen(rate_node_name);
1962
+
req->rate_node_name = malloc(req->_present.rate_node_name_len + 1);
1963
+
memcpy(req->rate_node_name, rate_node_name, req->_present.rate_node_name_len);
1964
+
req->rate_node_name[req->_present.rate_node_name_len] = 0;
1965
+
}
1966
+
static inline void
1967
+
devlink_rate_new_req_set_rate_tx_share(struct devlink_rate_new_req *req,
1968
+
__u64 rate_tx_share)
1969
+
{
1970
+
req->_present.rate_tx_share = 1;
1971
+
req->rate_tx_share = rate_tx_share;
1972
+
}
1973
+
static inline void
1974
+
devlink_rate_new_req_set_rate_tx_max(struct devlink_rate_new_req *req,
1975
+
__u64 rate_tx_max)
1976
+
{
1977
+
req->_present.rate_tx_max = 1;
1978
+
req->rate_tx_max = rate_tx_max;
1979
+
}
1980
+
static inline void
1981
+
devlink_rate_new_req_set_rate_tx_priority(struct devlink_rate_new_req *req,
1982
+
__u32 rate_tx_priority)
1983
+
{
1984
+
req->_present.rate_tx_priority = 1;
1985
+
req->rate_tx_priority = rate_tx_priority;
1986
+
}
1987
+
static inline void
1988
+
devlink_rate_new_req_set_rate_tx_weight(struct devlink_rate_new_req *req,
1989
+
__u32 rate_tx_weight)
1990
+
{
1991
+
req->_present.rate_tx_weight = 1;
1992
+
req->rate_tx_weight = rate_tx_weight;
1993
+
}
1994
+
static inline void
1995
+
devlink_rate_new_req_set_rate_parent_node_name(struct devlink_rate_new_req *req,
1996
+
const char *rate_parent_node_name)
1997
+
{
1998
+
free(req->rate_parent_node_name);
1999
+
req->_present.rate_parent_node_name_len = strlen(rate_parent_node_name);
2000
+
req->rate_parent_node_name = malloc(req->_present.rate_parent_node_name_len + 1);
2001
+
memcpy(req->rate_parent_node_name, rate_parent_node_name, req->_present.rate_parent_node_name_len);
2002
+
req->rate_parent_node_name[req->_present.rate_parent_node_name_len] = 0;
2003
+
}
2004
+
2005
+
/*
2006
+
* Create rate instances.
2007
+
*/
2008
+
int devlink_rate_new(struct ynl_sock *ys, struct devlink_rate_new_req *req);
2009
+
2010
+
/* ============== DEVLINK_CMD_RATE_DEL ============== */
2011
+
/* DEVLINK_CMD_RATE_DEL - do */
2012
+
struct devlink_rate_del_req {
2013
+
struct {
2014
+
__u32 bus_name_len;
2015
+
__u32 dev_name_len;
2016
+
__u32 rate_node_name_len;
2017
+
} _present;
2018
+
2019
+
char *bus_name;
2020
+
char *dev_name;
2021
+
char *rate_node_name;
2022
+
};
2023
+
2024
+
static inline struct devlink_rate_del_req *devlink_rate_del_req_alloc(void)
2025
+
{
2026
+
return calloc(1, sizeof(struct devlink_rate_del_req));
2027
+
}
2028
+
void devlink_rate_del_req_free(struct devlink_rate_del_req *req);
2029
+
2030
+
static inline void
2031
+
devlink_rate_del_req_set_bus_name(struct devlink_rate_del_req *req,
2032
+
const char *bus_name)
2033
+
{
2034
+
free(req->bus_name);
2035
+
req->_present.bus_name_len = strlen(bus_name);
2036
+
req->bus_name = malloc(req->_present.bus_name_len + 1);
2037
+
memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
2038
+
req->bus_name[req->_present.bus_name_len] = 0;
2039
+
}
2040
+
static inline void
2041
+
devlink_rate_del_req_set_dev_name(struct devlink_rate_del_req *req,
2042
+
const char *dev_name)
2043
+
{
2044
+
free(req->dev_name);
2045
+
req->_present.dev_name_len = strlen(dev_name);
2046
+
req->dev_name = malloc(req->_present.dev_name_len + 1);
2047
+
memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
2048
+
req->dev_name[req->_present.dev_name_len] = 0;
2049
+
}
2050
+
static inline void
2051
+
devlink_rate_del_req_set_rate_node_name(struct devlink_rate_del_req *req,
2052
+
const char *rate_node_name)
2053
+
{
2054
+
free(req->rate_node_name);
2055
+
req->_present.rate_node_name_len = strlen(rate_node_name);
2056
+
req->rate_node_name = malloc(req->_present.rate_node_name_len + 1);
2057
+
memcpy(req->rate_node_name, rate_node_name, req->_present.rate_node_name_len);
2058
+
req->rate_node_name[req->_present.rate_node_name_len] = 0;
2059
+
}
2060
+
2061
+
/*
2062
+
* Delete rate instances.
2063
+
*/
2064
+
int devlink_rate_del(struct ynl_sock *ys, struct devlink_rate_del_req *req);
2065
+
4680
2066
/* ============== DEVLINK_CMD_LINECARD_GET ============== */
4681
2067
/* DEVLINK_CMD_LINECARD_GET - do */
4682
2068
struct devlink_linecard_get_req {
···
5061
1919
devlink_linecard_get_dump(struct ynl_sock *ys,
5062
1920
struct devlink_linecard_get_req_dump *req);
5063
1921
1922
+
/* ============== DEVLINK_CMD_LINECARD_SET ============== */
1923
+
/* DEVLINK_CMD_LINECARD_SET - do */
1924
+
struct devlink_linecard_set_req {
1925
+
struct {
1926
+
__u32 bus_name_len;
1927
+
__u32 dev_name_len;
1928
+
__u32 linecard_index:1;
1929
+
__u32 linecard_type_len;
1930
+
} _present;
1931
+
1932
+
char *bus_name;
1933
+
char *dev_name;
1934
+
__u32 linecard_index;
1935
+
char *linecard_type;
1936
+
};
1937
+
1938
+
static inline struct devlink_linecard_set_req *
1939
+
devlink_linecard_set_req_alloc(void)
1940
+
{
1941
+
return calloc(1, sizeof(struct devlink_linecard_set_req));
1942
+
}
1943
+
void devlink_linecard_set_req_free(struct devlink_linecard_set_req *req);
1944
+
1945
+
static inline void
1946
+
devlink_linecard_set_req_set_bus_name(struct devlink_linecard_set_req *req,
1947
+
const char *bus_name)
1948
+
{
1949
+
free(req->bus_name);
1950
+
req->_present.bus_name_len = strlen(bus_name);
1951
+
req->bus_name = malloc(req->_present.bus_name_len + 1);
1952
+
memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
1953
+
req->bus_name[req->_present.bus_name_len] = 0;
1954
+
}
1955
+
static inline void
1956
+
devlink_linecard_set_req_set_dev_name(struct devlink_linecard_set_req *req,
1957
+
const char *dev_name)
1958
+
{
1959
+
free(req->dev_name);
1960
+
req->_present.dev_name_len = strlen(dev_name);
1961
+
req->dev_name = malloc(req->_present.dev_name_len + 1);
1962
+
memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
1963
+
req->dev_name[req->_present.dev_name_len] = 0;
1964
+
}
1965
+
static inline void
1966
+
devlink_linecard_set_req_set_linecard_index(struct devlink_linecard_set_req *req,
1967
+
__u32 linecard_index)
1968
+
{
1969
+
req->_present.linecard_index = 1;
1970
+
req->linecard_index = linecard_index;
1971
+
}
1972
+
static inline void
1973
+
devlink_linecard_set_req_set_linecard_type(struct devlink_linecard_set_req *req,
1974
+
const char *linecard_type)
1975
+
{
1976
+
free(req->linecard_type);
1977
+
req->_present.linecard_type_len = strlen(linecard_type);
1978
+
req->linecard_type = malloc(req->_present.linecard_type_len + 1);
1979
+
memcpy(req->linecard_type, linecard_type, req->_present.linecard_type_len);
1980
+
req->linecard_type[req->_present.linecard_type_len] = 0;
1981
+
}
1982
+
1983
+
/*
1984
+
* Set line card instances.
1985
+
*/
1986
+
int devlink_linecard_set(struct ynl_sock *ys,
1987
+
struct devlink_linecard_set_req *req);
1988
+
5064
1989
/* ============== DEVLINK_CMD_SELFTESTS_GET ============== */
5065
1990
/* DEVLINK_CMD_SELFTESTS_GET - do */
5066
1991
struct devlink_selftests_get_req {
···
5197
1988
5198
1989
struct devlink_selftests_get_list *
5199
1990
devlink_selftests_get_dump(struct ynl_sock *ys);
1991
+
1992
+
/* ============== DEVLINK_CMD_SELFTESTS_RUN ============== */
1993
+
/* DEVLINK_CMD_SELFTESTS_RUN - do */
1994
+
struct devlink_selftests_run_req {
1995
+
struct {
1996
+
__u32 bus_name_len;
1997
+
__u32 dev_name_len;
1998
+
__u32 selftests:1;
1999
+
} _present;
2000
+
2001
+
char *bus_name;
2002
+
char *dev_name;
2003
+
struct devlink_dl_selftest_id selftests;
2004
+
};
2005
+
2006
+
static inline struct devlink_selftests_run_req *
2007
+
devlink_selftests_run_req_alloc(void)
2008
+
{
2009
+
return calloc(1, sizeof(struct devlink_selftests_run_req));
2010
+
}
2011
+
void devlink_selftests_run_req_free(struct devlink_selftests_run_req *req);
2012
+
2013
+
static inline void
2014
+
devlink_selftests_run_req_set_bus_name(struct devlink_selftests_run_req *req,
2015
+
const char *bus_name)
2016
+
{
2017
+
free(req->bus_name);
2018
+
req->_present.bus_name_len = strlen(bus_name);
2019
+
req->bus_name = malloc(req->_present.bus_name_len + 1);
2020
+
memcpy(req->bus_name, bus_name, req->_present.bus_name_len);
2021
+
req->bus_name[req->_present.bus_name_len] = 0;
2022
+
}
2023
+
static inline void
2024
+
devlink_selftests_run_req_set_dev_name(struct devlink_selftests_run_req *req,
2025
+
const char *dev_name)
2026
+
{
2027
+
free(req->dev_name);
2028
+
req->_present.dev_name_len = strlen(dev_name);
2029
+
req->dev_name = malloc(req->_present.dev_name_len + 1);
2030
+
memcpy(req->dev_name, dev_name, req->_present.dev_name_len);
2031
+
req->dev_name[req->_present.dev_name_len] = 0;
2032
+
}
2033
+
static inline void
2034
+
devlink_selftests_run_req_set_selftests_flash(struct devlink_selftests_run_req *req)
2035
+
{
2036
+
req->_present.selftests = 1;
2037
+
req->selftests._present.flash = 1;
2038
+
}
2039
+
2040
+
/*
2041
+
* Run device selftest instances.
2042
+
*/
2043
+
int devlink_selftests_run(struct ynl_sock *ys,
2044
+
struct devlink_selftests_run_req *req);
5200
2045
5201
2046
#endif /* _LINUX_DEVLINK_GEN_H */
+6
tools/net/ynl/lib/ynl.c
+6
tools/net/ynl/lib/ynl.c
···
379
379
yerr(yarg->ys, YNL_ERROR_ATTR_INVALID,
380
380
"Invalid attribute (string %s)", policy->name);
381
381
return -1;
382
+
case YNL_PT_BITFIELD32:
383
+
if (len == sizeof(struct nla_bitfield32))
384
+
break;
385
+
yerr(yarg->ys, YNL_ERROR_ATTR_INVALID,
386
+
"Invalid attribute (bitfield32 %s)", policy->name);
387
+
return -1;
382
388
default:
383
389
yerr(yarg->ys, YNL_ERROR_ATTR_INVALID,
384
390
"Invalid attribute (unknown %s)", policy->name);
+1
tools/net/ynl/lib/ynl.h
+1
tools/net/ynl/lib/ynl.h
+10
-3
tools/net/ynl/lib/ynl.py
+10
-3
tools/net/ynl/lib/ynl.py
···
478
478
elif attr['type'] in NlAttr.type_formats:
479
479
format = NlAttr.get_format(attr['type'], attr.byte_order)
480
480
attr_payload = format.pack(int(value))
481
+
elif attr['type'] in "bitfield32":
482
+
attr_payload = struct.pack("II", int(value["value"]), int(value["selector"]))
481
483
else:
482
484
raise Exception(f'Unknown type at {space} {name} {value} {attr["type"]}')
483
485
···
547
545
decoded = attr.as_auto_scalar(attr_spec['type'], attr_spec.byte_order)
548
546
elif attr_spec["type"] in NlAttr.type_formats:
549
547
decoded = attr.as_scalar(attr_spec['type'], attr_spec.byte_order)
548
+
if 'enum' in attr_spec:
549
+
decoded = self._decode_enum(decoded, attr_spec)
550
550
elif attr_spec["type"] == 'array-nest':
551
551
decoded = self._decode_array_nest(attr, attr_spec)
552
+
elif attr_spec["type"] == 'bitfield32':
553
+
value, selector = struct.unpack("II", attr.raw)
554
+
if 'enum' in attr_spec:
555
+
value = self._decode_enum(value, attr_spec)
556
+
selector = self._decode_enum(selector, attr_spec)
557
+
decoded = {"value": value, "selector": selector}
552
558
else:
553
559
raise Exception(f'Unknown {attr_spec["type"]} with name {attr_spec["name"]}')
554
-
555
-
if 'enum' in attr_spec:
556
-
decoded = self._decode_enum(decoded, attr_spec)
557
560
558
561
if not attr_spec.is_multi:
559
562
rsp[attr_spec['name']] = decoded
+46
-4
tools/net/ynl/ynl-gen-c.py
+46
-4
tools/net/ynl/ynl-gen-c.py
···
488
488
f'memcpy({member}, {self.c_name}, {presence}_len);']
489
489
490
490
491
+
class TypeBitfield32(Type):
492
+
def _complex_member_type(self, ri):
493
+
return "struct nla_bitfield32"
494
+
495
+
def _attr_typol(self):
496
+
return f'.type = YNL_PT_BITFIELD32, '
497
+
498
+
def _attr_policy(self, policy):
499
+
if not 'enum' in self.attr:
500
+
raise Exception('Enum required for bitfield32 attr')
501
+
enum = self.family.consts[self.attr['enum']]
502
+
mask = enum.get_mask(as_flags=True)
503
+
return f"NLA_POLICY_BITFIELD32({mask})"
504
+
505
+
def attr_put(self, ri, var):
506
+
line = f"mnl_attr_put(nlh, {self.enum_name}, sizeof(struct nla_bitfield32), &{var}->{self.c_name})"
507
+
self._attr_put_line(ri, var, line)
508
+
509
+
def _attr_get(self, ri, var):
510
+
return f"memcpy(&{var}->{self.c_name}, mnl_attr_get_payload(attr), sizeof(struct nla_bitfield32));", None, None
511
+
512
+
def _setter_lines(self, ri, member, presence):
513
+
return [f"memcpy(&{member}, {self.c_name}, sizeof(struct nla_bitfield32));"]
514
+
515
+
491
516
class TypeNest(Type):
492
517
def _complex_member_type(self, ri):
493
518
return self.nested_struct_type
···
811
786
t = TypeString(self.family, self, elem, value)
812
787
elif elem['type'] == 'binary':
813
788
t = TypeBinary(self.family, self, elem, value)
789
+
elif elem['type'] == 'bitfield32':
790
+
t = TypeBitfield32(self.family, self, elem, value)
814
791
elif elem['type'] == 'nest':
815
792
t = TypeNest(self.family, self, elem, value)
816
793
elif elem['type'] == 'array-nest':
···
1112
1085
1113
1086
# 'do' and 'dump' response parsing is identical
1114
1087
self.type_consistent = True
1115
-
if op_mode != 'do' and 'dump' in op and 'do' in op:
1116
-
if ('reply' in op['do']) != ('reply' in op["dump"]):
1117
-
self.type_consistent = False
1118
-
elif 'reply' in op['do'] and op["do"]["reply"] != op["dump"]["reply"]:
1088
+
if op_mode != 'do' and 'dump' in op:
1089
+
if 'do' in op:
1090
+
if ('reply' in op['do']) != ('reply' in op["dump"]):
1091
+
self.type_consistent = False
1092
+
elif 'reply' in op['do'] and op["do"]["reply"] != op["dump"]["reply"]:
1093
+
self.type_consistent = False
1094
+
else:
1119
1095
self.type_consistent = False
1120
1096
1121
1097
self.attr_set = attr_set
···
2444
2414
cw.block_end(line=';')
2445
2415
2446
2416
2417
+
def family_contains_bitfield32(family):
2418
+
for _, attr_set in family.attr_sets.items():
2419
+
if attr_set.subset_of:
2420
+
continue
2421
+
for _, attr in attr_set.items():
2422
+
if attr.type == "bitfield32":
2423
+
return True
2424
+
return False
2425
+
2426
+
2447
2427
def find_kernel_root(full_path):
2448
2428
sub_path = ''
2449
2429
while True:
···
2539
2499
cw.p('#include <string.h>')
2540
2500
if args.header:
2541
2501
cw.p('#include <linux/types.h>')
2502
+
if family_contains_bitfield32(parsed):
2503
+
cw.p('#include <linux/netlink.h>')
2542
2504
else:
2543
2505
cw.p(f'#include "{parsed.name}-user.h"')
2544
2506
cw.p('#include "ynl.h"')