1#![doc = "Partial family for Devlink.\n"]
2#![allow(clippy::all)]
3#![allow(unused_imports)]
4#![allow(unused_assignments)]
5#![allow(non_snake_case)]
6#![allow(unused_variables)]
7#![allow(irrefutable_let_patterns)]
8#![allow(unreachable_code)]
9#![allow(unreachable_patterns)]
10use crate::builtin::{BuiltinBitfield32, BuiltinNfgenmsg, Nlmsghdr, PushDummy};
11use crate::{
12 consts,
13 traits::{NetlinkRequest, Protocol},
14 utils::*,
15};
16pub const PROTONAME: &str = "devlink";
17pub const PROTONAME_CSTR: &CStr = c"devlink";
18#[doc = "Enum - defines an integer enumeration, with values for each entry incrementing by 1, (e.g. 0, 1, 2, 3)"]
19#[derive(Debug, Clone, Copy)]
20pub enum SbPoolType {
21 Ingress = 0,
22 Egress = 1,
23}
24impl SbPoolType {
25 pub fn from_value(value: u64) -> Option<Self> {
26 Some(match value {
27 0 => Self::Ingress,
28 1 => Self::Egress,
29 _ => return None,
30 })
31 }
32}
33#[doc = "Enum - defines an integer enumeration, with values for each entry incrementing by 1, (e.g. 0, 1, 2, 3)"]
34#[derive(Debug, Clone, Copy)]
35pub enum PortType {
36 Notset = 0,
37 Auto = 1,
38 Eth = 2,
39 Ib = 3,
40}
41impl PortType {
42 pub fn from_value(value: u64) -> Option<Self> {
43 Some(match value {
44 0 => Self::Notset,
45 1 => Self::Auto,
46 2 => Self::Eth,
47 3 => Self::Ib,
48 _ => return None,
49 })
50 }
51}
52#[doc = "Enum - defines an integer enumeration, with values for each entry incrementing by 1, (e.g. 0, 1, 2, 3)"]
53#[derive(Debug, Clone, Copy)]
54pub enum PortFlavour {
55 Physical = 0,
56 Cpu = 1,
57 Dsa = 2,
58 PciPf = 3,
59 PciVf = 4,
60 Virtual = 5,
61 Unused = 6,
62 PciSf = 7,
63}
64impl PortFlavour {
65 pub fn from_value(value: u64) -> Option<Self> {
66 Some(match value {
67 0 => Self::Physical,
68 1 => Self::Cpu,
69 2 => Self::Dsa,
70 3 => Self::PciPf,
71 4 => Self::PciVf,
72 5 => Self::Virtual,
73 6 => Self::Unused,
74 7 => Self::PciSf,
75 _ => return None,
76 })
77 }
78}
79#[doc = "Enum - defines an integer enumeration, with values for each entry incrementing by 1, (e.g. 0, 1, 2, 3)"]
80#[derive(Debug, Clone, Copy)]
81pub enum PortFnState {
82 Inactive = 0,
83 Active = 1,
84}
85impl PortFnState {
86 pub fn from_value(value: u64) -> Option<Self> {
87 Some(match value {
88 0 => Self::Inactive,
89 1 => Self::Active,
90 _ => return None,
91 })
92 }
93}
94#[doc = "Enum - defines an integer enumeration, with values for each entry incrementing by 1, (e.g. 0, 1, 2, 3)"]
95#[derive(Debug, Clone, Copy)]
96pub enum PortFnOpstate {
97 Detached = 0,
98 Attached = 1,
99}
100impl PortFnOpstate {
101 pub fn from_value(value: u64) -> Option<Self> {
102 Some(match value {
103 0 => Self::Detached,
104 1 => Self::Attached,
105 _ => return None,
106 })
107 }
108}
109#[doc = "Enum - defines an integer enumeration, with values for each entry incrementing by 1, (e.g. 0, 1, 2, 3)"]
110#[derive(Debug, Clone, Copy)]
111pub enum PortFnAttrCap {
112 RoceBit = 0,
113 MigratableBit = 1,
114 IpsecCryptoBit = 2,
115 IpsecPacketBit = 3,
116}
117impl PortFnAttrCap {
118 pub fn from_value(value: u64) -> Option<Self> {
119 Some(match value {
120 0 => Self::RoceBit,
121 1 => Self::MigratableBit,
122 2 => Self::IpsecCryptoBit,
123 3 => Self::IpsecPacketBit,
124 _ => return None,
125 })
126 }
127}
128#[doc = "Enum - defines an integer enumeration, with values for each entry incrementing by 1, (e.g. 0, 1, 2, 3)"]
129#[derive(Debug, Clone, Copy)]
130pub enum RateType {
131 Leaf = 0,
132 Node = 1,
133}
134impl RateType {
135 pub fn from_value(value: u64) -> Option<Self> {
136 Some(match value {
137 0 => Self::Leaf,
138 1 => Self::Node,
139 _ => return None,
140 })
141 }
142}
143#[doc = "Enum - defines an integer enumeration, with values for each entry incrementing by 1, (e.g. 0, 1, 2, 3)"]
144#[derive(Debug, Clone, Copy)]
145pub enum SbThresholdType {
146 Static = 0,
147 Dynamic = 1,
148}
149impl SbThresholdType {
150 pub fn from_value(value: u64) -> Option<Self> {
151 Some(match value {
152 0 => Self::Static,
153 1 => Self::Dynamic,
154 _ => return None,
155 })
156 }
157}
158#[doc = "Enum - defines an integer enumeration, with values for each entry incrementing by 1, (e.g. 0, 1, 2, 3)"]
159#[derive(Debug, Clone, Copy)]
160pub enum EswitchMode {
161 Legacy = 0,
162 Switchdev = 1,
163 SwitchdevInactive = 2,
164}
165impl EswitchMode {
166 pub fn from_value(value: u64) -> Option<Self> {
167 Some(match value {
168 0 => Self::Legacy,
169 1 => Self::Switchdev,
170 2 => Self::SwitchdevInactive,
171 _ => return None,
172 })
173 }
174}
175#[doc = "Enum - defines an integer enumeration, with values for each entry incrementing by 1, (e.g. 0, 1, 2, 3)"]
176#[derive(Debug, Clone, Copy)]
177pub enum EswitchInlineMode {
178 None = 0,
179 Link = 1,
180 Network = 2,
181 Transport = 3,
182}
183impl EswitchInlineMode {
184 pub fn from_value(value: u64) -> Option<Self> {
185 Some(match value {
186 0 => Self::None,
187 1 => Self::Link,
188 2 => Self::Network,
189 3 => Self::Transport,
190 _ => return None,
191 })
192 }
193}
194#[doc = "Enum - defines an integer enumeration, with values for each entry incrementing by 1, (e.g. 0, 1, 2, 3)"]
195#[derive(Debug, Clone, Copy)]
196pub enum EswitchEncapMode {
197 None = 0,
198 Basic = 1,
199}
200impl EswitchEncapMode {
201 pub fn from_value(value: u64) -> Option<Self> {
202 Some(match value {
203 0 => Self::None,
204 1 => Self::Basic,
205 _ => return None,
206 })
207 }
208}
209#[doc = "Enum - defines an integer enumeration, with values for each entry incrementing by 1, (e.g. 0, 1, 2, 3)"]
210#[derive(Debug, Clone, Copy)]
211pub enum DpipeHeaderId {
212 Ethernet = 0,
213 Ipv4 = 1,
214 Ipv6 = 2,
215}
216impl DpipeHeaderId {
217 pub fn from_value(value: u64) -> Option<Self> {
218 Some(match value {
219 0 => Self::Ethernet,
220 1 => Self::Ipv4,
221 2 => Self::Ipv6,
222 _ => return None,
223 })
224 }
225}
226#[doc = "Enum - defines an integer enumeration, with values for each entry incrementing by 1, (e.g. 0, 1, 2, 3)"]
227#[derive(Debug, Clone, Copy)]
228pub enum DpipeMatchType {
229 FieldExact = 0,
230}
231impl DpipeMatchType {
232 pub fn from_value(value: u64) -> Option<Self> {
233 Some(match value {
234 0 => Self::FieldExact,
235 _ => return None,
236 })
237 }
238}
239#[doc = "Enum - defines an integer enumeration, with values for each entry incrementing by 1, (e.g. 0, 1, 2, 3)"]
240#[derive(Debug, Clone, Copy)]
241pub enum DpipeActionType {
242 FieldModify = 0,
243}
244impl DpipeActionType {
245 pub fn from_value(value: u64) -> Option<Self> {
246 Some(match value {
247 0 => Self::FieldModify,
248 _ => return None,
249 })
250 }
251}
252#[doc = "Enum - defines an integer enumeration, with values for each entry incrementing by 1, (e.g. 0, 1, 2, 3)"]
253#[derive(Debug, Clone, Copy)]
254pub enum DpipeFieldMappingType {
255 None = 0,
256 Ifindex = 1,
257}
258impl DpipeFieldMappingType {
259 pub fn from_value(value: u64) -> Option<Self> {
260 Some(match value {
261 0 => Self::None,
262 1 => Self::Ifindex,
263 _ => return None,
264 })
265 }
266}
267#[doc = "Enum - defines an integer enumeration, with values for each entry incrementing by 1, (e.g. 0, 1, 2, 3)"]
268#[derive(Debug, Clone, Copy)]
269pub enum ResourceUnit {
270 Entry = 0,
271}
272impl ResourceUnit {
273 pub fn from_value(value: u64) -> Option<Self> {
274 Some(match value {
275 0 => Self::Entry,
276 _ => return None,
277 })
278 }
279}
280#[doc = "Enum - defines an integer enumeration, with values for each entry incrementing by 1, (e.g. 0, 1, 2, 3)"]
281#[derive(Debug, Clone, Copy)]
282pub enum ResourceScope {
283 Dev = 0,
284 Port = 1,
285}
286impl ResourceScope {
287 pub fn from_value(value: u64) -> Option<Self> {
288 Some(match value {
289 0 => Self::Dev,
290 1 => Self::Port,
291 _ => return None,
292 })
293 }
294}
295#[doc = "Enum - defines an integer enumeration, with values for each entry incrementing by 1, (e.g. 0, 1, 2, 3)"]
296#[derive(Debug, Clone, Copy)]
297pub enum ReloadAction {
298 DriverReinit = 1,
299 FwActivate = 2,
300}
301impl ReloadAction {
302 pub fn from_value(value: u64) -> Option<Self> {
303 Some(match value {
304 1 => Self::DriverReinit,
305 2 => Self::FwActivate,
306 _ => return None,
307 })
308 }
309}
310#[doc = "Enum - defines an integer enumeration, with values for each entry incrementing by 1, (e.g. 0, 1, 2, 3)"]
311#[derive(Debug, Clone, Copy)]
312pub enum ParamCmode {
313 Runtime = 0,
314 Driverinit = 1,
315 Permanent = 2,
316}
317impl ParamCmode {
318 pub fn from_value(value: u64) -> Option<Self> {
319 Some(match value {
320 0 => Self::Runtime,
321 1 => Self::Driverinit,
322 2 => Self::Permanent,
323 _ => return None,
324 })
325 }
326}
327#[doc = "Enum - defines an integer enumeration, with values for each entry incrementing by 1, (e.g. 0, 1, 2, 3)"]
328#[derive(Debug, Clone, Copy)]
329pub enum FlashOverwrite {
330 SettingsBit = 0,
331 IdentifiersBit = 1,
332}
333impl FlashOverwrite {
334 pub fn from_value(value: u64) -> Option<Self> {
335 Some(match value {
336 0 => Self::SettingsBit,
337 1 => Self::IdentifiersBit,
338 _ => return None,
339 })
340 }
341}
342#[doc = "Enum - defines an integer enumeration, with values for each entry incrementing by 1, (e.g. 0, 1, 2, 3)"]
343#[derive(Debug, Clone, Copy)]
344pub enum TrapAction {
345 Drop = 0,
346 Trap = 1,
347 Mirror = 2,
348}
349impl TrapAction {
350 pub fn from_value(value: u64) -> Option<Self> {
351 Some(match value {
352 0 => Self::Drop,
353 1 => Self::Trap,
354 2 => Self::Mirror,
355 _ => return None,
356 })
357 }
358}
359#[doc = "Enum - defines an integer enumeration, with values for each entry incrementing by 1, (e.g. 0, 1, 2, 3)"]
360#[derive(Debug, Clone, Copy)]
361pub enum TrapType {
362 Drop = 0,
363 Exception = 1,
364 Control = 2,
365}
366impl TrapType {
367 pub fn from_value(value: u64) -> Option<Self> {
368 Some(match value {
369 0 => Self::Drop,
370 1 => Self::Exception,
371 2 => Self::Control,
372 _ => return None,
373 })
374 }
375}
376#[doc = "Enum - defines an integer enumeration, with values for each entry incrementing by 1, (e.g. 0, 1, 2, 3)"]
377#[derive(Debug, Clone, Copy)]
378pub enum VarAttrType {
379 U8 = 1,
380 U16 = 2,
381 U32 = 3,
382 U64 = 4,
383 String = 5,
384 Flag = 6,
385 NulString = 10,
386 Binary = 11,
387 U64Array = 129,
388}
389impl VarAttrType {
390 pub fn from_value(value: u64) -> Option<Self> {
391 Some(match value {
392 1 => Self::U8,
393 2 => Self::U16,
394 3 => Self::U32,
395 4 => Self::U64,
396 5 => Self::String,
397 6 => Self::Flag,
398 10 => Self::NulString,
399 11 => Self::Binary,
400 129 => Self::U64Array,
401 _ => return None,
402 })
403 }
404}
405pub const RATE_TC_INDEX_MAX: u64 = 7u64;
406#[derive(Clone)]
407pub enum Devlink<'a> {
408 BusName(&'a CStr),
409 DevName(&'a CStr),
410 PortIndex(u32),
411 #[doc = "Associated type: [`PortType`] (enum)"]
412 PortType(u16),
413 PortDesiredType(u16),
414 PortNetdevIfindex(u32),
415 PortNetdevName(&'a CStr),
416 PortIbdevName(&'a CStr),
417 PortSplitCount(u32),
418 PortSplitGroup(u32),
419 SbIndex(u32),
420 SbSize(u32),
421 SbIngressPoolCount(u16),
422 SbEgressPoolCount(u16),
423 SbIngressTcCount(u16),
424 SbEgressTcCount(u16),
425 SbPoolIndex(u16),
426 #[doc = "Associated type: [`SbPoolType`] (enum)"]
427 SbPoolType(u8),
428 SbPoolSize(u32),
429 #[doc = "Associated type: [`SbThresholdType`] (enum)"]
430 SbPoolThresholdType(u8),
431 SbThreshold(u32),
432 SbTcIndex(u16),
433 SbOccCur(u32),
434 SbOccMax(u32),
435 #[doc = "Associated type: [`EswitchMode`] (enum)"]
436 EswitchMode(u16),
437 #[doc = "Associated type: [`EswitchInlineMode`] (enum)"]
438 EswitchInlineMode(u8),
439 DpipeTables(IterableDlDpipeTables<'a>),
440 #[doc = "Attribute may repeat multiple times (treat it as array)"]
441 DpipeTable(IterableDlDpipeTable<'a>),
442 DpipeTableName(&'a CStr),
443 DpipeTableSize(u64),
444 DpipeTableMatches(IterableDlDpipeTableMatches<'a>),
445 DpipeTableActions(IterableDlDpipeTableActions<'a>),
446 DpipeTableCountersEnabled(u8),
447 DpipeEntries(IterableDlDpipeEntries<'a>),
448 #[doc = "Attribute may repeat multiple times (treat it as array)"]
449 DpipeEntry(IterableDlDpipeEntry<'a>),
450 DpipeEntryIndex(u64),
451 DpipeEntryMatchValues(IterableDlDpipeEntryMatchValues<'a>),
452 DpipeEntryActionValues(IterableDlDpipeEntryActionValues<'a>),
453 DpipeEntryCounter(u64),
454 #[doc = "Attribute may repeat multiple times (treat it as array)"]
455 DpipeMatch(IterableDlDpipeMatch<'a>),
456 #[doc = "Attribute may repeat multiple times (treat it as array)"]
457 DpipeMatchValue(IterableDlDpipeMatchValue<'a>),
458 #[doc = "Associated type: [`DpipeMatchType`] (enum)"]
459 DpipeMatchType(u32),
460 #[doc = "Attribute may repeat multiple times (treat it as array)"]
461 DpipeAction(IterableDlDpipeAction<'a>),
462 #[doc = "Attribute may repeat multiple times (treat it as array)"]
463 DpipeActionValue(IterableDlDpipeActionValue<'a>),
464 #[doc = "Associated type: [`DpipeActionType`] (enum)"]
465 DpipeActionType(u32),
466 DpipeValue(&'a [u8]),
467 DpipeValueMask(&'a [u8]),
468 DpipeValueMapping(u32),
469 DpipeHeaders(IterableDlDpipeHeaders<'a>),
470 #[doc = "Attribute may repeat multiple times (treat it as array)"]
471 DpipeHeader(IterableDlDpipeHeader<'a>),
472 DpipeHeaderName(&'a CStr),
473 #[doc = "Associated type: [`DpipeHeaderId`] (enum)"]
474 DpipeHeaderId(u32),
475 DpipeHeaderFields(IterableDlDpipeHeaderFields<'a>),
476 DpipeHeaderGlobal(u8),
477 DpipeHeaderIndex(u32),
478 #[doc = "Attribute may repeat multiple times (treat it as array)"]
479 DpipeField(IterableDlDpipeField<'a>),
480 DpipeFieldName(&'a CStr),
481 DpipeFieldId(u32),
482 DpipeFieldBitwidth(u32),
483 #[doc = "Associated type: [`DpipeFieldMappingType`] (enum)"]
484 DpipeFieldMappingType(u32),
485 Pad(&'a [u8]),
486 #[doc = "Associated type: [`EswitchEncapMode`] (enum)"]
487 EswitchEncapMode(u8),
488 ResourceList(IterableDlResourceList<'a>),
489 #[doc = "Attribute may repeat multiple times (treat it as array)"]
490 Resource(IterableDlResource<'a>),
491 ResourceName(&'a CStr),
492 ResourceId(u64),
493 ResourceSize(u64),
494 ResourceSizeNew(u64),
495 ResourceSizeValid(u8),
496 ResourceSizeMin(u64),
497 ResourceSizeMax(u64),
498 ResourceSizeGran(u64),
499 #[doc = "Associated type: [`ResourceUnit`] (enum)"]
500 ResourceUnit(u8),
501 ResourceOcc(u64),
502 DpipeTableResourceId(u64),
503 DpipeTableResourceUnits(u64),
504 #[doc = "Associated type: [`PortFlavour`] (enum)"]
505 PortFlavour(u16),
506 PortNumber(u32),
507 PortSplitSubportNumber(u32),
508 Param(IterableDlParam<'a>),
509 ParamName(&'a CStr),
510 ParamGeneric(()),
511 #[doc = "Associated type: [`VarAttrType`] (enum)"]
512 ParamType(u8),
513 #[doc = "Associated type: [`ParamCmode`] (enum)"]
514 ParamValueCmode(u8),
515 RegionName(&'a CStr),
516 RegionSize(u64),
517 RegionSnapshots(IterableDlRegionSnapshots<'a>),
518 RegionSnapshot(IterableDlRegionSnapshot<'a>),
519 RegionSnapshotId(u32),
520 RegionChunks(IterableDlRegionChunks<'a>),
521 RegionChunk(IterableDlRegionChunk<'a>),
522 RegionChunkData(&'a [u8]),
523 RegionChunkAddr(u64),
524 RegionChunkLen(u64),
525 InfoDriverName(&'a CStr),
526 InfoSerialNumber(&'a CStr),
527 #[doc = "Attribute may repeat multiple times (treat it as array)"]
528 InfoVersionFixed(IterableDlInfoVersion<'a>),
529 #[doc = "Attribute may repeat multiple times (treat it as array)"]
530 InfoVersionRunning(IterableDlInfoVersion<'a>),
531 #[doc = "Attribute may repeat multiple times (treat it as array)"]
532 InfoVersionStored(IterableDlInfoVersion<'a>),
533 InfoVersionName(&'a CStr),
534 InfoVersionValue(&'a CStr),
535 SbPoolCellSize(u32),
536 Fmsg(IterableDlFmsg<'a>),
537 FmsgObjNestStart(()),
538 FmsgPairNestStart(()),
539 FmsgArrNestStart(()),
540 FmsgNestEnd(()),
541 FmsgObjName(&'a CStr),
542 #[doc = "Associated type: [`VarAttrType`] (enum)"]
543 FmsgObjValueType(u8),
544 HealthReporter(IterableDlHealthReporter<'a>),
545 HealthReporterName(&'a CStr),
546 HealthReporterState(u8),
547 HealthReporterErrCount(u64),
548 HealthReporterRecoverCount(u64),
549 HealthReporterDumpTs(u64),
550 HealthReporterGracefulPeriod(u64),
551 HealthReporterAutoRecover(u8),
552 FlashUpdateFileName(&'a CStr),
553 FlashUpdateComponent(&'a CStr),
554 FlashUpdateStatusMsg(&'a CStr),
555 FlashUpdateStatusDone(u64),
556 FlashUpdateStatusTotal(u64),
557 PortPciPfNumber(u16),
558 PortPciVfNumber(u16),
559 Stats(IterableDlAttrStats<'a>),
560 TrapName(&'a CStr),
561 #[doc = "Associated type: [`TrapAction`] (enum)"]
562 TrapAction(u8),
563 #[doc = "Associated type: [`TrapType`] (enum)"]
564 TrapType(u8),
565 TrapGeneric(()),
566 TrapMetadata(IterableDlTrapMetadata<'a>),
567 TrapGroupName(&'a CStr),
568 ReloadFailed(u8),
569 HealthReporterDumpTsNs(u64),
570 NetnsFd(u32),
571 NetnsPid(u32),
572 NetnsId(u32),
573 HealthReporterAutoDump(u8),
574 TrapPolicerId(u32),
575 TrapPolicerRate(u64),
576 TrapPolicerBurst(u64),
577 PortFunction(IterableDlPortFunction<'a>),
578 InfoBoardSerialNumber(&'a CStr),
579 PortLanes(u32),
580 PortSplittable(u8),
581 PortExternal(u8),
582 PortControllerNumber(u32),
583 FlashUpdateStatusTimeout(u64),
584 #[doc = "Associated type: [`FlashOverwrite`] (1 bit per enumeration)"]
585 FlashUpdateOverwriteMask(BuiltinBitfield32),
586 #[doc = "Associated type: [`ReloadAction`] (enum)"]
587 ReloadAction(u8),
588 #[doc = "Associated type: [`ReloadAction`] (1 bit per enumeration)"]
589 ReloadActionsPerformed(BuiltinBitfield32),
590 #[doc = "Associated type: [`ReloadAction`] (1 bit per enumeration)"]
591 ReloadLimits(BuiltinBitfield32),
592 DevStats(IterableDlDevStats<'a>),
593 ReloadStats(IterableDlReloadStats<'a>),
594 #[doc = "Attribute may repeat multiple times (treat it as array)"]
595 ReloadStatsEntry(IterableDlReloadStatsEntry<'a>),
596 ReloadStatsLimit(u8),
597 ReloadStatsValue(u32),
598 RemoteReloadStats(IterableDlReloadStats<'a>),
599 #[doc = "Attribute may repeat multiple times (treat it as array)"]
600 ReloadActionInfo(IterableDlReloadActInfo<'a>),
601 #[doc = "Attribute may repeat multiple times (treat it as array)"]
602 ReloadActionStats(IterableDlReloadActStats<'a>),
603 PortPciSfNumber(u32),
604 #[doc = "Associated type: [`RateType`] (enum)"]
605 RateType(u16),
606 RateTxShare(u64),
607 RateTxMax(u64),
608 RateNodeName(&'a CStr),
609 RateParentNodeName(&'a CStr),
610 RegionMaxSnapshots(u32),
611 LinecardIndex(u32),
612 LinecardState(u8),
613 LinecardType(&'a CStr),
614 LinecardSupportedTypes(IterableDlLinecardSupportedTypes<'a>),
615 Selftests(IterableDlSelftestId<'a>),
616 RateTxPriority(u32),
617 RateTxWeight(u32),
618 RegionDirect(()),
619 #[doc = "Attribute may repeat multiple times (treat it as array)"]
620 RateTcBws(IterableDlRateTcBws<'a>),
621 #[doc = "Time (in msec) for recoveries before starting the grace period.\n"]
622 HealthReporterBurstPeriod(u64),
623 #[doc = "Request restoring parameter to its default value.\n"]
624 ParamResetDefault(()),
625 #[doc = "Unique devlink instance index.\n"]
626 Index(u32),
627 #[doc = "Bitmask selecting which resource classes to include in a resource-dump\nresponse. Bit 0 (dev) selects device-level resources; bit 1 (port)\nselects port-level resources. When absent all classes are returned.\n\nAssociated type: [`ResourceScope`] (1 bit per enumeration)"]
628 ResourceScopeMask(u32),
629}
630impl<'a> IterableDevlink<'a> {
631 pub fn get_bus_name(&self) -> Result<&'a CStr, ErrorContext> {
632 let mut iter = self.clone();
633 iter.pos = 0;
634 for attr in iter {
635 if let Ok(Devlink::BusName(val)) = attr {
636 return Ok(val);
637 }
638 }
639 Err(ErrorContext::new_missing(
640 "Devlink",
641 "BusName",
642 self.orig_loc,
643 self.buf.as_ptr() as usize,
644 ))
645 }
646 pub fn get_dev_name(&self) -> Result<&'a CStr, ErrorContext> {
647 let mut iter = self.clone();
648 iter.pos = 0;
649 for attr in iter {
650 if let Ok(Devlink::DevName(val)) = attr {
651 return Ok(val);
652 }
653 }
654 Err(ErrorContext::new_missing(
655 "Devlink",
656 "DevName",
657 self.orig_loc,
658 self.buf.as_ptr() as usize,
659 ))
660 }
661 pub fn get_port_index(&self) -> Result<u32, ErrorContext> {
662 let mut iter = self.clone();
663 iter.pos = 0;
664 for attr in iter {
665 if let Ok(Devlink::PortIndex(val)) = attr {
666 return Ok(val);
667 }
668 }
669 Err(ErrorContext::new_missing(
670 "Devlink",
671 "PortIndex",
672 self.orig_loc,
673 self.buf.as_ptr() as usize,
674 ))
675 }
676 #[doc = "Associated type: [`PortType`] (enum)"]
677 pub fn get_port_type(&self) -> Result<u16, ErrorContext> {
678 let mut iter = self.clone();
679 iter.pos = 0;
680 for attr in iter {
681 if let Ok(Devlink::PortType(val)) = attr {
682 return Ok(val);
683 }
684 }
685 Err(ErrorContext::new_missing(
686 "Devlink",
687 "PortType",
688 self.orig_loc,
689 self.buf.as_ptr() as usize,
690 ))
691 }
692 pub fn get_port_desired_type(&self) -> Result<u16, ErrorContext> {
693 let mut iter = self.clone();
694 iter.pos = 0;
695 for attr in iter {
696 if let Ok(Devlink::PortDesiredType(val)) = attr {
697 return Ok(val);
698 }
699 }
700 Err(ErrorContext::new_missing(
701 "Devlink",
702 "PortDesiredType",
703 self.orig_loc,
704 self.buf.as_ptr() as usize,
705 ))
706 }
707 pub fn get_port_netdev_ifindex(&self) -> Result<u32, ErrorContext> {
708 let mut iter = self.clone();
709 iter.pos = 0;
710 for attr in iter {
711 if let Ok(Devlink::PortNetdevIfindex(val)) = attr {
712 return Ok(val);
713 }
714 }
715 Err(ErrorContext::new_missing(
716 "Devlink",
717 "PortNetdevIfindex",
718 self.orig_loc,
719 self.buf.as_ptr() as usize,
720 ))
721 }
722 pub fn get_port_netdev_name(&self) -> Result<&'a CStr, ErrorContext> {
723 let mut iter = self.clone();
724 iter.pos = 0;
725 for attr in iter {
726 if let Ok(Devlink::PortNetdevName(val)) = attr {
727 return Ok(val);
728 }
729 }
730 Err(ErrorContext::new_missing(
731 "Devlink",
732 "PortNetdevName",
733 self.orig_loc,
734 self.buf.as_ptr() as usize,
735 ))
736 }
737 pub fn get_port_ibdev_name(&self) -> Result<&'a CStr, ErrorContext> {
738 let mut iter = self.clone();
739 iter.pos = 0;
740 for attr in iter {
741 if let Ok(Devlink::PortIbdevName(val)) = attr {
742 return Ok(val);
743 }
744 }
745 Err(ErrorContext::new_missing(
746 "Devlink",
747 "PortIbdevName",
748 self.orig_loc,
749 self.buf.as_ptr() as usize,
750 ))
751 }
752 pub fn get_port_split_count(&self) -> Result<u32, ErrorContext> {
753 let mut iter = self.clone();
754 iter.pos = 0;
755 for attr in iter {
756 if let Ok(Devlink::PortSplitCount(val)) = attr {
757 return Ok(val);
758 }
759 }
760 Err(ErrorContext::new_missing(
761 "Devlink",
762 "PortSplitCount",
763 self.orig_loc,
764 self.buf.as_ptr() as usize,
765 ))
766 }
767 pub fn get_port_split_group(&self) -> Result<u32, ErrorContext> {
768 let mut iter = self.clone();
769 iter.pos = 0;
770 for attr in iter {
771 if let Ok(Devlink::PortSplitGroup(val)) = attr {
772 return Ok(val);
773 }
774 }
775 Err(ErrorContext::new_missing(
776 "Devlink",
777 "PortSplitGroup",
778 self.orig_loc,
779 self.buf.as_ptr() as usize,
780 ))
781 }
782 pub fn get_sb_index(&self) -> Result<u32, ErrorContext> {
783 let mut iter = self.clone();
784 iter.pos = 0;
785 for attr in iter {
786 if let Ok(Devlink::SbIndex(val)) = attr {
787 return Ok(val);
788 }
789 }
790 Err(ErrorContext::new_missing(
791 "Devlink",
792 "SbIndex",
793 self.orig_loc,
794 self.buf.as_ptr() as usize,
795 ))
796 }
797 pub fn get_sb_size(&self) -> Result<u32, ErrorContext> {
798 let mut iter = self.clone();
799 iter.pos = 0;
800 for attr in iter {
801 if let Ok(Devlink::SbSize(val)) = attr {
802 return Ok(val);
803 }
804 }
805 Err(ErrorContext::new_missing(
806 "Devlink",
807 "SbSize",
808 self.orig_loc,
809 self.buf.as_ptr() as usize,
810 ))
811 }
812 pub fn get_sb_ingress_pool_count(&self) -> Result<u16, ErrorContext> {
813 let mut iter = self.clone();
814 iter.pos = 0;
815 for attr in iter {
816 if let Ok(Devlink::SbIngressPoolCount(val)) = attr {
817 return Ok(val);
818 }
819 }
820 Err(ErrorContext::new_missing(
821 "Devlink",
822 "SbIngressPoolCount",
823 self.orig_loc,
824 self.buf.as_ptr() as usize,
825 ))
826 }
827 pub fn get_sb_egress_pool_count(&self) -> Result<u16, ErrorContext> {
828 let mut iter = self.clone();
829 iter.pos = 0;
830 for attr in iter {
831 if let Ok(Devlink::SbEgressPoolCount(val)) = attr {
832 return Ok(val);
833 }
834 }
835 Err(ErrorContext::new_missing(
836 "Devlink",
837 "SbEgressPoolCount",
838 self.orig_loc,
839 self.buf.as_ptr() as usize,
840 ))
841 }
842 pub fn get_sb_ingress_tc_count(&self) -> Result<u16, ErrorContext> {
843 let mut iter = self.clone();
844 iter.pos = 0;
845 for attr in iter {
846 if let Ok(Devlink::SbIngressTcCount(val)) = attr {
847 return Ok(val);
848 }
849 }
850 Err(ErrorContext::new_missing(
851 "Devlink",
852 "SbIngressTcCount",
853 self.orig_loc,
854 self.buf.as_ptr() as usize,
855 ))
856 }
857 pub fn get_sb_egress_tc_count(&self) -> Result<u16, ErrorContext> {
858 let mut iter = self.clone();
859 iter.pos = 0;
860 for attr in iter {
861 if let Ok(Devlink::SbEgressTcCount(val)) = attr {
862 return Ok(val);
863 }
864 }
865 Err(ErrorContext::new_missing(
866 "Devlink",
867 "SbEgressTcCount",
868 self.orig_loc,
869 self.buf.as_ptr() as usize,
870 ))
871 }
872 pub fn get_sb_pool_index(&self) -> Result<u16, ErrorContext> {
873 let mut iter = self.clone();
874 iter.pos = 0;
875 for attr in iter {
876 if let Ok(Devlink::SbPoolIndex(val)) = attr {
877 return Ok(val);
878 }
879 }
880 Err(ErrorContext::new_missing(
881 "Devlink",
882 "SbPoolIndex",
883 self.orig_loc,
884 self.buf.as_ptr() as usize,
885 ))
886 }
887 #[doc = "Associated type: [`SbPoolType`] (enum)"]
888 pub fn get_sb_pool_type(&self) -> Result<u8, ErrorContext> {
889 let mut iter = self.clone();
890 iter.pos = 0;
891 for attr in iter {
892 if let Ok(Devlink::SbPoolType(val)) = attr {
893 return Ok(val);
894 }
895 }
896 Err(ErrorContext::new_missing(
897 "Devlink",
898 "SbPoolType",
899 self.orig_loc,
900 self.buf.as_ptr() as usize,
901 ))
902 }
903 pub fn get_sb_pool_size(&self) -> Result<u32, ErrorContext> {
904 let mut iter = self.clone();
905 iter.pos = 0;
906 for attr in iter {
907 if let Ok(Devlink::SbPoolSize(val)) = attr {
908 return Ok(val);
909 }
910 }
911 Err(ErrorContext::new_missing(
912 "Devlink",
913 "SbPoolSize",
914 self.orig_loc,
915 self.buf.as_ptr() as usize,
916 ))
917 }
918 #[doc = "Associated type: [`SbThresholdType`] (enum)"]
919 pub fn get_sb_pool_threshold_type(&self) -> Result<u8, ErrorContext> {
920 let mut iter = self.clone();
921 iter.pos = 0;
922 for attr in iter {
923 if let Ok(Devlink::SbPoolThresholdType(val)) = attr {
924 return Ok(val);
925 }
926 }
927 Err(ErrorContext::new_missing(
928 "Devlink",
929 "SbPoolThresholdType",
930 self.orig_loc,
931 self.buf.as_ptr() as usize,
932 ))
933 }
934 pub fn get_sb_threshold(&self) -> Result<u32, ErrorContext> {
935 let mut iter = self.clone();
936 iter.pos = 0;
937 for attr in iter {
938 if let Ok(Devlink::SbThreshold(val)) = attr {
939 return Ok(val);
940 }
941 }
942 Err(ErrorContext::new_missing(
943 "Devlink",
944 "SbThreshold",
945 self.orig_loc,
946 self.buf.as_ptr() as usize,
947 ))
948 }
949 pub fn get_sb_tc_index(&self) -> Result<u16, ErrorContext> {
950 let mut iter = self.clone();
951 iter.pos = 0;
952 for attr in iter {
953 if let Ok(Devlink::SbTcIndex(val)) = attr {
954 return Ok(val);
955 }
956 }
957 Err(ErrorContext::new_missing(
958 "Devlink",
959 "SbTcIndex",
960 self.orig_loc,
961 self.buf.as_ptr() as usize,
962 ))
963 }
964 pub fn get_sb_occ_cur(&self) -> Result<u32, ErrorContext> {
965 let mut iter = self.clone();
966 iter.pos = 0;
967 for attr in iter {
968 if let Ok(Devlink::SbOccCur(val)) = attr {
969 return Ok(val);
970 }
971 }
972 Err(ErrorContext::new_missing(
973 "Devlink",
974 "SbOccCur",
975 self.orig_loc,
976 self.buf.as_ptr() as usize,
977 ))
978 }
979 pub fn get_sb_occ_max(&self) -> Result<u32, ErrorContext> {
980 let mut iter = self.clone();
981 iter.pos = 0;
982 for attr in iter {
983 if let Ok(Devlink::SbOccMax(val)) = attr {
984 return Ok(val);
985 }
986 }
987 Err(ErrorContext::new_missing(
988 "Devlink",
989 "SbOccMax",
990 self.orig_loc,
991 self.buf.as_ptr() as usize,
992 ))
993 }
994 #[doc = "Associated type: [`EswitchMode`] (enum)"]
995 pub fn get_eswitch_mode(&self) -> Result<u16, ErrorContext> {
996 let mut iter = self.clone();
997 iter.pos = 0;
998 for attr in iter {
999 if let Ok(Devlink::EswitchMode(val)) = attr {
1000 return Ok(val);
1001 }
1002 }
1003 Err(ErrorContext::new_missing(
1004 "Devlink",
1005 "EswitchMode",
1006 self.orig_loc,
1007 self.buf.as_ptr() as usize,
1008 ))
1009 }
1010 #[doc = "Associated type: [`EswitchInlineMode`] (enum)"]
1011 pub fn get_eswitch_inline_mode(&self) -> Result<u8, ErrorContext> {
1012 let mut iter = self.clone();
1013 iter.pos = 0;
1014 for attr in iter {
1015 if let Ok(Devlink::EswitchInlineMode(val)) = attr {
1016 return Ok(val);
1017 }
1018 }
1019 Err(ErrorContext::new_missing(
1020 "Devlink",
1021 "EswitchInlineMode",
1022 self.orig_loc,
1023 self.buf.as_ptr() as usize,
1024 ))
1025 }
1026 pub fn get_dpipe_tables(&self) -> Result<IterableDlDpipeTables<'a>, ErrorContext> {
1027 let mut iter = self.clone();
1028 iter.pos = 0;
1029 for attr in iter {
1030 if let Ok(Devlink::DpipeTables(val)) = attr {
1031 return Ok(val);
1032 }
1033 }
1034 Err(ErrorContext::new_missing(
1035 "Devlink",
1036 "DpipeTables",
1037 self.orig_loc,
1038 self.buf.as_ptr() as usize,
1039 ))
1040 }
1041 #[doc = "Attribute may repeat multiple times (treat it as array)"]
1042 pub fn get_dpipe_table(
1043 &self,
1044 ) -> MultiAttrIterable<Self, Devlink<'a>, IterableDlDpipeTable<'a>> {
1045 MultiAttrIterable::new(self.clone(), |variant| {
1046 if let Devlink::DpipeTable(val) = variant {
1047 Some(val)
1048 } else {
1049 None
1050 }
1051 })
1052 }
1053 pub fn get_dpipe_table_name(&self) -> Result<&'a CStr, ErrorContext> {
1054 let mut iter = self.clone();
1055 iter.pos = 0;
1056 for attr in iter {
1057 if let Ok(Devlink::DpipeTableName(val)) = attr {
1058 return Ok(val);
1059 }
1060 }
1061 Err(ErrorContext::new_missing(
1062 "Devlink",
1063 "DpipeTableName",
1064 self.orig_loc,
1065 self.buf.as_ptr() as usize,
1066 ))
1067 }
1068 pub fn get_dpipe_table_size(&self) -> Result<u64, ErrorContext> {
1069 let mut iter = self.clone();
1070 iter.pos = 0;
1071 for attr in iter {
1072 if let Ok(Devlink::DpipeTableSize(val)) = attr {
1073 return Ok(val);
1074 }
1075 }
1076 Err(ErrorContext::new_missing(
1077 "Devlink",
1078 "DpipeTableSize",
1079 self.orig_loc,
1080 self.buf.as_ptr() as usize,
1081 ))
1082 }
1083 pub fn get_dpipe_table_matches(&self) -> Result<IterableDlDpipeTableMatches<'a>, ErrorContext> {
1084 let mut iter = self.clone();
1085 iter.pos = 0;
1086 for attr in iter {
1087 if let Ok(Devlink::DpipeTableMatches(val)) = attr {
1088 return Ok(val);
1089 }
1090 }
1091 Err(ErrorContext::new_missing(
1092 "Devlink",
1093 "DpipeTableMatches",
1094 self.orig_loc,
1095 self.buf.as_ptr() as usize,
1096 ))
1097 }
1098 pub fn get_dpipe_table_actions(&self) -> Result<IterableDlDpipeTableActions<'a>, ErrorContext> {
1099 let mut iter = self.clone();
1100 iter.pos = 0;
1101 for attr in iter {
1102 if let Ok(Devlink::DpipeTableActions(val)) = attr {
1103 return Ok(val);
1104 }
1105 }
1106 Err(ErrorContext::new_missing(
1107 "Devlink",
1108 "DpipeTableActions",
1109 self.orig_loc,
1110 self.buf.as_ptr() as usize,
1111 ))
1112 }
1113 pub fn get_dpipe_table_counters_enabled(&self) -> Result<u8, ErrorContext> {
1114 let mut iter = self.clone();
1115 iter.pos = 0;
1116 for attr in iter {
1117 if let Ok(Devlink::DpipeTableCountersEnabled(val)) = attr {
1118 return Ok(val);
1119 }
1120 }
1121 Err(ErrorContext::new_missing(
1122 "Devlink",
1123 "DpipeTableCountersEnabled",
1124 self.orig_loc,
1125 self.buf.as_ptr() as usize,
1126 ))
1127 }
1128 pub fn get_dpipe_entries(&self) -> Result<IterableDlDpipeEntries<'a>, ErrorContext> {
1129 let mut iter = self.clone();
1130 iter.pos = 0;
1131 for attr in iter {
1132 if let Ok(Devlink::DpipeEntries(val)) = attr {
1133 return Ok(val);
1134 }
1135 }
1136 Err(ErrorContext::new_missing(
1137 "Devlink",
1138 "DpipeEntries",
1139 self.orig_loc,
1140 self.buf.as_ptr() as usize,
1141 ))
1142 }
1143 #[doc = "Attribute may repeat multiple times (treat it as array)"]
1144 pub fn get_dpipe_entry(
1145 &self,
1146 ) -> MultiAttrIterable<Self, Devlink<'a>, IterableDlDpipeEntry<'a>> {
1147 MultiAttrIterable::new(self.clone(), |variant| {
1148 if let Devlink::DpipeEntry(val) = variant {
1149 Some(val)
1150 } else {
1151 None
1152 }
1153 })
1154 }
1155 pub fn get_dpipe_entry_index(&self) -> Result<u64, ErrorContext> {
1156 let mut iter = self.clone();
1157 iter.pos = 0;
1158 for attr in iter {
1159 if let Ok(Devlink::DpipeEntryIndex(val)) = attr {
1160 return Ok(val);
1161 }
1162 }
1163 Err(ErrorContext::new_missing(
1164 "Devlink",
1165 "DpipeEntryIndex",
1166 self.orig_loc,
1167 self.buf.as_ptr() as usize,
1168 ))
1169 }
1170 pub fn get_dpipe_entry_match_values(
1171 &self,
1172 ) -> Result<IterableDlDpipeEntryMatchValues<'a>, ErrorContext> {
1173 let mut iter = self.clone();
1174 iter.pos = 0;
1175 for attr in iter {
1176 if let Ok(Devlink::DpipeEntryMatchValues(val)) = attr {
1177 return Ok(val);
1178 }
1179 }
1180 Err(ErrorContext::new_missing(
1181 "Devlink",
1182 "DpipeEntryMatchValues",
1183 self.orig_loc,
1184 self.buf.as_ptr() as usize,
1185 ))
1186 }
1187 pub fn get_dpipe_entry_action_values(
1188 &self,
1189 ) -> Result<IterableDlDpipeEntryActionValues<'a>, ErrorContext> {
1190 let mut iter = self.clone();
1191 iter.pos = 0;
1192 for attr in iter {
1193 if let Ok(Devlink::DpipeEntryActionValues(val)) = attr {
1194 return Ok(val);
1195 }
1196 }
1197 Err(ErrorContext::new_missing(
1198 "Devlink",
1199 "DpipeEntryActionValues",
1200 self.orig_loc,
1201 self.buf.as_ptr() as usize,
1202 ))
1203 }
1204 pub fn get_dpipe_entry_counter(&self) -> Result<u64, ErrorContext> {
1205 let mut iter = self.clone();
1206 iter.pos = 0;
1207 for attr in iter {
1208 if let Ok(Devlink::DpipeEntryCounter(val)) = attr {
1209 return Ok(val);
1210 }
1211 }
1212 Err(ErrorContext::new_missing(
1213 "Devlink",
1214 "DpipeEntryCounter",
1215 self.orig_loc,
1216 self.buf.as_ptr() as usize,
1217 ))
1218 }
1219 #[doc = "Attribute may repeat multiple times (treat it as array)"]
1220 pub fn get_dpipe_match(
1221 &self,
1222 ) -> MultiAttrIterable<Self, Devlink<'a>, IterableDlDpipeMatch<'a>> {
1223 MultiAttrIterable::new(self.clone(), |variant| {
1224 if let Devlink::DpipeMatch(val) = variant {
1225 Some(val)
1226 } else {
1227 None
1228 }
1229 })
1230 }
1231 #[doc = "Attribute may repeat multiple times (treat it as array)"]
1232 pub fn get_dpipe_match_value(
1233 &self,
1234 ) -> MultiAttrIterable<Self, Devlink<'a>, IterableDlDpipeMatchValue<'a>> {
1235 MultiAttrIterable::new(self.clone(), |variant| {
1236 if let Devlink::DpipeMatchValue(val) = variant {
1237 Some(val)
1238 } else {
1239 None
1240 }
1241 })
1242 }
1243 #[doc = "Associated type: [`DpipeMatchType`] (enum)"]
1244 pub fn get_dpipe_match_type(&self) -> Result<u32, ErrorContext> {
1245 let mut iter = self.clone();
1246 iter.pos = 0;
1247 for attr in iter {
1248 if let Ok(Devlink::DpipeMatchType(val)) = attr {
1249 return Ok(val);
1250 }
1251 }
1252 Err(ErrorContext::new_missing(
1253 "Devlink",
1254 "DpipeMatchType",
1255 self.orig_loc,
1256 self.buf.as_ptr() as usize,
1257 ))
1258 }
1259 #[doc = "Attribute may repeat multiple times (treat it as array)"]
1260 pub fn get_dpipe_action(
1261 &self,
1262 ) -> MultiAttrIterable<Self, Devlink<'a>, IterableDlDpipeAction<'a>> {
1263 MultiAttrIterable::new(self.clone(), |variant| {
1264 if let Devlink::DpipeAction(val) = variant {
1265 Some(val)
1266 } else {
1267 None
1268 }
1269 })
1270 }
1271 #[doc = "Attribute may repeat multiple times (treat it as array)"]
1272 pub fn get_dpipe_action_value(
1273 &self,
1274 ) -> MultiAttrIterable<Self, Devlink<'a>, IterableDlDpipeActionValue<'a>> {
1275 MultiAttrIterable::new(self.clone(), |variant| {
1276 if let Devlink::DpipeActionValue(val) = variant {
1277 Some(val)
1278 } else {
1279 None
1280 }
1281 })
1282 }
1283 #[doc = "Associated type: [`DpipeActionType`] (enum)"]
1284 pub fn get_dpipe_action_type(&self) -> Result<u32, ErrorContext> {
1285 let mut iter = self.clone();
1286 iter.pos = 0;
1287 for attr in iter {
1288 if let Ok(Devlink::DpipeActionType(val)) = attr {
1289 return Ok(val);
1290 }
1291 }
1292 Err(ErrorContext::new_missing(
1293 "Devlink",
1294 "DpipeActionType",
1295 self.orig_loc,
1296 self.buf.as_ptr() as usize,
1297 ))
1298 }
1299 pub fn get_dpipe_value(&self) -> Result<&'a [u8], ErrorContext> {
1300 let mut iter = self.clone();
1301 iter.pos = 0;
1302 for attr in iter {
1303 if let Ok(Devlink::DpipeValue(val)) = attr {
1304 return Ok(val);
1305 }
1306 }
1307 Err(ErrorContext::new_missing(
1308 "Devlink",
1309 "DpipeValue",
1310 self.orig_loc,
1311 self.buf.as_ptr() as usize,
1312 ))
1313 }
1314 pub fn get_dpipe_value_mask(&self) -> Result<&'a [u8], ErrorContext> {
1315 let mut iter = self.clone();
1316 iter.pos = 0;
1317 for attr in iter {
1318 if let Ok(Devlink::DpipeValueMask(val)) = attr {
1319 return Ok(val);
1320 }
1321 }
1322 Err(ErrorContext::new_missing(
1323 "Devlink",
1324 "DpipeValueMask",
1325 self.orig_loc,
1326 self.buf.as_ptr() as usize,
1327 ))
1328 }
1329 pub fn get_dpipe_value_mapping(&self) -> Result<u32, ErrorContext> {
1330 let mut iter = self.clone();
1331 iter.pos = 0;
1332 for attr in iter {
1333 if let Ok(Devlink::DpipeValueMapping(val)) = attr {
1334 return Ok(val);
1335 }
1336 }
1337 Err(ErrorContext::new_missing(
1338 "Devlink",
1339 "DpipeValueMapping",
1340 self.orig_loc,
1341 self.buf.as_ptr() as usize,
1342 ))
1343 }
1344 pub fn get_dpipe_headers(&self) -> Result<IterableDlDpipeHeaders<'a>, ErrorContext> {
1345 let mut iter = self.clone();
1346 iter.pos = 0;
1347 for attr in iter {
1348 if let Ok(Devlink::DpipeHeaders(val)) = attr {
1349 return Ok(val);
1350 }
1351 }
1352 Err(ErrorContext::new_missing(
1353 "Devlink",
1354 "DpipeHeaders",
1355 self.orig_loc,
1356 self.buf.as_ptr() as usize,
1357 ))
1358 }
1359 #[doc = "Attribute may repeat multiple times (treat it as array)"]
1360 pub fn get_dpipe_header(
1361 &self,
1362 ) -> MultiAttrIterable<Self, Devlink<'a>, IterableDlDpipeHeader<'a>> {
1363 MultiAttrIterable::new(self.clone(), |variant| {
1364 if let Devlink::DpipeHeader(val) = variant {
1365 Some(val)
1366 } else {
1367 None
1368 }
1369 })
1370 }
1371 pub fn get_dpipe_header_name(&self) -> Result<&'a CStr, ErrorContext> {
1372 let mut iter = self.clone();
1373 iter.pos = 0;
1374 for attr in iter {
1375 if let Ok(Devlink::DpipeHeaderName(val)) = attr {
1376 return Ok(val);
1377 }
1378 }
1379 Err(ErrorContext::new_missing(
1380 "Devlink",
1381 "DpipeHeaderName",
1382 self.orig_loc,
1383 self.buf.as_ptr() as usize,
1384 ))
1385 }
1386 #[doc = "Associated type: [`DpipeHeaderId`] (enum)"]
1387 pub fn get_dpipe_header_id(&self) -> Result<u32, ErrorContext> {
1388 let mut iter = self.clone();
1389 iter.pos = 0;
1390 for attr in iter {
1391 if let Ok(Devlink::DpipeHeaderId(val)) = attr {
1392 return Ok(val);
1393 }
1394 }
1395 Err(ErrorContext::new_missing(
1396 "Devlink",
1397 "DpipeHeaderId",
1398 self.orig_loc,
1399 self.buf.as_ptr() as usize,
1400 ))
1401 }
1402 pub fn get_dpipe_header_fields(&self) -> Result<IterableDlDpipeHeaderFields<'a>, ErrorContext> {
1403 let mut iter = self.clone();
1404 iter.pos = 0;
1405 for attr in iter {
1406 if let Ok(Devlink::DpipeHeaderFields(val)) = attr {
1407 return Ok(val);
1408 }
1409 }
1410 Err(ErrorContext::new_missing(
1411 "Devlink",
1412 "DpipeHeaderFields",
1413 self.orig_loc,
1414 self.buf.as_ptr() as usize,
1415 ))
1416 }
1417 pub fn get_dpipe_header_global(&self) -> Result<u8, ErrorContext> {
1418 let mut iter = self.clone();
1419 iter.pos = 0;
1420 for attr in iter {
1421 if let Ok(Devlink::DpipeHeaderGlobal(val)) = attr {
1422 return Ok(val);
1423 }
1424 }
1425 Err(ErrorContext::new_missing(
1426 "Devlink",
1427 "DpipeHeaderGlobal",
1428 self.orig_loc,
1429 self.buf.as_ptr() as usize,
1430 ))
1431 }
1432 pub fn get_dpipe_header_index(&self) -> Result<u32, ErrorContext> {
1433 let mut iter = self.clone();
1434 iter.pos = 0;
1435 for attr in iter {
1436 if let Ok(Devlink::DpipeHeaderIndex(val)) = attr {
1437 return Ok(val);
1438 }
1439 }
1440 Err(ErrorContext::new_missing(
1441 "Devlink",
1442 "DpipeHeaderIndex",
1443 self.orig_loc,
1444 self.buf.as_ptr() as usize,
1445 ))
1446 }
1447 #[doc = "Attribute may repeat multiple times (treat it as array)"]
1448 pub fn get_dpipe_field(
1449 &self,
1450 ) -> MultiAttrIterable<Self, Devlink<'a>, IterableDlDpipeField<'a>> {
1451 MultiAttrIterable::new(self.clone(), |variant| {
1452 if let Devlink::DpipeField(val) = variant {
1453 Some(val)
1454 } else {
1455 None
1456 }
1457 })
1458 }
1459 pub fn get_dpipe_field_name(&self) -> Result<&'a CStr, ErrorContext> {
1460 let mut iter = self.clone();
1461 iter.pos = 0;
1462 for attr in iter {
1463 if let Ok(Devlink::DpipeFieldName(val)) = attr {
1464 return Ok(val);
1465 }
1466 }
1467 Err(ErrorContext::new_missing(
1468 "Devlink",
1469 "DpipeFieldName",
1470 self.orig_loc,
1471 self.buf.as_ptr() as usize,
1472 ))
1473 }
1474 pub fn get_dpipe_field_id(&self) -> Result<u32, ErrorContext> {
1475 let mut iter = self.clone();
1476 iter.pos = 0;
1477 for attr in iter {
1478 if let Ok(Devlink::DpipeFieldId(val)) = attr {
1479 return Ok(val);
1480 }
1481 }
1482 Err(ErrorContext::new_missing(
1483 "Devlink",
1484 "DpipeFieldId",
1485 self.orig_loc,
1486 self.buf.as_ptr() as usize,
1487 ))
1488 }
1489 pub fn get_dpipe_field_bitwidth(&self) -> Result<u32, ErrorContext> {
1490 let mut iter = self.clone();
1491 iter.pos = 0;
1492 for attr in iter {
1493 if let Ok(Devlink::DpipeFieldBitwidth(val)) = attr {
1494 return Ok(val);
1495 }
1496 }
1497 Err(ErrorContext::new_missing(
1498 "Devlink",
1499 "DpipeFieldBitwidth",
1500 self.orig_loc,
1501 self.buf.as_ptr() as usize,
1502 ))
1503 }
1504 #[doc = "Associated type: [`DpipeFieldMappingType`] (enum)"]
1505 pub fn get_dpipe_field_mapping_type(&self) -> Result<u32, ErrorContext> {
1506 let mut iter = self.clone();
1507 iter.pos = 0;
1508 for attr in iter {
1509 if let Ok(Devlink::DpipeFieldMappingType(val)) = attr {
1510 return Ok(val);
1511 }
1512 }
1513 Err(ErrorContext::new_missing(
1514 "Devlink",
1515 "DpipeFieldMappingType",
1516 self.orig_loc,
1517 self.buf.as_ptr() as usize,
1518 ))
1519 }
1520 pub fn get_pad(&self) -> Result<&'a [u8], ErrorContext> {
1521 let mut iter = self.clone();
1522 iter.pos = 0;
1523 for attr in iter {
1524 if let Ok(Devlink::Pad(val)) = attr {
1525 return Ok(val);
1526 }
1527 }
1528 Err(ErrorContext::new_missing(
1529 "Devlink",
1530 "Pad",
1531 self.orig_loc,
1532 self.buf.as_ptr() as usize,
1533 ))
1534 }
1535 #[doc = "Associated type: [`EswitchEncapMode`] (enum)"]
1536 pub fn get_eswitch_encap_mode(&self) -> Result<u8, ErrorContext> {
1537 let mut iter = self.clone();
1538 iter.pos = 0;
1539 for attr in iter {
1540 if let Ok(Devlink::EswitchEncapMode(val)) = attr {
1541 return Ok(val);
1542 }
1543 }
1544 Err(ErrorContext::new_missing(
1545 "Devlink",
1546 "EswitchEncapMode",
1547 self.orig_loc,
1548 self.buf.as_ptr() as usize,
1549 ))
1550 }
1551 pub fn get_resource_list(&self) -> Result<IterableDlResourceList<'a>, ErrorContext> {
1552 let mut iter = self.clone();
1553 iter.pos = 0;
1554 for attr in iter {
1555 if let Ok(Devlink::ResourceList(val)) = attr {
1556 return Ok(val);
1557 }
1558 }
1559 Err(ErrorContext::new_missing(
1560 "Devlink",
1561 "ResourceList",
1562 self.orig_loc,
1563 self.buf.as_ptr() as usize,
1564 ))
1565 }
1566 #[doc = "Attribute may repeat multiple times (treat it as array)"]
1567 pub fn get_resource(&self) -> MultiAttrIterable<Self, Devlink<'a>, IterableDlResource<'a>> {
1568 MultiAttrIterable::new(self.clone(), |variant| {
1569 if let Devlink::Resource(val) = variant {
1570 Some(val)
1571 } else {
1572 None
1573 }
1574 })
1575 }
1576 pub fn get_resource_name(&self) -> Result<&'a CStr, ErrorContext> {
1577 let mut iter = self.clone();
1578 iter.pos = 0;
1579 for attr in iter {
1580 if let Ok(Devlink::ResourceName(val)) = attr {
1581 return Ok(val);
1582 }
1583 }
1584 Err(ErrorContext::new_missing(
1585 "Devlink",
1586 "ResourceName",
1587 self.orig_loc,
1588 self.buf.as_ptr() as usize,
1589 ))
1590 }
1591 pub fn get_resource_id(&self) -> Result<u64, ErrorContext> {
1592 let mut iter = self.clone();
1593 iter.pos = 0;
1594 for attr in iter {
1595 if let Ok(Devlink::ResourceId(val)) = attr {
1596 return Ok(val);
1597 }
1598 }
1599 Err(ErrorContext::new_missing(
1600 "Devlink",
1601 "ResourceId",
1602 self.orig_loc,
1603 self.buf.as_ptr() as usize,
1604 ))
1605 }
1606 pub fn get_resource_size(&self) -> Result<u64, ErrorContext> {
1607 let mut iter = self.clone();
1608 iter.pos = 0;
1609 for attr in iter {
1610 if let Ok(Devlink::ResourceSize(val)) = attr {
1611 return Ok(val);
1612 }
1613 }
1614 Err(ErrorContext::new_missing(
1615 "Devlink",
1616 "ResourceSize",
1617 self.orig_loc,
1618 self.buf.as_ptr() as usize,
1619 ))
1620 }
1621 pub fn get_resource_size_new(&self) -> Result<u64, ErrorContext> {
1622 let mut iter = self.clone();
1623 iter.pos = 0;
1624 for attr in iter {
1625 if let Ok(Devlink::ResourceSizeNew(val)) = attr {
1626 return Ok(val);
1627 }
1628 }
1629 Err(ErrorContext::new_missing(
1630 "Devlink",
1631 "ResourceSizeNew",
1632 self.orig_loc,
1633 self.buf.as_ptr() as usize,
1634 ))
1635 }
1636 pub fn get_resource_size_valid(&self) -> Result<u8, ErrorContext> {
1637 let mut iter = self.clone();
1638 iter.pos = 0;
1639 for attr in iter {
1640 if let Ok(Devlink::ResourceSizeValid(val)) = attr {
1641 return Ok(val);
1642 }
1643 }
1644 Err(ErrorContext::new_missing(
1645 "Devlink",
1646 "ResourceSizeValid",
1647 self.orig_loc,
1648 self.buf.as_ptr() as usize,
1649 ))
1650 }
1651 pub fn get_resource_size_min(&self) -> Result<u64, ErrorContext> {
1652 let mut iter = self.clone();
1653 iter.pos = 0;
1654 for attr in iter {
1655 if let Ok(Devlink::ResourceSizeMin(val)) = attr {
1656 return Ok(val);
1657 }
1658 }
1659 Err(ErrorContext::new_missing(
1660 "Devlink",
1661 "ResourceSizeMin",
1662 self.orig_loc,
1663 self.buf.as_ptr() as usize,
1664 ))
1665 }
1666 pub fn get_resource_size_max(&self) -> Result<u64, ErrorContext> {
1667 let mut iter = self.clone();
1668 iter.pos = 0;
1669 for attr in iter {
1670 if let Ok(Devlink::ResourceSizeMax(val)) = attr {
1671 return Ok(val);
1672 }
1673 }
1674 Err(ErrorContext::new_missing(
1675 "Devlink",
1676 "ResourceSizeMax",
1677 self.orig_loc,
1678 self.buf.as_ptr() as usize,
1679 ))
1680 }
1681 pub fn get_resource_size_gran(&self) -> Result<u64, ErrorContext> {
1682 let mut iter = self.clone();
1683 iter.pos = 0;
1684 for attr in iter {
1685 if let Ok(Devlink::ResourceSizeGran(val)) = attr {
1686 return Ok(val);
1687 }
1688 }
1689 Err(ErrorContext::new_missing(
1690 "Devlink",
1691 "ResourceSizeGran",
1692 self.orig_loc,
1693 self.buf.as_ptr() as usize,
1694 ))
1695 }
1696 #[doc = "Associated type: [`ResourceUnit`] (enum)"]
1697 pub fn get_resource_unit(&self) -> Result<u8, ErrorContext> {
1698 let mut iter = self.clone();
1699 iter.pos = 0;
1700 for attr in iter {
1701 if let Ok(Devlink::ResourceUnit(val)) = attr {
1702 return Ok(val);
1703 }
1704 }
1705 Err(ErrorContext::new_missing(
1706 "Devlink",
1707 "ResourceUnit",
1708 self.orig_loc,
1709 self.buf.as_ptr() as usize,
1710 ))
1711 }
1712 pub fn get_resource_occ(&self) -> Result<u64, ErrorContext> {
1713 let mut iter = self.clone();
1714 iter.pos = 0;
1715 for attr in iter {
1716 if let Ok(Devlink::ResourceOcc(val)) = attr {
1717 return Ok(val);
1718 }
1719 }
1720 Err(ErrorContext::new_missing(
1721 "Devlink",
1722 "ResourceOcc",
1723 self.orig_loc,
1724 self.buf.as_ptr() as usize,
1725 ))
1726 }
1727 pub fn get_dpipe_table_resource_id(&self) -> Result<u64, ErrorContext> {
1728 let mut iter = self.clone();
1729 iter.pos = 0;
1730 for attr in iter {
1731 if let Ok(Devlink::DpipeTableResourceId(val)) = attr {
1732 return Ok(val);
1733 }
1734 }
1735 Err(ErrorContext::new_missing(
1736 "Devlink",
1737 "DpipeTableResourceId",
1738 self.orig_loc,
1739 self.buf.as_ptr() as usize,
1740 ))
1741 }
1742 pub fn get_dpipe_table_resource_units(&self) -> Result<u64, ErrorContext> {
1743 let mut iter = self.clone();
1744 iter.pos = 0;
1745 for attr in iter {
1746 if let Ok(Devlink::DpipeTableResourceUnits(val)) = attr {
1747 return Ok(val);
1748 }
1749 }
1750 Err(ErrorContext::new_missing(
1751 "Devlink",
1752 "DpipeTableResourceUnits",
1753 self.orig_loc,
1754 self.buf.as_ptr() as usize,
1755 ))
1756 }
1757 #[doc = "Associated type: [`PortFlavour`] (enum)"]
1758 pub fn get_port_flavour(&self) -> Result<u16, ErrorContext> {
1759 let mut iter = self.clone();
1760 iter.pos = 0;
1761 for attr in iter {
1762 if let Ok(Devlink::PortFlavour(val)) = attr {
1763 return Ok(val);
1764 }
1765 }
1766 Err(ErrorContext::new_missing(
1767 "Devlink",
1768 "PortFlavour",
1769 self.orig_loc,
1770 self.buf.as_ptr() as usize,
1771 ))
1772 }
1773 pub fn get_port_number(&self) -> Result<u32, ErrorContext> {
1774 let mut iter = self.clone();
1775 iter.pos = 0;
1776 for attr in iter {
1777 if let Ok(Devlink::PortNumber(val)) = attr {
1778 return Ok(val);
1779 }
1780 }
1781 Err(ErrorContext::new_missing(
1782 "Devlink",
1783 "PortNumber",
1784 self.orig_loc,
1785 self.buf.as_ptr() as usize,
1786 ))
1787 }
1788 pub fn get_port_split_subport_number(&self) -> Result<u32, ErrorContext> {
1789 let mut iter = self.clone();
1790 iter.pos = 0;
1791 for attr in iter {
1792 if let Ok(Devlink::PortSplitSubportNumber(val)) = attr {
1793 return Ok(val);
1794 }
1795 }
1796 Err(ErrorContext::new_missing(
1797 "Devlink",
1798 "PortSplitSubportNumber",
1799 self.orig_loc,
1800 self.buf.as_ptr() as usize,
1801 ))
1802 }
1803 pub fn get_param(&self) -> Result<IterableDlParam<'a>, ErrorContext> {
1804 let mut iter = self.clone();
1805 iter.pos = 0;
1806 for attr in iter {
1807 if let Ok(Devlink::Param(val)) = attr {
1808 return Ok(val);
1809 }
1810 }
1811 Err(ErrorContext::new_missing(
1812 "Devlink",
1813 "Param",
1814 self.orig_loc,
1815 self.buf.as_ptr() as usize,
1816 ))
1817 }
1818 pub fn get_param_name(&self) -> Result<&'a CStr, ErrorContext> {
1819 let mut iter = self.clone();
1820 iter.pos = 0;
1821 for attr in iter {
1822 if let Ok(Devlink::ParamName(val)) = attr {
1823 return Ok(val);
1824 }
1825 }
1826 Err(ErrorContext::new_missing(
1827 "Devlink",
1828 "ParamName",
1829 self.orig_loc,
1830 self.buf.as_ptr() as usize,
1831 ))
1832 }
1833 pub fn get_param_generic(&self) -> Result<(), ErrorContext> {
1834 let mut iter = self.clone();
1835 iter.pos = 0;
1836 for attr in iter {
1837 if let Ok(Devlink::ParamGeneric(val)) = attr {
1838 return Ok(val);
1839 }
1840 }
1841 Err(ErrorContext::new_missing(
1842 "Devlink",
1843 "ParamGeneric",
1844 self.orig_loc,
1845 self.buf.as_ptr() as usize,
1846 ))
1847 }
1848 #[doc = "Associated type: [`VarAttrType`] (enum)"]
1849 pub fn get_param_type(&self) -> Result<u8, ErrorContext> {
1850 let mut iter = self.clone();
1851 iter.pos = 0;
1852 for attr in iter {
1853 if let Ok(Devlink::ParamType(val)) = attr {
1854 return Ok(val);
1855 }
1856 }
1857 Err(ErrorContext::new_missing(
1858 "Devlink",
1859 "ParamType",
1860 self.orig_loc,
1861 self.buf.as_ptr() as usize,
1862 ))
1863 }
1864 #[doc = "Associated type: [`ParamCmode`] (enum)"]
1865 pub fn get_param_value_cmode(&self) -> Result<u8, ErrorContext> {
1866 let mut iter = self.clone();
1867 iter.pos = 0;
1868 for attr in iter {
1869 if let Ok(Devlink::ParamValueCmode(val)) = attr {
1870 return Ok(val);
1871 }
1872 }
1873 Err(ErrorContext::new_missing(
1874 "Devlink",
1875 "ParamValueCmode",
1876 self.orig_loc,
1877 self.buf.as_ptr() as usize,
1878 ))
1879 }
1880 pub fn get_region_name(&self) -> Result<&'a CStr, ErrorContext> {
1881 let mut iter = self.clone();
1882 iter.pos = 0;
1883 for attr in iter {
1884 if let Ok(Devlink::RegionName(val)) = attr {
1885 return Ok(val);
1886 }
1887 }
1888 Err(ErrorContext::new_missing(
1889 "Devlink",
1890 "RegionName",
1891 self.orig_loc,
1892 self.buf.as_ptr() as usize,
1893 ))
1894 }
1895 pub fn get_region_size(&self) -> Result<u64, ErrorContext> {
1896 let mut iter = self.clone();
1897 iter.pos = 0;
1898 for attr in iter {
1899 if let Ok(Devlink::RegionSize(val)) = attr {
1900 return Ok(val);
1901 }
1902 }
1903 Err(ErrorContext::new_missing(
1904 "Devlink",
1905 "RegionSize",
1906 self.orig_loc,
1907 self.buf.as_ptr() as usize,
1908 ))
1909 }
1910 pub fn get_region_snapshots(&self) -> Result<IterableDlRegionSnapshots<'a>, ErrorContext> {
1911 let mut iter = self.clone();
1912 iter.pos = 0;
1913 for attr in iter {
1914 if let Ok(Devlink::RegionSnapshots(val)) = attr {
1915 return Ok(val);
1916 }
1917 }
1918 Err(ErrorContext::new_missing(
1919 "Devlink",
1920 "RegionSnapshots",
1921 self.orig_loc,
1922 self.buf.as_ptr() as usize,
1923 ))
1924 }
1925 pub fn get_region_snapshot(&self) -> Result<IterableDlRegionSnapshot<'a>, ErrorContext> {
1926 let mut iter = self.clone();
1927 iter.pos = 0;
1928 for attr in iter {
1929 if let Ok(Devlink::RegionSnapshot(val)) = attr {
1930 return Ok(val);
1931 }
1932 }
1933 Err(ErrorContext::new_missing(
1934 "Devlink",
1935 "RegionSnapshot",
1936 self.orig_loc,
1937 self.buf.as_ptr() as usize,
1938 ))
1939 }
1940 pub fn get_region_snapshot_id(&self) -> Result<u32, ErrorContext> {
1941 let mut iter = self.clone();
1942 iter.pos = 0;
1943 for attr in iter {
1944 if let Ok(Devlink::RegionSnapshotId(val)) = attr {
1945 return Ok(val);
1946 }
1947 }
1948 Err(ErrorContext::new_missing(
1949 "Devlink",
1950 "RegionSnapshotId",
1951 self.orig_loc,
1952 self.buf.as_ptr() as usize,
1953 ))
1954 }
1955 pub fn get_region_chunks(&self) -> Result<IterableDlRegionChunks<'a>, ErrorContext> {
1956 let mut iter = self.clone();
1957 iter.pos = 0;
1958 for attr in iter {
1959 if let Ok(Devlink::RegionChunks(val)) = attr {
1960 return Ok(val);
1961 }
1962 }
1963 Err(ErrorContext::new_missing(
1964 "Devlink",
1965 "RegionChunks",
1966 self.orig_loc,
1967 self.buf.as_ptr() as usize,
1968 ))
1969 }
1970 pub fn get_region_chunk(&self) -> Result<IterableDlRegionChunk<'a>, ErrorContext> {
1971 let mut iter = self.clone();
1972 iter.pos = 0;
1973 for attr in iter {
1974 if let Ok(Devlink::RegionChunk(val)) = attr {
1975 return Ok(val);
1976 }
1977 }
1978 Err(ErrorContext::new_missing(
1979 "Devlink",
1980 "RegionChunk",
1981 self.orig_loc,
1982 self.buf.as_ptr() as usize,
1983 ))
1984 }
1985 pub fn get_region_chunk_data(&self) -> Result<&'a [u8], ErrorContext> {
1986 let mut iter = self.clone();
1987 iter.pos = 0;
1988 for attr in iter {
1989 if let Ok(Devlink::RegionChunkData(val)) = attr {
1990 return Ok(val);
1991 }
1992 }
1993 Err(ErrorContext::new_missing(
1994 "Devlink",
1995 "RegionChunkData",
1996 self.orig_loc,
1997 self.buf.as_ptr() as usize,
1998 ))
1999 }
2000 pub fn get_region_chunk_addr(&self) -> Result<u64, ErrorContext> {
2001 let mut iter = self.clone();
2002 iter.pos = 0;
2003 for attr in iter {
2004 if let Ok(Devlink::RegionChunkAddr(val)) = attr {
2005 return Ok(val);
2006 }
2007 }
2008 Err(ErrorContext::new_missing(
2009 "Devlink",
2010 "RegionChunkAddr",
2011 self.orig_loc,
2012 self.buf.as_ptr() as usize,
2013 ))
2014 }
2015 pub fn get_region_chunk_len(&self) -> Result<u64, ErrorContext> {
2016 let mut iter = self.clone();
2017 iter.pos = 0;
2018 for attr in iter {
2019 if let Ok(Devlink::RegionChunkLen(val)) = attr {
2020 return Ok(val);
2021 }
2022 }
2023 Err(ErrorContext::new_missing(
2024 "Devlink",
2025 "RegionChunkLen",
2026 self.orig_loc,
2027 self.buf.as_ptr() as usize,
2028 ))
2029 }
2030 pub fn get_info_driver_name(&self) -> Result<&'a CStr, ErrorContext> {
2031 let mut iter = self.clone();
2032 iter.pos = 0;
2033 for attr in iter {
2034 if let Ok(Devlink::InfoDriverName(val)) = attr {
2035 return Ok(val);
2036 }
2037 }
2038 Err(ErrorContext::new_missing(
2039 "Devlink",
2040 "InfoDriverName",
2041 self.orig_loc,
2042 self.buf.as_ptr() as usize,
2043 ))
2044 }
2045 pub fn get_info_serial_number(&self) -> Result<&'a CStr, ErrorContext> {
2046 let mut iter = self.clone();
2047 iter.pos = 0;
2048 for attr in iter {
2049 if let Ok(Devlink::InfoSerialNumber(val)) = attr {
2050 return Ok(val);
2051 }
2052 }
2053 Err(ErrorContext::new_missing(
2054 "Devlink",
2055 "InfoSerialNumber",
2056 self.orig_loc,
2057 self.buf.as_ptr() as usize,
2058 ))
2059 }
2060 #[doc = "Attribute may repeat multiple times (treat it as array)"]
2061 pub fn get_info_version_fixed(
2062 &self,
2063 ) -> MultiAttrIterable<Self, Devlink<'a>, IterableDlInfoVersion<'a>> {
2064 MultiAttrIterable::new(self.clone(), |variant| {
2065 if let Devlink::InfoVersionFixed(val) = variant {
2066 Some(val)
2067 } else {
2068 None
2069 }
2070 })
2071 }
2072 #[doc = "Attribute may repeat multiple times (treat it as array)"]
2073 pub fn get_info_version_running(
2074 &self,
2075 ) -> MultiAttrIterable<Self, Devlink<'a>, IterableDlInfoVersion<'a>> {
2076 MultiAttrIterable::new(self.clone(), |variant| {
2077 if let Devlink::InfoVersionRunning(val) = variant {
2078 Some(val)
2079 } else {
2080 None
2081 }
2082 })
2083 }
2084 #[doc = "Attribute may repeat multiple times (treat it as array)"]
2085 pub fn get_info_version_stored(
2086 &self,
2087 ) -> MultiAttrIterable<Self, Devlink<'a>, IterableDlInfoVersion<'a>> {
2088 MultiAttrIterable::new(self.clone(), |variant| {
2089 if let Devlink::InfoVersionStored(val) = variant {
2090 Some(val)
2091 } else {
2092 None
2093 }
2094 })
2095 }
2096 pub fn get_info_version_name(&self) -> Result<&'a CStr, ErrorContext> {
2097 let mut iter = self.clone();
2098 iter.pos = 0;
2099 for attr in iter {
2100 if let Ok(Devlink::InfoVersionName(val)) = attr {
2101 return Ok(val);
2102 }
2103 }
2104 Err(ErrorContext::new_missing(
2105 "Devlink",
2106 "InfoVersionName",
2107 self.orig_loc,
2108 self.buf.as_ptr() as usize,
2109 ))
2110 }
2111 pub fn get_info_version_value(&self) -> Result<&'a CStr, ErrorContext> {
2112 let mut iter = self.clone();
2113 iter.pos = 0;
2114 for attr in iter {
2115 if let Ok(Devlink::InfoVersionValue(val)) = attr {
2116 return Ok(val);
2117 }
2118 }
2119 Err(ErrorContext::new_missing(
2120 "Devlink",
2121 "InfoVersionValue",
2122 self.orig_loc,
2123 self.buf.as_ptr() as usize,
2124 ))
2125 }
2126 pub fn get_sb_pool_cell_size(&self) -> Result<u32, ErrorContext> {
2127 let mut iter = self.clone();
2128 iter.pos = 0;
2129 for attr in iter {
2130 if let Ok(Devlink::SbPoolCellSize(val)) = attr {
2131 return Ok(val);
2132 }
2133 }
2134 Err(ErrorContext::new_missing(
2135 "Devlink",
2136 "SbPoolCellSize",
2137 self.orig_loc,
2138 self.buf.as_ptr() as usize,
2139 ))
2140 }
2141 pub fn get_fmsg(&self) -> Result<IterableDlFmsg<'a>, ErrorContext> {
2142 let mut iter = self.clone();
2143 iter.pos = 0;
2144 for attr in iter {
2145 if let Ok(Devlink::Fmsg(val)) = attr {
2146 return Ok(val);
2147 }
2148 }
2149 Err(ErrorContext::new_missing(
2150 "Devlink",
2151 "Fmsg",
2152 self.orig_loc,
2153 self.buf.as_ptr() as usize,
2154 ))
2155 }
2156 pub fn get_fmsg_obj_nest_start(&self) -> Result<(), ErrorContext> {
2157 let mut iter = self.clone();
2158 iter.pos = 0;
2159 for attr in iter {
2160 if let Ok(Devlink::FmsgObjNestStart(val)) = attr {
2161 return Ok(val);
2162 }
2163 }
2164 Err(ErrorContext::new_missing(
2165 "Devlink",
2166 "FmsgObjNestStart",
2167 self.orig_loc,
2168 self.buf.as_ptr() as usize,
2169 ))
2170 }
2171 pub fn get_fmsg_pair_nest_start(&self) -> Result<(), ErrorContext> {
2172 let mut iter = self.clone();
2173 iter.pos = 0;
2174 for attr in iter {
2175 if let Ok(Devlink::FmsgPairNestStart(val)) = attr {
2176 return Ok(val);
2177 }
2178 }
2179 Err(ErrorContext::new_missing(
2180 "Devlink",
2181 "FmsgPairNestStart",
2182 self.orig_loc,
2183 self.buf.as_ptr() as usize,
2184 ))
2185 }
2186 pub fn get_fmsg_arr_nest_start(&self) -> Result<(), ErrorContext> {
2187 let mut iter = self.clone();
2188 iter.pos = 0;
2189 for attr in iter {
2190 if let Ok(Devlink::FmsgArrNestStart(val)) = attr {
2191 return Ok(val);
2192 }
2193 }
2194 Err(ErrorContext::new_missing(
2195 "Devlink",
2196 "FmsgArrNestStart",
2197 self.orig_loc,
2198 self.buf.as_ptr() as usize,
2199 ))
2200 }
2201 pub fn get_fmsg_nest_end(&self) -> Result<(), ErrorContext> {
2202 let mut iter = self.clone();
2203 iter.pos = 0;
2204 for attr in iter {
2205 if let Ok(Devlink::FmsgNestEnd(val)) = attr {
2206 return Ok(val);
2207 }
2208 }
2209 Err(ErrorContext::new_missing(
2210 "Devlink",
2211 "FmsgNestEnd",
2212 self.orig_loc,
2213 self.buf.as_ptr() as usize,
2214 ))
2215 }
2216 pub fn get_fmsg_obj_name(&self) -> Result<&'a CStr, ErrorContext> {
2217 let mut iter = self.clone();
2218 iter.pos = 0;
2219 for attr in iter {
2220 if let Ok(Devlink::FmsgObjName(val)) = attr {
2221 return Ok(val);
2222 }
2223 }
2224 Err(ErrorContext::new_missing(
2225 "Devlink",
2226 "FmsgObjName",
2227 self.orig_loc,
2228 self.buf.as_ptr() as usize,
2229 ))
2230 }
2231 #[doc = "Associated type: [`VarAttrType`] (enum)"]
2232 pub fn get_fmsg_obj_value_type(&self) -> Result<u8, ErrorContext> {
2233 let mut iter = self.clone();
2234 iter.pos = 0;
2235 for attr in iter {
2236 if let Ok(Devlink::FmsgObjValueType(val)) = attr {
2237 return Ok(val);
2238 }
2239 }
2240 Err(ErrorContext::new_missing(
2241 "Devlink",
2242 "FmsgObjValueType",
2243 self.orig_loc,
2244 self.buf.as_ptr() as usize,
2245 ))
2246 }
2247 pub fn get_health_reporter(&self) -> Result<IterableDlHealthReporter<'a>, ErrorContext> {
2248 let mut iter = self.clone();
2249 iter.pos = 0;
2250 for attr in iter {
2251 if let Ok(Devlink::HealthReporter(val)) = attr {
2252 return Ok(val);
2253 }
2254 }
2255 Err(ErrorContext::new_missing(
2256 "Devlink",
2257 "HealthReporter",
2258 self.orig_loc,
2259 self.buf.as_ptr() as usize,
2260 ))
2261 }
2262 pub fn get_health_reporter_name(&self) -> Result<&'a CStr, ErrorContext> {
2263 let mut iter = self.clone();
2264 iter.pos = 0;
2265 for attr in iter {
2266 if let Ok(Devlink::HealthReporterName(val)) = attr {
2267 return Ok(val);
2268 }
2269 }
2270 Err(ErrorContext::new_missing(
2271 "Devlink",
2272 "HealthReporterName",
2273 self.orig_loc,
2274 self.buf.as_ptr() as usize,
2275 ))
2276 }
2277 pub fn get_health_reporter_state(&self) -> Result<u8, ErrorContext> {
2278 let mut iter = self.clone();
2279 iter.pos = 0;
2280 for attr in iter {
2281 if let Ok(Devlink::HealthReporterState(val)) = attr {
2282 return Ok(val);
2283 }
2284 }
2285 Err(ErrorContext::new_missing(
2286 "Devlink",
2287 "HealthReporterState",
2288 self.orig_loc,
2289 self.buf.as_ptr() as usize,
2290 ))
2291 }
2292 pub fn get_health_reporter_err_count(&self) -> Result<u64, ErrorContext> {
2293 let mut iter = self.clone();
2294 iter.pos = 0;
2295 for attr in iter {
2296 if let Ok(Devlink::HealthReporterErrCount(val)) = attr {
2297 return Ok(val);
2298 }
2299 }
2300 Err(ErrorContext::new_missing(
2301 "Devlink",
2302 "HealthReporterErrCount",
2303 self.orig_loc,
2304 self.buf.as_ptr() as usize,
2305 ))
2306 }
2307 pub fn get_health_reporter_recover_count(&self) -> Result<u64, ErrorContext> {
2308 let mut iter = self.clone();
2309 iter.pos = 0;
2310 for attr in iter {
2311 if let Ok(Devlink::HealthReporterRecoverCount(val)) = attr {
2312 return Ok(val);
2313 }
2314 }
2315 Err(ErrorContext::new_missing(
2316 "Devlink",
2317 "HealthReporterRecoverCount",
2318 self.orig_loc,
2319 self.buf.as_ptr() as usize,
2320 ))
2321 }
2322 pub fn get_health_reporter_dump_ts(&self) -> Result<u64, ErrorContext> {
2323 let mut iter = self.clone();
2324 iter.pos = 0;
2325 for attr in iter {
2326 if let Ok(Devlink::HealthReporterDumpTs(val)) = attr {
2327 return Ok(val);
2328 }
2329 }
2330 Err(ErrorContext::new_missing(
2331 "Devlink",
2332 "HealthReporterDumpTs",
2333 self.orig_loc,
2334 self.buf.as_ptr() as usize,
2335 ))
2336 }
2337 pub fn get_health_reporter_graceful_period(&self) -> Result<u64, ErrorContext> {
2338 let mut iter = self.clone();
2339 iter.pos = 0;
2340 for attr in iter {
2341 if let Ok(Devlink::HealthReporterGracefulPeriod(val)) = attr {
2342 return Ok(val);
2343 }
2344 }
2345 Err(ErrorContext::new_missing(
2346 "Devlink",
2347 "HealthReporterGracefulPeriod",
2348 self.orig_loc,
2349 self.buf.as_ptr() as usize,
2350 ))
2351 }
2352 pub fn get_health_reporter_auto_recover(&self) -> Result<u8, ErrorContext> {
2353 let mut iter = self.clone();
2354 iter.pos = 0;
2355 for attr in iter {
2356 if let Ok(Devlink::HealthReporterAutoRecover(val)) = attr {
2357 return Ok(val);
2358 }
2359 }
2360 Err(ErrorContext::new_missing(
2361 "Devlink",
2362 "HealthReporterAutoRecover",
2363 self.orig_loc,
2364 self.buf.as_ptr() as usize,
2365 ))
2366 }
2367 pub fn get_flash_update_file_name(&self) -> Result<&'a CStr, ErrorContext> {
2368 let mut iter = self.clone();
2369 iter.pos = 0;
2370 for attr in iter {
2371 if let Ok(Devlink::FlashUpdateFileName(val)) = attr {
2372 return Ok(val);
2373 }
2374 }
2375 Err(ErrorContext::new_missing(
2376 "Devlink",
2377 "FlashUpdateFileName",
2378 self.orig_loc,
2379 self.buf.as_ptr() as usize,
2380 ))
2381 }
2382 pub fn get_flash_update_component(&self) -> Result<&'a CStr, ErrorContext> {
2383 let mut iter = self.clone();
2384 iter.pos = 0;
2385 for attr in iter {
2386 if let Ok(Devlink::FlashUpdateComponent(val)) = attr {
2387 return Ok(val);
2388 }
2389 }
2390 Err(ErrorContext::new_missing(
2391 "Devlink",
2392 "FlashUpdateComponent",
2393 self.orig_loc,
2394 self.buf.as_ptr() as usize,
2395 ))
2396 }
2397 pub fn get_flash_update_status_msg(&self) -> Result<&'a CStr, ErrorContext> {
2398 let mut iter = self.clone();
2399 iter.pos = 0;
2400 for attr in iter {
2401 if let Ok(Devlink::FlashUpdateStatusMsg(val)) = attr {
2402 return Ok(val);
2403 }
2404 }
2405 Err(ErrorContext::new_missing(
2406 "Devlink",
2407 "FlashUpdateStatusMsg",
2408 self.orig_loc,
2409 self.buf.as_ptr() as usize,
2410 ))
2411 }
2412 pub fn get_flash_update_status_done(&self) -> Result<u64, ErrorContext> {
2413 let mut iter = self.clone();
2414 iter.pos = 0;
2415 for attr in iter {
2416 if let Ok(Devlink::FlashUpdateStatusDone(val)) = attr {
2417 return Ok(val);
2418 }
2419 }
2420 Err(ErrorContext::new_missing(
2421 "Devlink",
2422 "FlashUpdateStatusDone",
2423 self.orig_loc,
2424 self.buf.as_ptr() as usize,
2425 ))
2426 }
2427 pub fn get_flash_update_status_total(&self) -> Result<u64, ErrorContext> {
2428 let mut iter = self.clone();
2429 iter.pos = 0;
2430 for attr in iter {
2431 if let Ok(Devlink::FlashUpdateStatusTotal(val)) = attr {
2432 return Ok(val);
2433 }
2434 }
2435 Err(ErrorContext::new_missing(
2436 "Devlink",
2437 "FlashUpdateStatusTotal",
2438 self.orig_loc,
2439 self.buf.as_ptr() as usize,
2440 ))
2441 }
2442 pub fn get_port_pci_pf_number(&self) -> Result<u16, ErrorContext> {
2443 let mut iter = self.clone();
2444 iter.pos = 0;
2445 for attr in iter {
2446 if let Ok(Devlink::PortPciPfNumber(val)) = attr {
2447 return Ok(val);
2448 }
2449 }
2450 Err(ErrorContext::new_missing(
2451 "Devlink",
2452 "PortPciPfNumber",
2453 self.orig_loc,
2454 self.buf.as_ptr() as usize,
2455 ))
2456 }
2457 pub fn get_port_pci_vf_number(&self) -> Result<u16, ErrorContext> {
2458 let mut iter = self.clone();
2459 iter.pos = 0;
2460 for attr in iter {
2461 if let Ok(Devlink::PortPciVfNumber(val)) = attr {
2462 return Ok(val);
2463 }
2464 }
2465 Err(ErrorContext::new_missing(
2466 "Devlink",
2467 "PortPciVfNumber",
2468 self.orig_loc,
2469 self.buf.as_ptr() as usize,
2470 ))
2471 }
2472 pub fn get_stats(&self) -> Result<IterableDlAttrStats<'a>, ErrorContext> {
2473 let mut iter = self.clone();
2474 iter.pos = 0;
2475 for attr in iter {
2476 if let Ok(Devlink::Stats(val)) = attr {
2477 return Ok(val);
2478 }
2479 }
2480 Err(ErrorContext::new_missing(
2481 "Devlink",
2482 "Stats",
2483 self.orig_loc,
2484 self.buf.as_ptr() as usize,
2485 ))
2486 }
2487 pub fn get_trap_name(&self) -> Result<&'a CStr, ErrorContext> {
2488 let mut iter = self.clone();
2489 iter.pos = 0;
2490 for attr in iter {
2491 if let Ok(Devlink::TrapName(val)) = attr {
2492 return Ok(val);
2493 }
2494 }
2495 Err(ErrorContext::new_missing(
2496 "Devlink",
2497 "TrapName",
2498 self.orig_loc,
2499 self.buf.as_ptr() as usize,
2500 ))
2501 }
2502 #[doc = "Associated type: [`TrapAction`] (enum)"]
2503 pub fn get_trap_action(&self) -> Result<u8, ErrorContext> {
2504 let mut iter = self.clone();
2505 iter.pos = 0;
2506 for attr in iter {
2507 if let Ok(Devlink::TrapAction(val)) = attr {
2508 return Ok(val);
2509 }
2510 }
2511 Err(ErrorContext::new_missing(
2512 "Devlink",
2513 "TrapAction",
2514 self.orig_loc,
2515 self.buf.as_ptr() as usize,
2516 ))
2517 }
2518 #[doc = "Associated type: [`TrapType`] (enum)"]
2519 pub fn get_trap_type(&self) -> Result<u8, ErrorContext> {
2520 let mut iter = self.clone();
2521 iter.pos = 0;
2522 for attr in iter {
2523 if let Ok(Devlink::TrapType(val)) = attr {
2524 return Ok(val);
2525 }
2526 }
2527 Err(ErrorContext::new_missing(
2528 "Devlink",
2529 "TrapType",
2530 self.orig_loc,
2531 self.buf.as_ptr() as usize,
2532 ))
2533 }
2534 pub fn get_trap_generic(&self) -> Result<(), ErrorContext> {
2535 let mut iter = self.clone();
2536 iter.pos = 0;
2537 for attr in iter {
2538 if let Ok(Devlink::TrapGeneric(val)) = attr {
2539 return Ok(val);
2540 }
2541 }
2542 Err(ErrorContext::new_missing(
2543 "Devlink",
2544 "TrapGeneric",
2545 self.orig_loc,
2546 self.buf.as_ptr() as usize,
2547 ))
2548 }
2549 pub fn get_trap_metadata(&self) -> Result<IterableDlTrapMetadata<'a>, ErrorContext> {
2550 let mut iter = self.clone();
2551 iter.pos = 0;
2552 for attr in iter {
2553 if let Ok(Devlink::TrapMetadata(val)) = attr {
2554 return Ok(val);
2555 }
2556 }
2557 Err(ErrorContext::new_missing(
2558 "Devlink",
2559 "TrapMetadata",
2560 self.orig_loc,
2561 self.buf.as_ptr() as usize,
2562 ))
2563 }
2564 pub fn get_trap_group_name(&self) -> Result<&'a CStr, ErrorContext> {
2565 let mut iter = self.clone();
2566 iter.pos = 0;
2567 for attr in iter {
2568 if let Ok(Devlink::TrapGroupName(val)) = attr {
2569 return Ok(val);
2570 }
2571 }
2572 Err(ErrorContext::new_missing(
2573 "Devlink",
2574 "TrapGroupName",
2575 self.orig_loc,
2576 self.buf.as_ptr() as usize,
2577 ))
2578 }
2579 pub fn get_reload_failed(&self) -> Result<u8, ErrorContext> {
2580 let mut iter = self.clone();
2581 iter.pos = 0;
2582 for attr in iter {
2583 if let Ok(Devlink::ReloadFailed(val)) = attr {
2584 return Ok(val);
2585 }
2586 }
2587 Err(ErrorContext::new_missing(
2588 "Devlink",
2589 "ReloadFailed",
2590 self.orig_loc,
2591 self.buf.as_ptr() as usize,
2592 ))
2593 }
2594 pub fn get_health_reporter_dump_ts_ns(&self) -> Result<u64, ErrorContext> {
2595 let mut iter = self.clone();
2596 iter.pos = 0;
2597 for attr in iter {
2598 if let Ok(Devlink::HealthReporterDumpTsNs(val)) = attr {
2599 return Ok(val);
2600 }
2601 }
2602 Err(ErrorContext::new_missing(
2603 "Devlink",
2604 "HealthReporterDumpTsNs",
2605 self.orig_loc,
2606 self.buf.as_ptr() as usize,
2607 ))
2608 }
2609 pub fn get_netns_fd(&self) -> Result<u32, ErrorContext> {
2610 let mut iter = self.clone();
2611 iter.pos = 0;
2612 for attr in iter {
2613 if let Ok(Devlink::NetnsFd(val)) = attr {
2614 return Ok(val);
2615 }
2616 }
2617 Err(ErrorContext::new_missing(
2618 "Devlink",
2619 "NetnsFd",
2620 self.orig_loc,
2621 self.buf.as_ptr() as usize,
2622 ))
2623 }
2624 pub fn get_netns_pid(&self) -> Result<u32, ErrorContext> {
2625 let mut iter = self.clone();
2626 iter.pos = 0;
2627 for attr in iter {
2628 if let Ok(Devlink::NetnsPid(val)) = attr {
2629 return Ok(val);
2630 }
2631 }
2632 Err(ErrorContext::new_missing(
2633 "Devlink",
2634 "NetnsPid",
2635 self.orig_loc,
2636 self.buf.as_ptr() as usize,
2637 ))
2638 }
2639 pub fn get_netns_id(&self) -> Result<u32, ErrorContext> {
2640 let mut iter = self.clone();
2641 iter.pos = 0;
2642 for attr in iter {
2643 if let Ok(Devlink::NetnsId(val)) = attr {
2644 return Ok(val);
2645 }
2646 }
2647 Err(ErrorContext::new_missing(
2648 "Devlink",
2649 "NetnsId",
2650 self.orig_loc,
2651 self.buf.as_ptr() as usize,
2652 ))
2653 }
2654 pub fn get_health_reporter_auto_dump(&self) -> Result<u8, ErrorContext> {
2655 let mut iter = self.clone();
2656 iter.pos = 0;
2657 for attr in iter {
2658 if let Ok(Devlink::HealthReporterAutoDump(val)) = attr {
2659 return Ok(val);
2660 }
2661 }
2662 Err(ErrorContext::new_missing(
2663 "Devlink",
2664 "HealthReporterAutoDump",
2665 self.orig_loc,
2666 self.buf.as_ptr() as usize,
2667 ))
2668 }
2669 pub fn get_trap_policer_id(&self) -> Result<u32, ErrorContext> {
2670 let mut iter = self.clone();
2671 iter.pos = 0;
2672 for attr in iter {
2673 if let Ok(Devlink::TrapPolicerId(val)) = attr {
2674 return Ok(val);
2675 }
2676 }
2677 Err(ErrorContext::new_missing(
2678 "Devlink",
2679 "TrapPolicerId",
2680 self.orig_loc,
2681 self.buf.as_ptr() as usize,
2682 ))
2683 }
2684 pub fn get_trap_policer_rate(&self) -> Result<u64, ErrorContext> {
2685 let mut iter = self.clone();
2686 iter.pos = 0;
2687 for attr in iter {
2688 if let Ok(Devlink::TrapPolicerRate(val)) = attr {
2689 return Ok(val);
2690 }
2691 }
2692 Err(ErrorContext::new_missing(
2693 "Devlink",
2694 "TrapPolicerRate",
2695 self.orig_loc,
2696 self.buf.as_ptr() as usize,
2697 ))
2698 }
2699 pub fn get_trap_policer_burst(&self) -> Result<u64, ErrorContext> {
2700 let mut iter = self.clone();
2701 iter.pos = 0;
2702 for attr in iter {
2703 if let Ok(Devlink::TrapPolicerBurst(val)) = attr {
2704 return Ok(val);
2705 }
2706 }
2707 Err(ErrorContext::new_missing(
2708 "Devlink",
2709 "TrapPolicerBurst",
2710 self.orig_loc,
2711 self.buf.as_ptr() as usize,
2712 ))
2713 }
2714 pub fn get_port_function(&self) -> Result<IterableDlPortFunction<'a>, ErrorContext> {
2715 let mut iter = self.clone();
2716 iter.pos = 0;
2717 for attr in iter {
2718 if let Ok(Devlink::PortFunction(val)) = attr {
2719 return Ok(val);
2720 }
2721 }
2722 Err(ErrorContext::new_missing(
2723 "Devlink",
2724 "PortFunction",
2725 self.orig_loc,
2726 self.buf.as_ptr() as usize,
2727 ))
2728 }
2729 pub fn get_info_board_serial_number(&self) -> Result<&'a CStr, ErrorContext> {
2730 let mut iter = self.clone();
2731 iter.pos = 0;
2732 for attr in iter {
2733 if let Ok(Devlink::InfoBoardSerialNumber(val)) = attr {
2734 return Ok(val);
2735 }
2736 }
2737 Err(ErrorContext::new_missing(
2738 "Devlink",
2739 "InfoBoardSerialNumber",
2740 self.orig_loc,
2741 self.buf.as_ptr() as usize,
2742 ))
2743 }
2744 pub fn get_port_lanes(&self) -> Result<u32, ErrorContext> {
2745 let mut iter = self.clone();
2746 iter.pos = 0;
2747 for attr in iter {
2748 if let Ok(Devlink::PortLanes(val)) = attr {
2749 return Ok(val);
2750 }
2751 }
2752 Err(ErrorContext::new_missing(
2753 "Devlink",
2754 "PortLanes",
2755 self.orig_loc,
2756 self.buf.as_ptr() as usize,
2757 ))
2758 }
2759 pub fn get_port_splittable(&self) -> Result<u8, ErrorContext> {
2760 let mut iter = self.clone();
2761 iter.pos = 0;
2762 for attr in iter {
2763 if let Ok(Devlink::PortSplittable(val)) = attr {
2764 return Ok(val);
2765 }
2766 }
2767 Err(ErrorContext::new_missing(
2768 "Devlink",
2769 "PortSplittable",
2770 self.orig_loc,
2771 self.buf.as_ptr() as usize,
2772 ))
2773 }
2774 pub fn get_port_external(&self) -> Result<u8, ErrorContext> {
2775 let mut iter = self.clone();
2776 iter.pos = 0;
2777 for attr in iter {
2778 if let Ok(Devlink::PortExternal(val)) = attr {
2779 return Ok(val);
2780 }
2781 }
2782 Err(ErrorContext::new_missing(
2783 "Devlink",
2784 "PortExternal",
2785 self.orig_loc,
2786 self.buf.as_ptr() as usize,
2787 ))
2788 }
2789 pub fn get_port_controller_number(&self) -> Result<u32, ErrorContext> {
2790 let mut iter = self.clone();
2791 iter.pos = 0;
2792 for attr in iter {
2793 if let Ok(Devlink::PortControllerNumber(val)) = attr {
2794 return Ok(val);
2795 }
2796 }
2797 Err(ErrorContext::new_missing(
2798 "Devlink",
2799 "PortControllerNumber",
2800 self.orig_loc,
2801 self.buf.as_ptr() as usize,
2802 ))
2803 }
2804 pub fn get_flash_update_status_timeout(&self) -> Result<u64, ErrorContext> {
2805 let mut iter = self.clone();
2806 iter.pos = 0;
2807 for attr in iter {
2808 if let Ok(Devlink::FlashUpdateStatusTimeout(val)) = attr {
2809 return Ok(val);
2810 }
2811 }
2812 Err(ErrorContext::new_missing(
2813 "Devlink",
2814 "FlashUpdateStatusTimeout",
2815 self.orig_loc,
2816 self.buf.as_ptr() as usize,
2817 ))
2818 }
2819 #[doc = "Associated type: [`FlashOverwrite`] (1 bit per enumeration)"]
2820 pub fn get_flash_update_overwrite_mask(&self) -> Result<BuiltinBitfield32, ErrorContext> {
2821 let mut iter = self.clone();
2822 iter.pos = 0;
2823 for attr in iter {
2824 if let Ok(Devlink::FlashUpdateOverwriteMask(val)) = attr {
2825 return Ok(val);
2826 }
2827 }
2828 Err(ErrorContext::new_missing(
2829 "Devlink",
2830 "FlashUpdateOverwriteMask",
2831 self.orig_loc,
2832 self.buf.as_ptr() as usize,
2833 ))
2834 }
2835 #[doc = "Associated type: [`ReloadAction`] (enum)"]
2836 pub fn get_reload_action(&self) -> Result<u8, ErrorContext> {
2837 let mut iter = self.clone();
2838 iter.pos = 0;
2839 for attr in iter {
2840 if let Ok(Devlink::ReloadAction(val)) = attr {
2841 return Ok(val);
2842 }
2843 }
2844 Err(ErrorContext::new_missing(
2845 "Devlink",
2846 "ReloadAction",
2847 self.orig_loc,
2848 self.buf.as_ptr() as usize,
2849 ))
2850 }
2851 #[doc = "Associated type: [`ReloadAction`] (1 bit per enumeration)"]
2852 pub fn get_reload_actions_performed(&self) -> Result<BuiltinBitfield32, ErrorContext> {
2853 let mut iter = self.clone();
2854 iter.pos = 0;
2855 for attr in iter {
2856 if let Ok(Devlink::ReloadActionsPerformed(val)) = attr {
2857 return Ok(val);
2858 }
2859 }
2860 Err(ErrorContext::new_missing(
2861 "Devlink",
2862 "ReloadActionsPerformed",
2863 self.orig_loc,
2864 self.buf.as_ptr() as usize,
2865 ))
2866 }
2867 #[doc = "Associated type: [`ReloadAction`] (1 bit per enumeration)"]
2868 pub fn get_reload_limits(&self) -> Result<BuiltinBitfield32, ErrorContext> {
2869 let mut iter = self.clone();
2870 iter.pos = 0;
2871 for attr in iter {
2872 if let Ok(Devlink::ReloadLimits(val)) = attr {
2873 return Ok(val);
2874 }
2875 }
2876 Err(ErrorContext::new_missing(
2877 "Devlink",
2878 "ReloadLimits",
2879 self.orig_loc,
2880 self.buf.as_ptr() as usize,
2881 ))
2882 }
2883 pub fn get_dev_stats(&self) -> Result<IterableDlDevStats<'a>, ErrorContext> {
2884 let mut iter = self.clone();
2885 iter.pos = 0;
2886 for attr in iter {
2887 if let Ok(Devlink::DevStats(val)) = attr {
2888 return Ok(val);
2889 }
2890 }
2891 Err(ErrorContext::new_missing(
2892 "Devlink",
2893 "DevStats",
2894 self.orig_loc,
2895 self.buf.as_ptr() as usize,
2896 ))
2897 }
2898 pub fn get_reload_stats(&self) -> Result<IterableDlReloadStats<'a>, ErrorContext> {
2899 let mut iter = self.clone();
2900 iter.pos = 0;
2901 for attr in iter {
2902 if let Ok(Devlink::ReloadStats(val)) = attr {
2903 return Ok(val);
2904 }
2905 }
2906 Err(ErrorContext::new_missing(
2907 "Devlink",
2908 "ReloadStats",
2909 self.orig_loc,
2910 self.buf.as_ptr() as usize,
2911 ))
2912 }
2913 #[doc = "Attribute may repeat multiple times (treat it as array)"]
2914 pub fn get_reload_stats_entry(
2915 &self,
2916 ) -> MultiAttrIterable<Self, Devlink<'a>, IterableDlReloadStatsEntry<'a>> {
2917 MultiAttrIterable::new(self.clone(), |variant| {
2918 if let Devlink::ReloadStatsEntry(val) = variant {
2919 Some(val)
2920 } else {
2921 None
2922 }
2923 })
2924 }
2925 pub fn get_reload_stats_limit(&self) -> Result<u8, ErrorContext> {
2926 let mut iter = self.clone();
2927 iter.pos = 0;
2928 for attr in iter {
2929 if let Ok(Devlink::ReloadStatsLimit(val)) = attr {
2930 return Ok(val);
2931 }
2932 }
2933 Err(ErrorContext::new_missing(
2934 "Devlink",
2935 "ReloadStatsLimit",
2936 self.orig_loc,
2937 self.buf.as_ptr() as usize,
2938 ))
2939 }
2940 pub fn get_reload_stats_value(&self) -> Result<u32, ErrorContext> {
2941 let mut iter = self.clone();
2942 iter.pos = 0;
2943 for attr in iter {
2944 if let Ok(Devlink::ReloadStatsValue(val)) = attr {
2945 return Ok(val);
2946 }
2947 }
2948 Err(ErrorContext::new_missing(
2949 "Devlink",
2950 "ReloadStatsValue",
2951 self.orig_loc,
2952 self.buf.as_ptr() as usize,
2953 ))
2954 }
2955 pub fn get_remote_reload_stats(&self) -> Result<IterableDlReloadStats<'a>, ErrorContext> {
2956 let mut iter = self.clone();
2957 iter.pos = 0;
2958 for attr in iter {
2959 if let Ok(Devlink::RemoteReloadStats(val)) = attr {
2960 return Ok(val);
2961 }
2962 }
2963 Err(ErrorContext::new_missing(
2964 "Devlink",
2965 "RemoteReloadStats",
2966 self.orig_loc,
2967 self.buf.as_ptr() as usize,
2968 ))
2969 }
2970 #[doc = "Attribute may repeat multiple times (treat it as array)"]
2971 pub fn get_reload_action_info(
2972 &self,
2973 ) -> MultiAttrIterable<Self, Devlink<'a>, IterableDlReloadActInfo<'a>> {
2974 MultiAttrIterable::new(self.clone(), |variant| {
2975 if let Devlink::ReloadActionInfo(val) = variant {
2976 Some(val)
2977 } else {
2978 None
2979 }
2980 })
2981 }
2982 #[doc = "Attribute may repeat multiple times (treat it as array)"]
2983 pub fn get_reload_action_stats(
2984 &self,
2985 ) -> MultiAttrIterable<Self, Devlink<'a>, IterableDlReloadActStats<'a>> {
2986 MultiAttrIterable::new(self.clone(), |variant| {
2987 if let Devlink::ReloadActionStats(val) = variant {
2988 Some(val)
2989 } else {
2990 None
2991 }
2992 })
2993 }
2994 pub fn get_port_pci_sf_number(&self) -> Result<u32, ErrorContext> {
2995 let mut iter = self.clone();
2996 iter.pos = 0;
2997 for attr in iter {
2998 if let Ok(Devlink::PortPciSfNumber(val)) = attr {
2999 return Ok(val);
3000 }
3001 }
3002 Err(ErrorContext::new_missing(
3003 "Devlink",
3004 "PortPciSfNumber",
3005 self.orig_loc,
3006 self.buf.as_ptr() as usize,
3007 ))
3008 }
3009 #[doc = "Associated type: [`RateType`] (enum)"]
3010 pub fn get_rate_type(&self) -> Result<u16, ErrorContext> {
3011 let mut iter = self.clone();
3012 iter.pos = 0;
3013 for attr in iter {
3014 if let Ok(Devlink::RateType(val)) = attr {
3015 return Ok(val);
3016 }
3017 }
3018 Err(ErrorContext::new_missing(
3019 "Devlink",
3020 "RateType",
3021 self.orig_loc,
3022 self.buf.as_ptr() as usize,
3023 ))
3024 }
3025 pub fn get_rate_tx_share(&self) -> Result<u64, ErrorContext> {
3026 let mut iter = self.clone();
3027 iter.pos = 0;
3028 for attr in iter {
3029 if let Ok(Devlink::RateTxShare(val)) = attr {
3030 return Ok(val);
3031 }
3032 }
3033 Err(ErrorContext::new_missing(
3034 "Devlink",
3035 "RateTxShare",
3036 self.orig_loc,
3037 self.buf.as_ptr() as usize,
3038 ))
3039 }
3040 pub fn get_rate_tx_max(&self) -> Result<u64, ErrorContext> {
3041 let mut iter = self.clone();
3042 iter.pos = 0;
3043 for attr in iter {
3044 if let Ok(Devlink::RateTxMax(val)) = attr {
3045 return Ok(val);
3046 }
3047 }
3048 Err(ErrorContext::new_missing(
3049 "Devlink",
3050 "RateTxMax",
3051 self.orig_loc,
3052 self.buf.as_ptr() as usize,
3053 ))
3054 }
3055 pub fn get_rate_node_name(&self) -> Result<&'a CStr, ErrorContext> {
3056 let mut iter = self.clone();
3057 iter.pos = 0;
3058 for attr in iter {
3059 if let Ok(Devlink::RateNodeName(val)) = attr {
3060 return Ok(val);
3061 }
3062 }
3063 Err(ErrorContext::new_missing(
3064 "Devlink",
3065 "RateNodeName",
3066 self.orig_loc,
3067 self.buf.as_ptr() as usize,
3068 ))
3069 }
3070 pub fn get_rate_parent_node_name(&self) -> Result<&'a CStr, ErrorContext> {
3071 let mut iter = self.clone();
3072 iter.pos = 0;
3073 for attr in iter {
3074 if let Ok(Devlink::RateParentNodeName(val)) = attr {
3075 return Ok(val);
3076 }
3077 }
3078 Err(ErrorContext::new_missing(
3079 "Devlink",
3080 "RateParentNodeName",
3081 self.orig_loc,
3082 self.buf.as_ptr() as usize,
3083 ))
3084 }
3085 pub fn get_region_max_snapshots(&self) -> Result<u32, ErrorContext> {
3086 let mut iter = self.clone();
3087 iter.pos = 0;
3088 for attr in iter {
3089 if let Ok(Devlink::RegionMaxSnapshots(val)) = attr {
3090 return Ok(val);
3091 }
3092 }
3093 Err(ErrorContext::new_missing(
3094 "Devlink",
3095 "RegionMaxSnapshots",
3096 self.orig_loc,
3097 self.buf.as_ptr() as usize,
3098 ))
3099 }
3100 pub fn get_linecard_index(&self) -> Result<u32, ErrorContext> {
3101 let mut iter = self.clone();
3102 iter.pos = 0;
3103 for attr in iter {
3104 if let Ok(Devlink::LinecardIndex(val)) = attr {
3105 return Ok(val);
3106 }
3107 }
3108 Err(ErrorContext::new_missing(
3109 "Devlink",
3110 "LinecardIndex",
3111 self.orig_loc,
3112 self.buf.as_ptr() as usize,
3113 ))
3114 }
3115 pub fn get_linecard_state(&self) -> Result<u8, ErrorContext> {
3116 let mut iter = self.clone();
3117 iter.pos = 0;
3118 for attr in iter {
3119 if let Ok(Devlink::LinecardState(val)) = attr {
3120 return Ok(val);
3121 }
3122 }
3123 Err(ErrorContext::new_missing(
3124 "Devlink",
3125 "LinecardState",
3126 self.orig_loc,
3127 self.buf.as_ptr() as usize,
3128 ))
3129 }
3130 pub fn get_linecard_type(&self) -> Result<&'a CStr, ErrorContext> {
3131 let mut iter = self.clone();
3132 iter.pos = 0;
3133 for attr in iter {
3134 if let Ok(Devlink::LinecardType(val)) = attr {
3135 return Ok(val);
3136 }
3137 }
3138 Err(ErrorContext::new_missing(
3139 "Devlink",
3140 "LinecardType",
3141 self.orig_loc,
3142 self.buf.as_ptr() as usize,
3143 ))
3144 }
3145 pub fn get_linecard_supported_types(
3146 &self,
3147 ) -> Result<IterableDlLinecardSupportedTypes<'a>, ErrorContext> {
3148 let mut iter = self.clone();
3149 iter.pos = 0;
3150 for attr in iter {
3151 if let Ok(Devlink::LinecardSupportedTypes(val)) = attr {
3152 return Ok(val);
3153 }
3154 }
3155 Err(ErrorContext::new_missing(
3156 "Devlink",
3157 "LinecardSupportedTypes",
3158 self.orig_loc,
3159 self.buf.as_ptr() as usize,
3160 ))
3161 }
3162 pub fn get_selftests(&self) -> Result<IterableDlSelftestId<'a>, ErrorContext> {
3163 let mut iter = self.clone();
3164 iter.pos = 0;
3165 for attr in iter {
3166 if let Ok(Devlink::Selftests(val)) = attr {
3167 return Ok(val);
3168 }
3169 }
3170 Err(ErrorContext::new_missing(
3171 "Devlink",
3172 "Selftests",
3173 self.orig_loc,
3174 self.buf.as_ptr() as usize,
3175 ))
3176 }
3177 pub fn get_rate_tx_priority(&self) -> Result<u32, ErrorContext> {
3178 let mut iter = self.clone();
3179 iter.pos = 0;
3180 for attr in iter {
3181 if let Ok(Devlink::RateTxPriority(val)) = attr {
3182 return Ok(val);
3183 }
3184 }
3185 Err(ErrorContext::new_missing(
3186 "Devlink",
3187 "RateTxPriority",
3188 self.orig_loc,
3189 self.buf.as_ptr() as usize,
3190 ))
3191 }
3192 pub fn get_rate_tx_weight(&self) -> Result<u32, ErrorContext> {
3193 let mut iter = self.clone();
3194 iter.pos = 0;
3195 for attr in iter {
3196 if let Ok(Devlink::RateTxWeight(val)) = attr {
3197 return Ok(val);
3198 }
3199 }
3200 Err(ErrorContext::new_missing(
3201 "Devlink",
3202 "RateTxWeight",
3203 self.orig_loc,
3204 self.buf.as_ptr() as usize,
3205 ))
3206 }
3207 pub fn get_region_direct(&self) -> Result<(), ErrorContext> {
3208 let mut iter = self.clone();
3209 iter.pos = 0;
3210 for attr in iter {
3211 if let Ok(Devlink::RegionDirect(val)) = attr {
3212 return Ok(val);
3213 }
3214 }
3215 Err(ErrorContext::new_missing(
3216 "Devlink",
3217 "RegionDirect",
3218 self.orig_loc,
3219 self.buf.as_ptr() as usize,
3220 ))
3221 }
3222 #[doc = "Attribute may repeat multiple times (treat it as array)"]
3223 pub fn get_rate_tc_bws(&self) -> MultiAttrIterable<Self, Devlink<'a>, IterableDlRateTcBws<'a>> {
3224 MultiAttrIterable::new(self.clone(), |variant| {
3225 if let Devlink::RateTcBws(val) = variant {
3226 Some(val)
3227 } else {
3228 None
3229 }
3230 })
3231 }
3232 #[doc = "Time (in msec) for recoveries before starting the grace period.\n"]
3233 pub fn get_health_reporter_burst_period(&self) -> Result<u64, ErrorContext> {
3234 let mut iter = self.clone();
3235 iter.pos = 0;
3236 for attr in iter {
3237 if let Ok(Devlink::HealthReporterBurstPeriod(val)) = attr {
3238 return Ok(val);
3239 }
3240 }
3241 Err(ErrorContext::new_missing(
3242 "Devlink",
3243 "HealthReporterBurstPeriod",
3244 self.orig_loc,
3245 self.buf.as_ptr() as usize,
3246 ))
3247 }
3248 #[doc = "Request restoring parameter to its default value.\n"]
3249 pub fn get_param_reset_default(&self) -> Result<(), ErrorContext> {
3250 let mut iter = self.clone();
3251 iter.pos = 0;
3252 for attr in iter {
3253 if let Ok(Devlink::ParamResetDefault(val)) = attr {
3254 return Ok(val);
3255 }
3256 }
3257 Err(ErrorContext::new_missing(
3258 "Devlink",
3259 "ParamResetDefault",
3260 self.orig_loc,
3261 self.buf.as_ptr() as usize,
3262 ))
3263 }
3264 #[doc = "Unique devlink instance index.\n"]
3265 pub fn get_index(&self) -> Result<u32, ErrorContext> {
3266 let mut iter = self.clone();
3267 iter.pos = 0;
3268 for attr in iter {
3269 if let Ok(Devlink::Index(val)) = attr {
3270 return Ok(val);
3271 }
3272 }
3273 Err(ErrorContext::new_missing(
3274 "Devlink",
3275 "Index",
3276 self.orig_loc,
3277 self.buf.as_ptr() as usize,
3278 ))
3279 }
3280 #[doc = "Bitmask selecting which resource classes to include in a resource-dump\nresponse. Bit 0 (dev) selects device-level resources; bit 1 (port)\nselects port-level resources. When absent all classes are returned.\n\nAssociated type: [`ResourceScope`] (1 bit per enumeration)"]
3281 pub fn get_resource_scope_mask(&self) -> Result<u32, ErrorContext> {
3282 let mut iter = self.clone();
3283 iter.pos = 0;
3284 for attr in iter {
3285 if let Ok(Devlink::ResourceScopeMask(val)) = attr {
3286 return Ok(val);
3287 }
3288 }
3289 Err(ErrorContext::new_missing(
3290 "Devlink",
3291 "ResourceScopeMask",
3292 self.orig_loc,
3293 self.buf.as_ptr() as usize,
3294 ))
3295 }
3296}
3297impl Devlink<'_> {
3298 pub fn new<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
3299 IterableDevlink::with_loc(buf, buf.as_ptr() as usize)
3300 }
3301 fn attr_from_type(r#type: u16) -> Option<&'static str> {
3302 let res = match r#type {
3303 1u16 => "BusName",
3304 2u16 => "DevName",
3305 3u16 => "PortIndex",
3306 4u16 => "PortType",
3307 5u16 => "PortDesiredType",
3308 6u16 => "PortNetdevIfindex",
3309 7u16 => "PortNetdevName",
3310 8u16 => "PortIbdevName",
3311 9u16 => "PortSplitCount",
3312 10u16 => "PortSplitGroup",
3313 11u16 => "SbIndex",
3314 12u16 => "SbSize",
3315 13u16 => "SbIngressPoolCount",
3316 14u16 => "SbEgressPoolCount",
3317 15u16 => "SbIngressTcCount",
3318 16u16 => "SbEgressTcCount",
3319 17u16 => "SbPoolIndex",
3320 18u16 => "SbPoolType",
3321 19u16 => "SbPoolSize",
3322 20u16 => "SbPoolThresholdType",
3323 21u16 => "SbThreshold",
3324 22u16 => "SbTcIndex",
3325 23u16 => "SbOccCur",
3326 24u16 => "SbOccMax",
3327 25u16 => "EswitchMode",
3328 26u16 => "EswitchInlineMode",
3329 27u16 => "DpipeTables",
3330 28u16 => "DpipeTable",
3331 29u16 => "DpipeTableName",
3332 30u16 => "DpipeTableSize",
3333 31u16 => "DpipeTableMatches",
3334 32u16 => "DpipeTableActions",
3335 33u16 => "DpipeTableCountersEnabled",
3336 34u16 => "DpipeEntries",
3337 35u16 => "DpipeEntry",
3338 36u16 => "DpipeEntryIndex",
3339 37u16 => "DpipeEntryMatchValues",
3340 38u16 => "DpipeEntryActionValues",
3341 39u16 => "DpipeEntryCounter",
3342 40u16 => "DpipeMatch",
3343 41u16 => "DpipeMatchValue",
3344 42u16 => "DpipeMatchType",
3345 43u16 => "DpipeAction",
3346 44u16 => "DpipeActionValue",
3347 45u16 => "DpipeActionType",
3348 46u16 => "DpipeValue",
3349 47u16 => "DpipeValueMask",
3350 48u16 => "DpipeValueMapping",
3351 49u16 => "DpipeHeaders",
3352 50u16 => "DpipeHeader",
3353 51u16 => "DpipeHeaderName",
3354 52u16 => "DpipeHeaderId",
3355 53u16 => "DpipeHeaderFields",
3356 54u16 => "DpipeHeaderGlobal",
3357 55u16 => "DpipeHeaderIndex",
3358 56u16 => "DpipeField",
3359 57u16 => "DpipeFieldName",
3360 58u16 => "DpipeFieldId",
3361 59u16 => "DpipeFieldBitwidth",
3362 60u16 => "DpipeFieldMappingType",
3363 61u16 => "Pad",
3364 62u16 => "EswitchEncapMode",
3365 63u16 => "ResourceList",
3366 64u16 => "Resource",
3367 65u16 => "ResourceName",
3368 66u16 => "ResourceId",
3369 67u16 => "ResourceSize",
3370 68u16 => "ResourceSizeNew",
3371 69u16 => "ResourceSizeValid",
3372 70u16 => "ResourceSizeMin",
3373 71u16 => "ResourceSizeMax",
3374 72u16 => "ResourceSizeGran",
3375 73u16 => "ResourceUnit",
3376 74u16 => "ResourceOcc",
3377 75u16 => "DpipeTableResourceId",
3378 76u16 => "DpipeTableResourceUnits",
3379 77u16 => "PortFlavour",
3380 78u16 => "PortNumber",
3381 79u16 => "PortSplitSubportNumber",
3382 80u16 => "Param",
3383 81u16 => "ParamName",
3384 82u16 => "ParamGeneric",
3385 83u16 => "ParamType",
3386 87u16 => "ParamValueCmode",
3387 88u16 => "RegionName",
3388 89u16 => "RegionSize",
3389 90u16 => "RegionSnapshots",
3390 91u16 => "RegionSnapshot",
3391 92u16 => "RegionSnapshotId",
3392 93u16 => "RegionChunks",
3393 94u16 => "RegionChunk",
3394 95u16 => "RegionChunkData",
3395 96u16 => "RegionChunkAddr",
3396 97u16 => "RegionChunkLen",
3397 98u16 => "InfoDriverName",
3398 99u16 => "InfoSerialNumber",
3399 100u16 => "InfoVersionFixed",
3400 101u16 => "InfoVersionRunning",
3401 102u16 => "InfoVersionStored",
3402 103u16 => "InfoVersionName",
3403 104u16 => "InfoVersionValue",
3404 105u16 => "SbPoolCellSize",
3405 106u16 => "Fmsg",
3406 107u16 => "FmsgObjNestStart",
3407 108u16 => "FmsgPairNestStart",
3408 109u16 => "FmsgArrNestStart",
3409 110u16 => "FmsgNestEnd",
3410 111u16 => "FmsgObjName",
3411 112u16 => "FmsgObjValueType",
3412 114u16 => "HealthReporter",
3413 115u16 => "HealthReporterName",
3414 116u16 => "HealthReporterState",
3415 117u16 => "HealthReporterErrCount",
3416 118u16 => "HealthReporterRecoverCount",
3417 119u16 => "HealthReporterDumpTs",
3418 120u16 => "HealthReporterGracefulPeriod",
3419 121u16 => "HealthReporterAutoRecover",
3420 122u16 => "FlashUpdateFileName",
3421 123u16 => "FlashUpdateComponent",
3422 124u16 => "FlashUpdateStatusMsg",
3423 125u16 => "FlashUpdateStatusDone",
3424 126u16 => "FlashUpdateStatusTotal",
3425 127u16 => "PortPciPfNumber",
3426 128u16 => "PortPciVfNumber",
3427 129u16 => "Stats",
3428 130u16 => "TrapName",
3429 131u16 => "TrapAction",
3430 132u16 => "TrapType",
3431 133u16 => "TrapGeneric",
3432 134u16 => "TrapMetadata",
3433 135u16 => "TrapGroupName",
3434 136u16 => "ReloadFailed",
3435 137u16 => "HealthReporterDumpTsNs",
3436 138u16 => "NetnsFd",
3437 139u16 => "NetnsPid",
3438 140u16 => "NetnsId",
3439 141u16 => "HealthReporterAutoDump",
3440 142u16 => "TrapPolicerId",
3441 143u16 => "TrapPolicerRate",
3442 144u16 => "TrapPolicerBurst",
3443 145u16 => "PortFunction",
3444 146u16 => "InfoBoardSerialNumber",
3445 147u16 => "PortLanes",
3446 148u16 => "PortSplittable",
3447 149u16 => "PortExternal",
3448 150u16 => "PortControllerNumber",
3449 151u16 => "FlashUpdateStatusTimeout",
3450 152u16 => "FlashUpdateOverwriteMask",
3451 153u16 => "ReloadAction",
3452 154u16 => "ReloadActionsPerformed",
3453 155u16 => "ReloadLimits",
3454 156u16 => "DevStats",
3455 157u16 => "ReloadStats",
3456 158u16 => "ReloadStatsEntry",
3457 159u16 => "ReloadStatsLimit",
3458 160u16 => "ReloadStatsValue",
3459 161u16 => "RemoteReloadStats",
3460 162u16 => "ReloadActionInfo",
3461 163u16 => "ReloadActionStats",
3462 164u16 => "PortPciSfNumber",
3463 165u16 => "RateType",
3464 166u16 => "RateTxShare",
3465 167u16 => "RateTxMax",
3466 168u16 => "RateNodeName",
3467 169u16 => "RateParentNodeName",
3468 170u16 => "RegionMaxSnapshots",
3469 171u16 => "LinecardIndex",
3470 172u16 => "LinecardState",
3471 173u16 => "LinecardType",
3472 174u16 => "LinecardSupportedTypes",
3473 176u16 => "Selftests",
3474 177u16 => "RateTxPriority",
3475 178u16 => "RateTxWeight",
3476 179u16 => "RegionDirect",
3477 180u16 => "RateTcBws",
3478 181u16 => "HealthReporterBurstPeriod",
3479 183u16 => "ParamResetDefault",
3480 184u16 => "Index",
3481 185u16 => "ResourceScopeMask",
3482 _ => return None,
3483 };
3484 Some(res)
3485 }
3486}
3487#[derive(Clone, Copy, Default)]
3488pub struct IterableDevlink<'a> {
3489 buf: &'a [u8],
3490 pos: usize,
3491 orig_loc: usize,
3492}
3493impl<'a> IterableDevlink<'a> {
3494 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
3495 Self {
3496 buf,
3497 pos: 0,
3498 orig_loc,
3499 }
3500 }
3501 pub fn get_buf(&self) -> &'a [u8] {
3502 self.buf
3503 }
3504}
3505impl<'a> Iterator for IterableDevlink<'a> {
3506 type Item = Result<Devlink<'a>, ErrorContext>;
3507 fn next(&mut self) -> Option<Self::Item> {
3508 let mut pos;
3509 let mut r#type;
3510 loop {
3511 pos = self.pos;
3512 r#type = None;
3513 if self.buf.len() == self.pos {
3514 return None;
3515 }
3516 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
3517 self.pos = self.buf.len();
3518 break;
3519 };
3520 r#type = Some(header.r#type);
3521 let res = match header.r#type {
3522 1u16 => Devlink::BusName({
3523 let res = CStr::from_bytes_with_nul(next).ok();
3524 let Some(val) = res else { break };
3525 val
3526 }),
3527 2u16 => Devlink::DevName({
3528 let res = CStr::from_bytes_with_nul(next).ok();
3529 let Some(val) = res else { break };
3530 val
3531 }),
3532 3u16 => Devlink::PortIndex({
3533 let res = parse_u32(next);
3534 let Some(val) = res else { break };
3535 val
3536 }),
3537 4u16 => Devlink::PortType({
3538 let res = parse_u16(next);
3539 let Some(val) = res else { break };
3540 val
3541 }),
3542 5u16 => Devlink::PortDesiredType({
3543 let res = parse_u16(next);
3544 let Some(val) = res else { break };
3545 val
3546 }),
3547 6u16 => Devlink::PortNetdevIfindex({
3548 let res = parse_u32(next);
3549 let Some(val) = res else { break };
3550 val
3551 }),
3552 7u16 => Devlink::PortNetdevName({
3553 let res = CStr::from_bytes_with_nul(next).ok();
3554 let Some(val) = res else { break };
3555 val
3556 }),
3557 8u16 => Devlink::PortIbdevName({
3558 let res = CStr::from_bytes_with_nul(next).ok();
3559 let Some(val) = res else { break };
3560 val
3561 }),
3562 9u16 => Devlink::PortSplitCount({
3563 let res = parse_u32(next);
3564 let Some(val) = res else { break };
3565 val
3566 }),
3567 10u16 => Devlink::PortSplitGroup({
3568 let res = parse_u32(next);
3569 let Some(val) = res else { break };
3570 val
3571 }),
3572 11u16 => Devlink::SbIndex({
3573 let res = parse_u32(next);
3574 let Some(val) = res else { break };
3575 val
3576 }),
3577 12u16 => Devlink::SbSize({
3578 let res = parse_u32(next);
3579 let Some(val) = res else { break };
3580 val
3581 }),
3582 13u16 => Devlink::SbIngressPoolCount({
3583 let res = parse_u16(next);
3584 let Some(val) = res else { break };
3585 val
3586 }),
3587 14u16 => Devlink::SbEgressPoolCount({
3588 let res = parse_u16(next);
3589 let Some(val) = res else { break };
3590 val
3591 }),
3592 15u16 => Devlink::SbIngressTcCount({
3593 let res = parse_u16(next);
3594 let Some(val) = res else { break };
3595 val
3596 }),
3597 16u16 => Devlink::SbEgressTcCount({
3598 let res = parse_u16(next);
3599 let Some(val) = res else { break };
3600 val
3601 }),
3602 17u16 => Devlink::SbPoolIndex({
3603 let res = parse_u16(next);
3604 let Some(val) = res else { break };
3605 val
3606 }),
3607 18u16 => Devlink::SbPoolType({
3608 let res = parse_u8(next);
3609 let Some(val) = res else { break };
3610 val
3611 }),
3612 19u16 => Devlink::SbPoolSize({
3613 let res = parse_u32(next);
3614 let Some(val) = res else { break };
3615 val
3616 }),
3617 20u16 => Devlink::SbPoolThresholdType({
3618 let res = parse_u8(next);
3619 let Some(val) = res else { break };
3620 val
3621 }),
3622 21u16 => Devlink::SbThreshold({
3623 let res = parse_u32(next);
3624 let Some(val) = res else { break };
3625 val
3626 }),
3627 22u16 => Devlink::SbTcIndex({
3628 let res = parse_u16(next);
3629 let Some(val) = res else { break };
3630 val
3631 }),
3632 23u16 => Devlink::SbOccCur({
3633 let res = parse_u32(next);
3634 let Some(val) = res else { break };
3635 val
3636 }),
3637 24u16 => Devlink::SbOccMax({
3638 let res = parse_u32(next);
3639 let Some(val) = res else { break };
3640 val
3641 }),
3642 25u16 => Devlink::EswitchMode({
3643 let res = parse_u16(next);
3644 let Some(val) = res else { break };
3645 val
3646 }),
3647 26u16 => Devlink::EswitchInlineMode({
3648 let res = parse_u8(next);
3649 let Some(val) = res else { break };
3650 val
3651 }),
3652 27u16 => Devlink::DpipeTables({
3653 let res = Some(IterableDlDpipeTables::with_loc(next, self.orig_loc));
3654 let Some(val) = res else { break };
3655 val
3656 }),
3657 28u16 => Devlink::DpipeTable({
3658 let res = Some(IterableDlDpipeTable::with_loc(next, self.orig_loc));
3659 let Some(val) = res else { break };
3660 val
3661 }),
3662 29u16 => Devlink::DpipeTableName({
3663 let res = CStr::from_bytes_with_nul(next).ok();
3664 let Some(val) = res else { break };
3665 val
3666 }),
3667 30u16 => Devlink::DpipeTableSize({
3668 let res = parse_u64(next);
3669 let Some(val) = res else { break };
3670 val
3671 }),
3672 31u16 => Devlink::DpipeTableMatches({
3673 let res = Some(IterableDlDpipeTableMatches::with_loc(next, self.orig_loc));
3674 let Some(val) = res else { break };
3675 val
3676 }),
3677 32u16 => Devlink::DpipeTableActions({
3678 let res = Some(IterableDlDpipeTableActions::with_loc(next, self.orig_loc));
3679 let Some(val) = res else { break };
3680 val
3681 }),
3682 33u16 => Devlink::DpipeTableCountersEnabled({
3683 let res = parse_u8(next);
3684 let Some(val) = res else { break };
3685 val
3686 }),
3687 34u16 => Devlink::DpipeEntries({
3688 let res = Some(IterableDlDpipeEntries::with_loc(next, self.orig_loc));
3689 let Some(val) = res else { break };
3690 val
3691 }),
3692 35u16 => Devlink::DpipeEntry({
3693 let res = Some(IterableDlDpipeEntry::with_loc(next, self.orig_loc));
3694 let Some(val) = res else { break };
3695 val
3696 }),
3697 36u16 => Devlink::DpipeEntryIndex({
3698 let res = parse_u64(next);
3699 let Some(val) = res else { break };
3700 val
3701 }),
3702 37u16 => Devlink::DpipeEntryMatchValues({
3703 let res = Some(IterableDlDpipeEntryMatchValues::with_loc(
3704 next,
3705 self.orig_loc,
3706 ));
3707 let Some(val) = res else { break };
3708 val
3709 }),
3710 38u16 => Devlink::DpipeEntryActionValues({
3711 let res = Some(IterableDlDpipeEntryActionValues::with_loc(
3712 next,
3713 self.orig_loc,
3714 ));
3715 let Some(val) = res else { break };
3716 val
3717 }),
3718 39u16 => Devlink::DpipeEntryCounter({
3719 let res = parse_u64(next);
3720 let Some(val) = res else { break };
3721 val
3722 }),
3723 40u16 => Devlink::DpipeMatch({
3724 let res = Some(IterableDlDpipeMatch::with_loc(next, self.orig_loc));
3725 let Some(val) = res else { break };
3726 val
3727 }),
3728 41u16 => Devlink::DpipeMatchValue({
3729 let res = Some(IterableDlDpipeMatchValue::with_loc(next, self.orig_loc));
3730 let Some(val) = res else { break };
3731 val
3732 }),
3733 42u16 => Devlink::DpipeMatchType({
3734 let res = parse_u32(next);
3735 let Some(val) = res else { break };
3736 val
3737 }),
3738 43u16 => Devlink::DpipeAction({
3739 let res = Some(IterableDlDpipeAction::with_loc(next, self.orig_loc));
3740 let Some(val) = res else { break };
3741 val
3742 }),
3743 44u16 => Devlink::DpipeActionValue({
3744 let res = Some(IterableDlDpipeActionValue::with_loc(next, self.orig_loc));
3745 let Some(val) = res else { break };
3746 val
3747 }),
3748 45u16 => Devlink::DpipeActionType({
3749 let res = parse_u32(next);
3750 let Some(val) = res else { break };
3751 val
3752 }),
3753 46u16 => Devlink::DpipeValue({
3754 let res = Some(next);
3755 let Some(val) = res else { break };
3756 val
3757 }),
3758 47u16 => Devlink::DpipeValueMask({
3759 let res = Some(next);
3760 let Some(val) = res else { break };
3761 val
3762 }),
3763 48u16 => Devlink::DpipeValueMapping({
3764 let res = parse_u32(next);
3765 let Some(val) = res else { break };
3766 val
3767 }),
3768 49u16 => Devlink::DpipeHeaders({
3769 let res = Some(IterableDlDpipeHeaders::with_loc(next, self.orig_loc));
3770 let Some(val) = res else { break };
3771 val
3772 }),
3773 50u16 => Devlink::DpipeHeader({
3774 let res = Some(IterableDlDpipeHeader::with_loc(next, self.orig_loc));
3775 let Some(val) = res else { break };
3776 val
3777 }),
3778 51u16 => Devlink::DpipeHeaderName({
3779 let res = CStr::from_bytes_with_nul(next).ok();
3780 let Some(val) = res else { break };
3781 val
3782 }),
3783 52u16 => Devlink::DpipeHeaderId({
3784 let res = parse_u32(next);
3785 let Some(val) = res else { break };
3786 val
3787 }),
3788 53u16 => Devlink::DpipeHeaderFields({
3789 let res = Some(IterableDlDpipeHeaderFields::with_loc(next, self.orig_loc));
3790 let Some(val) = res else { break };
3791 val
3792 }),
3793 54u16 => Devlink::DpipeHeaderGlobal({
3794 let res = parse_u8(next);
3795 let Some(val) = res else { break };
3796 val
3797 }),
3798 55u16 => Devlink::DpipeHeaderIndex({
3799 let res = parse_u32(next);
3800 let Some(val) = res else { break };
3801 val
3802 }),
3803 56u16 => Devlink::DpipeField({
3804 let res = Some(IterableDlDpipeField::with_loc(next, self.orig_loc));
3805 let Some(val) = res else { break };
3806 val
3807 }),
3808 57u16 => Devlink::DpipeFieldName({
3809 let res = CStr::from_bytes_with_nul(next).ok();
3810 let Some(val) = res else { break };
3811 val
3812 }),
3813 58u16 => Devlink::DpipeFieldId({
3814 let res = parse_u32(next);
3815 let Some(val) = res else { break };
3816 val
3817 }),
3818 59u16 => Devlink::DpipeFieldBitwidth({
3819 let res = parse_u32(next);
3820 let Some(val) = res else { break };
3821 val
3822 }),
3823 60u16 => Devlink::DpipeFieldMappingType({
3824 let res = parse_u32(next);
3825 let Some(val) = res else { break };
3826 val
3827 }),
3828 61u16 => Devlink::Pad({
3829 let res = Some(next);
3830 let Some(val) = res else { break };
3831 val
3832 }),
3833 62u16 => Devlink::EswitchEncapMode({
3834 let res = parse_u8(next);
3835 let Some(val) = res else { break };
3836 val
3837 }),
3838 63u16 => Devlink::ResourceList({
3839 let res = Some(IterableDlResourceList::with_loc(next, self.orig_loc));
3840 let Some(val) = res else { break };
3841 val
3842 }),
3843 64u16 => Devlink::Resource({
3844 let res = Some(IterableDlResource::with_loc(next, self.orig_loc));
3845 let Some(val) = res else { break };
3846 val
3847 }),
3848 65u16 => Devlink::ResourceName({
3849 let res = CStr::from_bytes_with_nul(next).ok();
3850 let Some(val) = res else { break };
3851 val
3852 }),
3853 66u16 => Devlink::ResourceId({
3854 let res = parse_u64(next);
3855 let Some(val) = res else { break };
3856 val
3857 }),
3858 67u16 => Devlink::ResourceSize({
3859 let res = parse_u64(next);
3860 let Some(val) = res else { break };
3861 val
3862 }),
3863 68u16 => Devlink::ResourceSizeNew({
3864 let res = parse_u64(next);
3865 let Some(val) = res else { break };
3866 val
3867 }),
3868 69u16 => Devlink::ResourceSizeValid({
3869 let res = parse_u8(next);
3870 let Some(val) = res else { break };
3871 val
3872 }),
3873 70u16 => Devlink::ResourceSizeMin({
3874 let res = parse_u64(next);
3875 let Some(val) = res else { break };
3876 val
3877 }),
3878 71u16 => Devlink::ResourceSizeMax({
3879 let res = parse_u64(next);
3880 let Some(val) = res else { break };
3881 val
3882 }),
3883 72u16 => Devlink::ResourceSizeGran({
3884 let res = parse_u64(next);
3885 let Some(val) = res else { break };
3886 val
3887 }),
3888 73u16 => Devlink::ResourceUnit({
3889 let res = parse_u8(next);
3890 let Some(val) = res else { break };
3891 val
3892 }),
3893 74u16 => Devlink::ResourceOcc({
3894 let res = parse_u64(next);
3895 let Some(val) = res else { break };
3896 val
3897 }),
3898 75u16 => Devlink::DpipeTableResourceId({
3899 let res = parse_u64(next);
3900 let Some(val) = res else { break };
3901 val
3902 }),
3903 76u16 => Devlink::DpipeTableResourceUnits({
3904 let res = parse_u64(next);
3905 let Some(val) = res else { break };
3906 val
3907 }),
3908 77u16 => Devlink::PortFlavour({
3909 let res = parse_u16(next);
3910 let Some(val) = res else { break };
3911 val
3912 }),
3913 78u16 => Devlink::PortNumber({
3914 let res = parse_u32(next);
3915 let Some(val) = res else { break };
3916 val
3917 }),
3918 79u16 => Devlink::PortSplitSubportNumber({
3919 let res = parse_u32(next);
3920 let Some(val) = res else { break };
3921 val
3922 }),
3923 80u16 => Devlink::Param({
3924 let res = Some(IterableDlParam::with_loc(next, self.orig_loc));
3925 let Some(val) = res else { break };
3926 val
3927 }),
3928 81u16 => Devlink::ParamName({
3929 let res = CStr::from_bytes_with_nul(next).ok();
3930 let Some(val) = res else { break };
3931 val
3932 }),
3933 82u16 => Devlink::ParamGeneric(()),
3934 83u16 => Devlink::ParamType({
3935 let res = parse_u8(next);
3936 let Some(val) = res else { break };
3937 val
3938 }),
3939 87u16 => Devlink::ParamValueCmode({
3940 let res = parse_u8(next);
3941 let Some(val) = res else { break };
3942 val
3943 }),
3944 88u16 => Devlink::RegionName({
3945 let res = CStr::from_bytes_with_nul(next).ok();
3946 let Some(val) = res else { break };
3947 val
3948 }),
3949 89u16 => Devlink::RegionSize({
3950 let res = parse_u64(next);
3951 let Some(val) = res else { break };
3952 val
3953 }),
3954 90u16 => Devlink::RegionSnapshots({
3955 let res = Some(IterableDlRegionSnapshots::with_loc(next, self.orig_loc));
3956 let Some(val) = res else { break };
3957 val
3958 }),
3959 91u16 => Devlink::RegionSnapshot({
3960 let res = Some(IterableDlRegionSnapshot::with_loc(next, self.orig_loc));
3961 let Some(val) = res else { break };
3962 val
3963 }),
3964 92u16 => Devlink::RegionSnapshotId({
3965 let res = parse_u32(next);
3966 let Some(val) = res else { break };
3967 val
3968 }),
3969 93u16 => Devlink::RegionChunks({
3970 let res = Some(IterableDlRegionChunks::with_loc(next, self.orig_loc));
3971 let Some(val) = res else { break };
3972 val
3973 }),
3974 94u16 => Devlink::RegionChunk({
3975 let res = Some(IterableDlRegionChunk::with_loc(next, self.orig_loc));
3976 let Some(val) = res else { break };
3977 val
3978 }),
3979 95u16 => Devlink::RegionChunkData({
3980 let res = Some(next);
3981 let Some(val) = res else { break };
3982 val
3983 }),
3984 96u16 => Devlink::RegionChunkAddr({
3985 let res = parse_u64(next);
3986 let Some(val) = res else { break };
3987 val
3988 }),
3989 97u16 => Devlink::RegionChunkLen({
3990 let res = parse_u64(next);
3991 let Some(val) = res else { break };
3992 val
3993 }),
3994 98u16 => Devlink::InfoDriverName({
3995 let res = CStr::from_bytes_with_nul(next).ok();
3996 let Some(val) = res else { break };
3997 val
3998 }),
3999 99u16 => Devlink::InfoSerialNumber({
4000 let res = CStr::from_bytes_with_nul(next).ok();
4001 let Some(val) = res else { break };
4002 val
4003 }),
4004 100u16 => Devlink::InfoVersionFixed({
4005 let res = Some(IterableDlInfoVersion::with_loc(next, self.orig_loc));
4006 let Some(val) = res else { break };
4007 val
4008 }),
4009 101u16 => Devlink::InfoVersionRunning({
4010 let res = Some(IterableDlInfoVersion::with_loc(next, self.orig_loc));
4011 let Some(val) = res else { break };
4012 val
4013 }),
4014 102u16 => Devlink::InfoVersionStored({
4015 let res = Some(IterableDlInfoVersion::with_loc(next, self.orig_loc));
4016 let Some(val) = res else { break };
4017 val
4018 }),
4019 103u16 => Devlink::InfoVersionName({
4020 let res = CStr::from_bytes_with_nul(next).ok();
4021 let Some(val) = res else { break };
4022 val
4023 }),
4024 104u16 => Devlink::InfoVersionValue({
4025 let res = CStr::from_bytes_with_nul(next).ok();
4026 let Some(val) = res else { break };
4027 val
4028 }),
4029 105u16 => Devlink::SbPoolCellSize({
4030 let res = parse_u32(next);
4031 let Some(val) = res else { break };
4032 val
4033 }),
4034 106u16 => Devlink::Fmsg({
4035 let res = Some(IterableDlFmsg::with_loc(next, self.orig_loc));
4036 let Some(val) = res else { break };
4037 val
4038 }),
4039 107u16 => Devlink::FmsgObjNestStart(()),
4040 108u16 => Devlink::FmsgPairNestStart(()),
4041 109u16 => Devlink::FmsgArrNestStart(()),
4042 110u16 => Devlink::FmsgNestEnd(()),
4043 111u16 => Devlink::FmsgObjName({
4044 let res = CStr::from_bytes_with_nul(next).ok();
4045 let Some(val) = res else { break };
4046 val
4047 }),
4048 112u16 => Devlink::FmsgObjValueType({
4049 let res = parse_u8(next);
4050 let Some(val) = res else { break };
4051 val
4052 }),
4053 114u16 => Devlink::HealthReporter({
4054 let res = Some(IterableDlHealthReporter::with_loc(next, self.orig_loc));
4055 let Some(val) = res else { break };
4056 val
4057 }),
4058 115u16 => Devlink::HealthReporterName({
4059 let res = CStr::from_bytes_with_nul(next).ok();
4060 let Some(val) = res else { break };
4061 val
4062 }),
4063 116u16 => Devlink::HealthReporterState({
4064 let res = parse_u8(next);
4065 let Some(val) = res else { break };
4066 val
4067 }),
4068 117u16 => Devlink::HealthReporterErrCount({
4069 let res = parse_u64(next);
4070 let Some(val) = res else { break };
4071 val
4072 }),
4073 118u16 => Devlink::HealthReporterRecoverCount({
4074 let res = parse_u64(next);
4075 let Some(val) = res else { break };
4076 val
4077 }),
4078 119u16 => Devlink::HealthReporterDumpTs({
4079 let res = parse_u64(next);
4080 let Some(val) = res else { break };
4081 val
4082 }),
4083 120u16 => Devlink::HealthReporterGracefulPeriod({
4084 let res = parse_u64(next);
4085 let Some(val) = res else { break };
4086 val
4087 }),
4088 121u16 => Devlink::HealthReporterAutoRecover({
4089 let res = parse_u8(next);
4090 let Some(val) = res else { break };
4091 val
4092 }),
4093 122u16 => Devlink::FlashUpdateFileName({
4094 let res = CStr::from_bytes_with_nul(next).ok();
4095 let Some(val) = res else { break };
4096 val
4097 }),
4098 123u16 => Devlink::FlashUpdateComponent({
4099 let res = CStr::from_bytes_with_nul(next).ok();
4100 let Some(val) = res else { break };
4101 val
4102 }),
4103 124u16 => Devlink::FlashUpdateStatusMsg({
4104 let res = CStr::from_bytes_with_nul(next).ok();
4105 let Some(val) = res else { break };
4106 val
4107 }),
4108 125u16 => Devlink::FlashUpdateStatusDone({
4109 let res = parse_u64(next);
4110 let Some(val) = res else { break };
4111 val
4112 }),
4113 126u16 => Devlink::FlashUpdateStatusTotal({
4114 let res = parse_u64(next);
4115 let Some(val) = res else { break };
4116 val
4117 }),
4118 127u16 => Devlink::PortPciPfNumber({
4119 let res = parse_u16(next);
4120 let Some(val) = res else { break };
4121 val
4122 }),
4123 128u16 => Devlink::PortPciVfNumber({
4124 let res = parse_u16(next);
4125 let Some(val) = res else { break };
4126 val
4127 }),
4128 129u16 => Devlink::Stats({
4129 let res = Some(IterableDlAttrStats::with_loc(next, self.orig_loc));
4130 let Some(val) = res else { break };
4131 val
4132 }),
4133 130u16 => Devlink::TrapName({
4134 let res = CStr::from_bytes_with_nul(next).ok();
4135 let Some(val) = res else { break };
4136 val
4137 }),
4138 131u16 => Devlink::TrapAction({
4139 let res = parse_u8(next);
4140 let Some(val) = res else { break };
4141 val
4142 }),
4143 132u16 => Devlink::TrapType({
4144 let res = parse_u8(next);
4145 let Some(val) = res else { break };
4146 val
4147 }),
4148 133u16 => Devlink::TrapGeneric(()),
4149 134u16 => Devlink::TrapMetadata({
4150 let res = Some(IterableDlTrapMetadata::with_loc(next, self.orig_loc));
4151 let Some(val) = res else { break };
4152 val
4153 }),
4154 135u16 => Devlink::TrapGroupName({
4155 let res = CStr::from_bytes_with_nul(next).ok();
4156 let Some(val) = res else { break };
4157 val
4158 }),
4159 136u16 => Devlink::ReloadFailed({
4160 let res = parse_u8(next);
4161 let Some(val) = res else { break };
4162 val
4163 }),
4164 137u16 => Devlink::HealthReporterDumpTsNs({
4165 let res = parse_u64(next);
4166 let Some(val) = res else { break };
4167 val
4168 }),
4169 138u16 => Devlink::NetnsFd({
4170 let res = parse_u32(next);
4171 let Some(val) = res else { break };
4172 val
4173 }),
4174 139u16 => Devlink::NetnsPid({
4175 let res = parse_u32(next);
4176 let Some(val) = res else { break };
4177 val
4178 }),
4179 140u16 => Devlink::NetnsId({
4180 let res = parse_u32(next);
4181 let Some(val) = res else { break };
4182 val
4183 }),
4184 141u16 => Devlink::HealthReporterAutoDump({
4185 let res = parse_u8(next);
4186 let Some(val) = res else { break };
4187 val
4188 }),
4189 142u16 => Devlink::TrapPolicerId({
4190 let res = parse_u32(next);
4191 let Some(val) = res else { break };
4192 val
4193 }),
4194 143u16 => Devlink::TrapPolicerRate({
4195 let res = parse_u64(next);
4196 let Some(val) = res else { break };
4197 val
4198 }),
4199 144u16 => Devlink::TrapPolicerBurst({
4200 let res = parse_u64(next);
4201 let Some(val) = res else { break };
4202 val
4203 }),
4204 145u16 => Devlink::PortFunction({
4205 let res = Some(IterableDlPortFunction::with_loc(next, self.orig_loc));
4206 let Some(val) = res else { break };
4207 val
4208 }),
4209 146u16 => Devlink::InfoBoardSerialNumber({
4210 let res = CStr::from_bytes_with_nul(next).ok();
4211 let Some(val) = res else { break };
4212 val
4213 }),
4214 147u16 => Devlink::PortLanes({
4215 let res = parse_u32(next);
4216 let Some(val) = res else { break };
4217 val
4218 }),
4219 148u16 => Devlink::PortSplittable({
4220 let res = parse_u8(next);
4221 let Some(val) = res else { break };
4222 val
4223 }),
4224 149u16 => Devlink::PortExternal({
4225 let res = parse_u8(next);
4226 let Some(val) = res else { break };
4227 val
4228 }),
4229 150u16 => Devlink::PortControllerNumber({
4230 let res = parse_u32(next);
4231 let Some(val) = res else { break };
4232 val
4233 }),
4234 151u16 => Devlink::FlashUpdateStatusTimeout({
4235 let res = parse_u64(next);
4236 let Some(val) = res else { break };
4237 val
4238 }),
4239 152u16 => Devlink::FlashUpdateOverwriteMask({
4240 let res = BuiltinBitfield32::new_from_slice(next);
4241 let Some(val) = res else { break };
4242 val
4243 }),
4244 153u16 => Devlink::ReloadAction({
4245 let res = parse_u8(next);
4246 let Some(val) = res else { break };
4247 val
4248 }),
4249 154u16 => Devlink::ReloadActionsPerformed({
4250 let res = BuiltinBitfield32::new_from_slice(next);
4251 let Some(val) = res else { break };
4252 val
4253 }),
4254 155u16 => Devlink::ReloadLimits({
4255 let res = BuiltinBitfield32::new_from_slice(next);
4256 let Some(val) = res else { break };
4257 val
4258 }),
4259 156u16 => Devlink::DevStats({
4260 let res = Some(IterableDlDevStats::with_loc(next, self.orig_loc));
4261 let Some(val) = res else { break };
4262 val
4263 }),
4264 157u16 => Devlink::ReloadStats({
4265 let res = Some(IterableDlReloadStats::with_loc(next, self.orig_loc));
4266 let Some(val) = res else { break };
4267 val
4268 }),
4269 158u16 => Devlink::ReloadStatsEntry({
4270 let res = Some(IterableDlReloadStatsEntry::with_loc(next, self.orig_loc));
4271 let Some(val) = res else { break };
4272 val
4273 }),
4274 159u16 => Devlink::ReloadStatsLimit({
4275 let res = parse_u8(next);
4276 let Some(val) = res else { break };
4277 val
4278 }),
4279 160u16 => Devlink::ReloadStatsValue({
4280 let res = parse_u32(next);
4281 let Some(val) = res else { break };
4282 val
4283 }),
4284 161u16 => Devlink::RemoteReloadStats({
4285 let res = Some(IterableDlReloadStats::with_loc(next, self.orig_loc));
4286 let Some(val) = res else { break };
4287 val
4288 }),
4289 162u16 => Devlink::ReloadActionInfo({
4290 let res = Some(IterableDlReloadActInfo::with_loc(next, self.orig_loc));
4291 let Some(val) = res else { break };
4292 val
4293 }),
4294 163u16 => Devlink::ReloadActionStats({
4295 let res = Some(IterableDlReloadActStats::with_loc(next, self.orig_loc));
4296 let Some(val) = res else { break };
4297 val
4298 }),
4299 164u16 => Devlink::PortPciSfNumber({
4300 let res = parse_u32(next);
4301 let Some(val) = res else { break };
4302 val
4303 }),
4304 165u16 => Devlink::RateType({
4305 let res = parse_u16(next);
4306 let Some(val) = res else { break };
4307 val
4308 }),
4309 166u16 => Devlink::RateTxShare({
4310 let res = parse_u64(next);
4311 let Some(val) = res else { break };
4312 val
4313 }),
4314 167u16 => Devlink::RateTxMax({
4315 let res = parse_u64(next);
4316 let Some(val) = res else { break };
4317 val
4318 }),
4319 168u16 => Devlink::RateNodeName({
4320 let res = CStr::from_bytes_with_nul(next).ok();
4321 let Some(val) = res else { break };
4322 val
4323 }),
4324 169u16 => Devlink::RateParentNodeName({
4325 let res = CStr::from_bytes_with_nul(next).ok();
4326 let Some(val) = res else { break };
4327 val
4328 }),
4329 170u16 => Devlink::RegionMaxSnapshots({
4330 let res = parse_u32(next);
4331 let Some(val) = res else { break };
4332 val
4333 }),
4334 171u16 => Devlink::LinecardIndex({
4335 let res = parse_u32(next);
4336 let Some(val) = res else { break };
4337 val
4338 }),
4339 172u16 => Devlink::LinecardState({
4340 let res = parse_u8(next);
4341 let Some(val) = res else { break };
4342 val
4343 }),
4344 173u16 => Devlink::LinecardType({
4345 let res = CStr::from_bytes_with_nul(next).ok();
4346 let Some(val) = res else { break };
4347 val
4348 }),
4349 174u16 => Devlink::LinecardSupportedTypes({
4350 let res = Some(IterableDlLinecardSupportedTypes::with_loc(
4351 next,
4352 self.orig_loc,
4353 ));
4354 let Some(val) = res else { break };
4355 val
4356 }),
4357 176u16 => Devlink::Selftests({
4358 let res = Some(IterableDlSelftestId::with_loc(next, self.orig_loc));
4359 let Some(val) = res else { break };
4360 val
4361 }),
4362 177u16 => Devlink::RateTxPriority({
4363 let res = parse_u32(next);
4364 let Some(val) = res else { break };
4365 val
4366 }),
4367 178u16 => Devlink::RateTxWeight({
4368 let res = parse_u32(next);
4369 let Some(val) = res else { break };
4370 val
4371 }),
4372 179u16 => Devlink::RegionDirect(()),
4373 180u16 => Devlink::RateTcBws({
4374 let res = Some(IterableDlRateTcBws::with_loc(next, self.orig_loc));
4375 let Some(val) = res else { break };
4376 val
4377 }),
4378 181u16 => Devlink::HealthReporterBurstPeriod({
4379 let res = parse_u64(next);
4380 let Some(val) = res else { break };
4381 val
4382 }),
4383 183u16 => Devlink::ParamResetDefault(()),
4384 184u16 => Devlink::Index({
4385 let res = parse_u32(next);
4386 let Some(val) = res else { break };
4387 val
4388 }),
4389 185u16 => Devlink::ResourceScopeMask({
4390 let res = parse_u32(next);
4391 let Some(val) = res else { break };
4392 val
4393 }),
4394 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
4395 n => continue,
4396 };
4397 return Some(Ok(res));
4398 }
4399 Some(Err(ErrorContext::new(
4400 "Devlink",
4401 r#type.and_then(|t| Devlink::attr_from_type(t)),
4402 self.orig_loc,
4403 self.buf.as_ptr().wrapping_add(pos) as usize,
4404 )))
4405 }
4406}
4407impl<'a> std::fmt::Debug for IterableDevlink<'_> {
4408 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4409 let mut fmt = f.debug_struct("Devlink");
4410 for attr in self.clone() {
4411 let attr = match attr {
4412 Ok(a) => a,
4413 Err(err) => {
4414 fmt.finish()?;
4415 f.write_str("Err(")?;
4416 err.fmt(f)?;
4417 return f.write_str(")");
4418 }
4419 };
4420 match attr {
4421 Devlink::BusName(val) => fmt.field("BusName", &val),
4422 Devlink::DevName(val) => fmt.field("DevName", &val),
4423 Devlink::PortIndex(val) => fmt.field("PortIndex", &val),
4424 Devlink::PortType(val) => {
4425 fmt.field("PortType", &FormatEnum(val.into(), PortType::from_value))
4426 }
4427 Devlink::PortDesiredType(val) => fmt.field("PortDesiredType", &val),
4428 Devlink::PortNetdevIfindex(val) => fmt.field("PortNetdevIfindex", &val),
4429 Devlink::PortNetdevName(val) => fmt.field("PortNetdevName", &val),
4430 Devlink::PortIbdevName(val) => fmt.field("PortIbdevName", &val),
4431 Devlink::PortSplitCount(val) => fmt.field("PortSplitCount", &val),
4432 Devlink::PortSplitGroup(val) => fmt.field("PortSplitGroup", &val),
4433 Devlink::SbIndex(val) => fmt.field("SbIndex", &val),
4434 Devlink::SbSize(val) => fmt.field("SbSize", &val),
4435 Devlink::SbIngressPoolCount(val) => fmt.field("SbIngressPoolCount", &val),
4436 Devlink::SbEgressPoolCount(val) => fmt.field("SbEgressPoolCount", &val),
4437 Devlink::SbIngressTcCount(val) => fmt.field("SbIngressTcCount", &val),
4438 Devlink::SbEgressTcCount(val) => fmt.field("SbEgressTcCount", &val),
4439 Devlink::SbPoolIndex(val) => fmt.field("SbPoolIndex", &val),
4440 Devlink::SbPoolType(val) => fmt.field(
4441 "SbPoolType",
4442 &FormatEnum(val.into(), SbPoolType::from_value),
4443 ),
4444 Devlink::SbPoolSize(val) => fmt.field("SbPoolSize", &val),
4445 Devlink::SbPoolThresholdType(val) => fmt.field(
4446 "SbPoolThresholdType",
4447 &FormatEnum(val.into(), SbThresholdType::from_value),
4448 ),
4449 Devlink::SbThreshold(val) => fmt.field("SbThreshold", &val),
4450 Devlink::SbTcIndex(val) => fmt.field("SbTcIndex", &val),
4451 Devlink::SbOccCur(val) => fmt.field("SbOccCur", &val),
4452 Devlink::SbOccMax(val) => fmt.field("SbOccMax", &val),
4453 Devlink::EswitchMode(val) => fmt.field(
4454 "EswitchMode",
4455 &FormatEnum(val.into(), EswitchMode::from_value),
4456 ),
4457 Devlink::EswitchInlineMode(val) => fmt.field(
4458 "EswitchInlineMode",
4459 &FormatEnum(val.into(), EswitchInlineMode::from_value),
4460 ),
4461 Devlink::DpipeTables(val) => fmt.field("DpipeTables", &val),
4462 Devlink::DpipeTable(val) => fmt.field("DpipeTable", &val),
4463 Devlink::DpipeTableName(val) => fmt.field("DpipeTableName", &val),
4464 Devlink::DpipeTableSize(val) => fmt.field("DpipeTableSize", &val),
4465 Devlink::DpipeTableMatches(val) => fmt.field("DpipeTableMatches", &val),
4466 Devlink::DpipeTableActions(val) => fmt.field("DpipeTableActions", &val),
4467 Devlink::DpipeTableCountersEnabled(val) => {
4468 fmt.field("DpipeTableCountersEnabled", &val)
4469 }
4470 Devlink::DpipeEntries(val) => fmt.field("DpipeEntries", &val),
4471 Devlink::DpipeEntry(val) => fmt.field("DpipeEntry", &val),
4472 Devlink::DpipeEntryIndex(val) => fmt.field("DpipeEntryIndex", &val),
4473 Devlink::DpipeEntryMatchValues(val) => fmt.field("DpipeEntryMatchValues", &val),
4474 Devlink::DpipeEntryActionValues(val) => fmt.field("DpipeEntryActionValues", &val),
4475 Devlink::DpipeEntryCounter(val) => fmt.field("DpipeEntryCounter", &val),
4476 Devlink::DpipeMatch(val) => fmt.field("DpipeMatch", &val),
4477 Devlink::DpipeMatchValue(val) => fmt.field("DpipeMatchValue", &val),
4478 Devlink::DpipeMatchType(val) => fmt.field(
4479 "DpipeMatchType",
4480 &FormatEnum(val.into(), DpipeMatchType::from_value),
4481 ),
4482 Devlink::DpipeAction(val) => fmt.field("DpipeAction", &val),
4483 Devlink::DpipeActionValue(val) => fmt.field("DpipeActionValue", &val),
4484 Devlink::DpipeActionType(val) => fmt.field(
4485 "DpipeActionType",
4486 &FormatEnum(val.into(), DpipeActionType::from_value),
4487 ),
4488 Devlink::DpipeValue(val) => fmt.field("DpipeValue", &val),
4489 Devlink::DpipeValueMask(val) => fmt.field("DpipeValueMask", &val),
4490 Devlink::DpipeValueMapping(val) => fmt.field("DpipeValueMapping", &val),
4491 Devlink::DpipeHeaders(val) => fmt.field("DpipeHeaders", &val),
4492 Devlink::DpipeHeader(val) => fmt.field("DpipeHeader", &val),
4493 Devlink::DpipeHeaderName(val) => fmt.field("DpipeHeaderName", &val),
4494 Devlink::DpipeHeaderId(val) => fmt.field(
4495 "DpipeHeaderId",
4496 &FormatEnum(val.into(), DpipeHeaderId::from_value),
4497 ),
4498 Devlink::DpipeHeaderFields(val) => fmt.field("DpipeHeaderFields", &val),
4499 Devlink::DpipeHeaderGlobal(val) => fmt.field("DpipeHeaderGlobal", &val),
4500 Devlink::DpipeHeaderIndex(val) => fmt.field("DpipeHeaderIndex", &val),
4501 Devlink::DpipeField(val) => fmt.field("DpipeField", &val),
4502 Devlink::DpipeFieldName(val) => fmt.field("DpipeFieldName", &val),
4503 Devlink::DpipeFieldId(val) => fmt.field("DpipeFieldId", &val),
4504 Devlink::DpipeFieldBitwidth(val) => fmt.field("DpipeFieldBitwidth", &val),
4505 Devlink::DpipeFieldMappingType(val) => fmt.field(
4506 "DpipeFieldMappingType",
4507 &FormatEnum(val.into(), DpipeFieldMappingType::from_value),
4508 ),
4509 Devlink::Pad(val) => fmt.field("Pad", &val),
4510 Devlink::EswitchEncapMode(val) => fmt.field(
4511 "EswitchEncapMode",
4512 &FormatEnum(val.into(), EswitchEncapMode::from_value),
4513 ),
4514 Devlink::ResourceList(val) => fmt.field("ResourceList", &val),
4515 Devlink::Resource(val) => fmt.field("Resource", &val),
4516 Devlink::ResourceName(val) => fmt.field("ResourceName", &val),
4517 Devlink::ResourceId(val) => fmt.field("ResourceId", &val),
4518 Devlink::ResourceSize(val) => fmt.field("ResourceSize", &val),
4519 Devlink::ResourceSizeNew(val) => fmt.field("ResourceSizeNew", &val),
4520 Devlink::ResourceSizeValid(val) => fmt.field("ResourceSizeValid", &val),
4521 Devlink::ResourceSizeMin(val) => fmt.field("ResourceSizeMin", &val),
4522 Devlink::ResourceSizeMax(val) => fmt.field("ResourceSizeMax", &val),
4523 Devlink::ResourceSizeGran(val) => fmt.field("ResourceSizeGran", &val),
4524 Devlink::ResourceUnit(val) => fmt.field(
4525 "ResourceUnit",
4526 &FormatEnum(val.into(), ResourceUnit::from_value),
4527 ),
4528 Devlink::ResourceOcc(val) => fmt.field("ResourceOcc", &val),
4529 Devlink::DpipeTableResourceId(val) => fmt.field("DpipeTableResourceId", &val),
4530 Devlink::DpipeTableResourceUnits(val) => fmt.field("DpipeTableResourceUnits", &val),
4531 Devlink::PortFlavour(val) => fmt.field(
4532 "PortFlavour",
4533 &FormatEnum(val.into(), PortFlavour::from_value),
4534 ),
4535 Devlink::PortNumber(val) => fmt.field("PortNumber", &val),
4536 Devlink::PortSplitSubportNumber(val) => fmt.field("PortSplitSubportNumber", &val),
4537 Devlink::Param(val) => fmt.field("Param", &val),
4538 Devlink::ParamName(val) => fmt.field("ParamName", &val),
4539 Devlink::ParamGeneric(val) => fmt.field("ParamGeneric", &val),
4540 Devlink::ParamType(val) => fmt.field(
4541 "ParamType",
4542 &FormatEnum(val.into(), VarAttrType::from_value),
4543 ),
4544 Devlink::ParamValueCmode(val) => fmt.field(
4545 "ParamValueCmode",
4546 &FormatEnum(val.into(), ParamCmode::from_value),
4547 ),
4548 Devlink::RegionName(val) => fmt.field("RegionName", &val),
4549 Devlink::RegionSize(val) => fmt.field("RegionSize", &val),
4550 Devlink::RegionSnapshots(val) => fmt.field("RegionSnapshots", &val),
4551 Devlink::RegionSnapshot(val) => fmt.field("RegionSnapshot", &val),
4552 Devlink::RegionSnapshotId(val) => fmt.field("RegionSnapshotId", &val),
4553 Devlink::RegionChunks(val) => fmt.field("RegionChunks", &val),
4554 Devlink::RegionChunk(val) => fmt.field("RegionChunk", &val),
4555 Devlink::RegionChunkData(val) => fmt.field("RegionChunkData", &val),
4556 Devlink::RegionChunkAddr(val) => fmt.field("RegionChunkAddr", &val),
4557 Devlink::RegionChunkLen(val) => fmt.field("RegionChunkLen", &val),
4558 Devlink::InfoDriverName(val) => fmt.field("InfoDriverName", &val),
4559 Devlink::InfoSerialNumber(val) => fmt.field("InfoSerialNumber", &val),
4560 Devlink::InfoVersionFixed(val) => fmt.field("InfoVersionFixed", &val),
4561 Devlink::InfoVersionRunning(val) => fmt.field("InfoVersionRunning", &val),
4562 Devlink::InfoVersionStored(val) => fmt.field("InfoVersionStored", &val),
4563 Devlink::InfoVersionName(val) => fmt.field("InfoVersionName", &val),
4564 Devlink::InfoVersionValue(val) => fmt.field("InfoVersionValue", &val),
4565 Devlink::SbPoolCellSize(val) => fmt.field("SbPoolCellSize", &val),
4566 Devlink::Fmsg(val) => fmt.field("Fmsg", &val),
4567 Devlink::FmsgObjNestStart(val) => fmt.field("FmsgObjNestStart", &val),
4568 Devlink::FmsgPairNestStart(val) => fmt.field("FmsgPairNestStart", &val),
4569 Devlink::FmsgArrNestStart(val) => fmt.field("FmsgArrNestStart", &val),
4570 Devlink::FmsgNestEnd(val) => fmt.field("FmsgNestEnd", &val),
4571 Devlink::FmsgObjName(val) => fmt.field("FmsgObjName", &val),
4572 Devlink::FmsgObjValueType(val) => fmt.field(
4573 "FmsgObjValueType",
4574 &FormatEnum(val.into(), VarAttrType::from_value),
4575 ),
4576 Devlink::HealthReporter(val) => fmt.field("HealthReporter", &val),
4577 Devlink::HealthReporterName(val) => fmt.field("HealthReporterName", &val),
4578 Devlink::HealthReporterState(val) => fmt.field("HealthReporterState", &val),
4579 Devlink::HealthReporterErrCount(val) => fmt.field("HealthReporterErrCount", &val),
4580 Devlink::HealthReporterRecoverCount(val) => {
4581 fmt.field("HealthReporterRecoverCount", &val)
4582 }
4583 Devlink::HealthReporterDumpTs(val) => fmt.field("HealthReporterDumpTs", &val),
4584 Devlink::HealthReporterGracefulPeriod(val) => {
4585 fmt.field("HealthReporterGracefulPeriod", &val)
4586 }
4587 Devlink::HealthReporterAutoRecover(val) => {
4588 fmt.field("HealthReporterAutoRecover", &val)
4589 }
4590 Devlink::FlashUpdateFileName(val) => fmt.field("FlashUpdateFileName", &val),
4591 Devlink::FlashUpdateComponent(val) => fmt.field("FlashUpdateComponent", &val),
4592 Devlink::FlashUpdateStatusMsg(val) => fmt.field("FlashUpdateStatusMsg", &val),
4593 Devlink::FlashUpdateStatusDone(val) => fmt.field("FlashUpdateStatusDone", &val),
4594 Devlink::FlashUpdateStatusTotal(val) => fmt.field("FlashUpdateStatusTotal", &val),
4595 Devlink::PortPciPfNumber(val) => fmt.field("PortPciPfNumber", &val),
4596 Devlink::PortPciVfNumber(val) => fmt.field("PortPciVfNumber", &val),
4597 Devlink::Stats(val) => fmt.field("Stats", &val),
4598 Devlink::TrapName(val) => fmt.field("TrapName", &val),
4599 Devlink::TrapAction(val) => fmt.field(
4600 "TrapAction",
4601 &FormatEnum(val.into(), TrapAction::from_value),
4602 ),
4603 Devlink::TrapType(val) => {
4604 fmt.field("TrapType", &FormatEnum(val.into(), TrapType::from_value))
4605 }
4606 Devlink::TrapGeneric(val) => fmt.field("TrapGeneric", &val),
4607 Devlink::TrapMetadata(val) => fmt.field("TrapMetadata", &val),
4608 Devlink::TrapGroupName(val) => fmt.field("TrapGroupName", &val),
4609 Devlink::ReloadFailed(val) => fmt.field("ReloadFailed", &val),
4610 Devlink::HealthReporterDumpTsNs(val) => fmt.field("HealthReporterDumpTsNs", &val),
4611 Devlink::NetnsFd(val) => fmt.field("NetnsFd", &val),
4612 Devlink::NetnsPid(val) => fmt.field("NetnsPid", &val),
4613 Devlink::NetnsId(val) => fmt.field("NetnsId", &val),
4614 Devlink::HealthReporterAutoDump(val) => fmt.field("HealthReporterAutoDump", &val),
4615 Devlink::TrapPolicerId(val) => fmt.field("TrapPolicerId", &val),
4616 Devlink::TrapPolicerRate(val) => fmt.field("TrapPolicerRate", &val),
4617 Devlink::TrapPolicerBurst(val) => fmt.field("TrapPolicerBurst", &val),
4618 Devlink::PortFunction(val) => fmt.field("PortFunction", &val),
4619 Devlink::InfoBoardSerialNumber(val) => fmt.field("InfoBoardSerialNumber", &val),
4620 Devlink::PortLanes(val) => fmt.field("PortLanes", &val),
4621 Devlink::PortSplittable(val) => fmt.field("PortSplittable", &val),
4622 Devlink::PortExternal(val) => fmt.field("PortExternal", &val),
4623 Devlink::PortControllerNumber(val) => fmt.field("PortControllerNumber", &val),
4624 Devlink::FlashUpdateStatusTimeout(val) => {
4625 fmt.field("FlashUpdateStatusTimeout", &val)
4626 }
4627 Devlink::FlashUpdateOverwriteMask(val) => fmt.field(
4628 "FlashUpdateOverwriteMask",
4629 &FormatFlags(val.value.into(), |val| {
4630 FlashOverwrite::from_value(val.trailing_zeros().into())
4631 }),
4632 ),
4633 Devlink::ReloadAction(val) => fmt.field(
4634 "ReloadAction",
4635 &FormatEnum(val.into(), ReloadAction::from_value),
4636 ),
4637 Devlink::ReloadActionsPerformed(val) => fmt.field(
4638 "ReloadActionsPerformed",
4639 &FormatFlags(val.value.into(), |val| {
4640 ReloadAction::from_value(val.trailing_zeros().into())
4641 }),
4642 ),
4643 Devlink::ReloadLimits(val) => fmt.field(
4644 "ReloadLimits",
4645 &FormatFlags(val.value.into(), |val| {
4646 ReloadAction::from_value(val.trailing_zeros().into())
4647 }),
4648 ),
4649 Devlink::DevStats(val) => fmt.field("DevStats", &val),
4650 Devlink::ReloadStats(val) => fmt.field("ReloadStats", &val),
4651 Devlink::ReloadStatsEntry(val) => fmt.field("ReloadStatsEntry", &val),
4652 Devlink::ReloadStatsLimit(val) => fmt.field("ReloadStatsLimit", &val),
4653 Devlink::ReloadStatsValue(val) => fmt.field("ReloadStatsValue", &val),
4654 Devlink::RemoteReloadStats(val) => fmt.field("RemoteReloadStats", &val),
4655 Devlink::ReloadActionInfo(val) => fmt.field("ReloadActionInfo", &val),
4656 Devlink::ReloadActionStats(val) => fmt.field("ReloadActionStats", &val),
4657 Devlink::PortPciSfNumber(val) => fmt.field("PortPciSfNumber", &val),
4658 Devlink::RateType(val) => {
4659 fmt.field("RateType", &FormatEnum(val.into(), RateType::from_value))
4660 }
4661 Devlink::RateTxShare(val) => fmt.field("RateTxShare", &val),
4662 Devlink::RateTxMax(val) => fmt.field("RateTxMax", &val),
4663 Devlink::RateNodeName(val) => fmt.field("RateNodeName", &val),
4664 Devlink::RateParentNodeName(val) => fmt.field("RateParentNodeName", &val),
4665 Devlink::RegionMaxSnapshots(val) => fmt.field("RegionMaxSnapshots", &val),
4666 Devlink::LinecardIndex(val) => fmt.field("LinecardIndex", &val),
4667 Devlink::LinecardState(val) => fmt.field("LinecardState", &val),
4668 Devlink::LinecardType(val) => fmt.field("LinecardType", &val),
4669 Devlink::LinecardSupportedTypes(val) => fmt.field("LinecardSupportedTypes", &val),
4670 Devlink::Selftests(val) => fmt.field("Selftests", &val),
4671 Devlink::RateTxPriority(val) => fmt.field("RateTxPriority", &val),
4672 Devlink::RateTxWeight(val) => fmt.field("RateTxWeight", &val),
4673 Devlink::RegionDirect(val) => fmt.field("RegionDirect", &val),
4674 Devlink::RateTcBws(val) => fmt.field("RateTcBws", &val),
4675 Devlink::HealthReporterBurstPeriod(val) => {
4676 fmt.field("HealthReporterBurstPeriod", &val)
4677 }
4678 Devlink::ParamResetDefault(val) => fmt.field("ParamResetDefault", &val),
4679 Devlink::Index(val) => fmt.field("Index", &val),
4680 Devlink::ResourceScopeMask(val) => fmt.field(
4681 "ResourceScopeMask",
4682 &FormatFlags(val.into(), |val| {
4683 ResourceScope::from_value(val.trailing_zeros().into())
4684 }),
4685 ),
4686 };
4687 }
4688 fmt.finish()
4689 }
4690}
4691impl IterableDevlink<'_> {
4692 pub fn lookup_attr(
4693 &self,
4694 offset: usize,
4695 missing_type: Option<u16>,
4696 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
4697 let mut stack = Vec::new();
4698 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
4699 if missing_type.is_some() && cur == offset {
4700 stack.push(("Devlink", offset));
4701 return (stack, missing_type.and_then(|t| Devlink::attr_from_type(t)));
4702 }
4703 if cur > offset || cur + self.buf.len() < offset {
4704 return (stack, None);
4705 }
4706 let mut attrs = self.clone();
4707 let mut last_off = cur + attrs.pos;
4708 let mut missing = None;
4709 while let Some(attr) = attrs.next() {
4710 let Ok(attr) = attr else { break };
4711 match attr {
4712 Devlink::BusName(val) => {
4713 if last_off == offset {
4714 stack.push(("BusName", last_off));
4715 break;
4716 }
4717 }
4718 Devlink::DevName(val) => {
4719 if last_off == offset {
4720 stack.push(("DevName", last_off));
4721 break;
4722 }
4723 }
4724 Devlink::PortIndex(val) => {
4725 if last_off == offset {
4726 stack.push(("PortIndex", last_off));
4727 break;
4728 }
4729 }
4730 Devlink::PortType(val) => {
4731 if last_off == offset {
4732 stack.push(("PortType", last_off));
4733 break;
4734 }
4735 }
4736 Devlink::PortDesiredType(val) => {
4737 if last_off == offset {
4738 stack.push(("PortDesiredType", last_off));
4739 break;
4740 }
4741 }
4742 Devlink::PortNetdevIfindex(val) => {
4743 if last_off == offset {
4744 stack.push(("PortNetdevIfindex", last_off));
4745 break;
4746 }
4747 }
4748 Devlink::PortNetdevName(val) => {
4749 if last_off == offset {
4750 stack.push(("PortNetdevName", last_off));
4751 break;
4752 }
4753 }
4754 Devlink::PortIbdevName(val) => {
4755 if last_off == offset {
4756 stack.push(("PortIbdevName", last_off));
4757 break;
4758 }
4759 }
4760 Devlink::PortSplitCount(val) => {
4761 if last_off == offset {
4762 stack.push(("PortSplitCount", last_off));
4763 break;
4764 }
4765 }
4766 Devlink::PortSplitGroup(val) => {
4767 if last_off == offset {
4768 stack.push(("PortSplitGroup", last_off));
4769 break;
4770 }
4771 }
4772 Devlink::SbIndex(val) => {
4773 if last_off == offset {
4774 stack.push(("SbIndex", last_off));
4775 break;
4776 }
4777 }
4778 Devlink::SbSize(val) => {
4779 if last_off == offset {
4780 stack.push(("SbSize", last_off));
4781 break;
4782 }
4783 }
4784 Devlink::SbIngressPoolCount(val) => {
4785 if last_off == offset {
4786 stack.push(("SbIngressPoolCount", last_off));
4787 break;
4788 }
4789 }
4790 Devlink::SbEgressPoolCount(val) => {
4791 if last_off == offset {
4792 stack.push(("SbEgressPoolCount", last_off));
4793 break;
4794 }
4795 }
4796 Devlink::SbIngressTcCount(val) => {
4797 if last_off == offset {
4798 stack.push(("SbIngressTcCount", last_off));
4799 break;
4800 }
4801 }
4802 Devlink::SbEgressTcCount(val) => {
4803 if last_off == offset {
4804 stack.push(("SbEgressTcCount", last_off));
4805 break;
4806 }
4807 }
4808 Devlink::SbPoolIndex(val) => {
4809 if last_off == offset {
4810 stack.push(("SbPoolIndex", last_off));
4811 break;
4812 }
4813 }
4814 Devlink::SbPoolType(val) => {
4815 if last_off == offset {
4816 stack.push(("SbPoolType", last_off));
4817 break;
4818 }
4819 }
4820 Devlink::SbPoolSize(val) => {
4821 if last_off == offset {
4822 stack.push(("SbPoolSize", last_off));
4823 break;
4824 }
4825 }
4826 Devlink::SbPoolThresholdType(val) => {
4827 if last_off == offset {
4828 stack.push(("SbPoolThresholdType", last_off));
4829 break;
4830 }
4831 }
4832 Devlink::SbThreshold(val) => {
4833 if last_off == offset {
4834 stack.push(("SbThreshold", last_off));
4835 break;
4836 }
4837 }
4838 Devlink::SbTcIndex(val) => {
4839 if last_off == offset {
4840 stack.push(("SbTcIndex", last_off));
4841 break;
4842 }
4843 }
4844 Devlink::SbOccCur(val) => {
4845 if last_off == offset {
4846 stack.push(("SbOccCur", last_off));
4847 break;
4848 }
4849 }
4850 Devlink::SbOccMax(val) => {
4851 if last_off == offset {
4852 stack.push(("SbOccMax", last_off));
4853 break;
4854 }
4855 }
4856 Devlink::EswitchMode(val) => {
4857 if last_off == offset {
4858 stack.push(("EswitchMode", last_off));
4859 break;
4860 }
4861 }
4862 Devlink::EswitchInlineMode(val) => {
4863 if last_off == offset {
4864 stack.push(("EswitchInlineMode", last_off));
4865 break;
4866 }
4867 }
4868 Devlink::DpipeTables(val) => {
4869 (stack, missing) = val.lookup_attr(offset, missing_type);
4870 if !stack.is_empty() {
4871 break;
4872 }
4873 }
4874 Devlink::DpipeTable(val) => {
4875 (stack, missing) = val.lookup_attr(offset, missing_type);
4876 if !stack.is_empty() {
4877 break;
4878 }
4879 }
4880 Devlink::DpipeTableName(val) => {
4881 if last_off == offset {
4882 stack.push(("DpipeTableName", last_off));
4883 break;
4884 }
4885 }
4886 Devlink::DpipeTableSize(val) => {
4887 if last_off == offset {
4888 stack.push(("DpipeTableSize", last_off));
4889 break;
4890 }
4891 }
4892 Devlink::DpipeTableMatches(val) => {
4893 (stack, missing) = val.lookup_attr(offset, missing_type);
4894 if !stack.is_empty() {
4895 break;
4896 }
4897 }
4898 Devlink::DpipeTableActions(val) => {
4899 (stack, missing) = val.lookup_attr(offset, missing_type);
4900 if !stack.is_empty() {
4901 break;
4902 }
4903 }
4904 Devlink::DpipeTableCountersEnabled(val) => {
4905 if last_off == offset {
4906 stack.push(("DpipeTableCountersEnabled", last_off));
4907 break;
4908 }
4909 }
4910 Devlink::DpipeEntries(val) => {
4911 (stack, missing) = val.lookup_attr(offset, missing_type);
4912 if !stack.is_empty() {
4913 break;
4914 }
4915 }
4916 Devlink::DpipeEntry(val) => {
4917 (stack, missing) = val.lookup_attr(offset, missing_type);
4918 if !stack.is_empty() {
4919 break;
4920 }
4921 }
4922 Devlink::DpipeEntryIndex(val) => {
4923 if last_off == offset {
4924 stack.push(("DpipeEntryIndex", last_off));
4925 break;
4926 }
4927 }
4928 Devlink::DpipeEntryMatchValues(val) => {
4929 (stack, missing) = val.lookup_attr(offset, missing_type);
4930 if !stack.is_empty() {
4931 break;
4932 }
4933 }
4934 Devlink::DpipeEntryActionValues(val) => {
4935 (stack, missing) = val.lookup_attr(offset, missing_type);
4936 if !stack.is_empty() {
4937 break;
4938 }
4939 }
4940 Devlink::DpipeEntryCounter(val) => {
4941 if last_off == offset {
4942 stack.push(("DpipeEntryCounter", last_off));
4943 break;
4944 }
4945 }
4946 Devlink::DpipeMatch(val) => {
4947 (stack, missing) = val.lookup_attr(offset, missing_type);
4948 if !stack.is_empty() {
4949 break;
4950 }
4951 }
4952 Devlink::DpipeMatchValue(val) => {
4953 (stack, missing) = val.lookup_attr(offset, missing_type);
4954 if !stack.is_empty() {
4955 break;
4956 }
4957 }
4958 Devlink::DpipeMatchType(val) => {
4959 if last_off == offset {
4960 stack.push(("DpipeMatchType", last_off));
4961 break;
4962 }
4963 }
4964 Devlink::DpipeAction(val) => {
4965 (stack, missing) = val.lookup_attr(offset, missing_type);
4966 if !stack.is_empty() {
4967 break;
4968 }
4969 }
4970 Devlink::DpipeActionValue(val) => {
4971 (stack, missing) = val.lookup_attr(offset, missing_type);
4972 if !stack.is_empty() {
4973 break;
4974 }
4975 }
4976 Devlink::DpipeActionType(val) => {
4977 if last_off == offset {
4978 stack.push(("DpipeActionType", last_off));
4979 break;
4980 }
4981 }
4982 Devlink::DpipeValue(val) => {
4983 if last_off == offset {
4984 stack.push(("DpipeValue", last_off));
4985 break;
4986 }
4987 }
4988 Devlink::DpipeValueMask(val) => {
4989 if last_off == offset {
4990 stack.push(("DpipeValueMask", last_off));
4991 break;
4992 }
4993 }
4994 Devlink::DpipeValueMapping(val) => {
4995 if last_off == offset {
4996 stack.push(("DpipeValueMapping", last_off));
4997 break;
4998 }
4999 }
5000 Devlink::DpipeHeaders(val) => {
5001 (stack, missing) = val.lookup_attr(offset, missing_type);
5002 if !stack.is_empty() {
5003 break;
5004 }
5005 }
5006 Devlink::DpipeHeader(val) => {
5007 (stack, missing) = val.lookup_attr(offset, missing_type);
5008 if !stack.is_empty() {
5009 break;
5010 }
5011 }
5012 Devlink::DpipeHeaderName(val) => {
5013 if last_off == offset {
5014 stack.push(("DpipeHeaderName", last_off));
5015 break;
5016 }
5017 }
5018 Devlink::DpipeHeaderId(val) => {
5019 if last_off == offset {
5020 stack.push(("DpipeHeaderId", last_off));
5021 break;
5022 }
5023 }
5024 Devlink::DpipeHeaderFields(val) => {
5025 (stack, missing) = val.lookup_attr(offset, missing_type);
5026 if !stack.is_empty() {
5027 break;
5028 }
5029 }
5030 Devlink::DpipeHeaderGlobal(val) => {
5031 if last_off == offset {
5032 stack.push(("DpipeHeaderGlobal", last_off));
5033 break;
5034 }
5035 }
5036 Devlink::DpipeHeaderIndex(val) => {
5037 if last_off == offset {
5038 stack.push(("DpipeHeaderIndex", last_off));
5039 break;
5040 }
5041 }
5042 Devlink::DpipeField(val) => {
5043 (stack, missing) = val.lookup_attr(offset, missing_type);
5044 if !stack.is_empty() {
5045 break;
5046 }
5047 }
5048 Devlink::DpipeFieldName(val) => {
5049 if last_off == offset {
5050 stack.push(("DpipeFieldName", last_off));
5051 break;
5052 }
5053 }
5054 Devlink::DpipeFieldId(val) => {
5055 if last_off == offset {
5056 stack.push(("DpipeFieldId", last_off));
5057 break;
5058 }
5059 }
5060 Devlink::DpipeFieldBitwidth(val) => {
5061 if last_off == offset {
5062 stack.push(("DpipeFieldBitwidth", last_off));
5063 break;
5064 }
5065 }
5066 Devlink::DpipeFieldMappingType(val) => {
5067 if last_off == offset {
5068 stack.push(("DpipeFieldMappingType", last_off));
5069 break;
5070 }
5071 }
5072 Devlink::Pad(val) => {
5073 if last_off == offset {
5074 stack.push(("Pad", last_off));
5075 break;
5076 }
5077 }
5078 Devlink::EswitchEncapMode(val) => {
5079 if last_off == offset {
5080 stack.push(("EswitchEncapMode", last_off));
5081 break;
5082 }
5083 }
5084 Devlink::ResourceList(val) => {
5085 (stack, missing) = val.lookup_attr(offset, missing_type);
5086 if !stack.is_empty() {
5087 break;
5088 }
5089 }
5090 Devlink::Resource(val) => {
5091 (stack, missing) = val.lookup_attr(offset, missing_type);
5092 if !stack.is_empty() {
5093 break;
5094 }
5095 }
5096 Devlink::ResourceName(val) => {
5097 if last_off == offset {
5098 stack.push(("ResourceName", last_off));
5099 break;
5100 }
5101 }
5102 Devlink::ResourceId(val) => {
5103 if last_off == offset {
5104 stack.push(("ResourceId", last_off));
5105 break;
5106 }
5107 }
5108 Devlink::ResourceSize(val) => {
5109 if last_off == offset {
5110 stack.push(("ResourceSize", last_off));
5111 break;
5112 }
5113 }
5114 Devlink::ResourceSizeNew(val) => {
5115 if last_off == offset {
5116 stack.push(("ResourceSizeNew", last_off));
5117 break;
5118 }
5119 }
5120 Devlink::ResourceSizeValid(val) => {
5121 if last_off == offset {
5122 stack.push(("ResourceSizeValid", last_off));
5123 break;
5124 }
5125 }
5126 Devlink::ResourceSizeMin(val) => {
5127 if last_off == offset {
5128 stack.push(("ResourceSizeMin", last_off));
5129 break;
5130 }
5131 }
5132 Devlink::ResourceSizeMax(val) => {
5133 if last_off == offset {
5134 stack.push(("ResourceSizeMax", last_off));
5135 break;
5136 }
5137 }
5138 Devlink::ResourceSizeGran(val) => {
5139 if last_off == offset {
5140 stack.push(("ResourceSizeGran", last_off));
5141 break;
5142 }
5143 }
5144 Devlink::ResourceUnit(val) => {
5145 if last_off == offset {
5146 stack.push(("ResourceUnit", last_off));
5147 break;
5148 }
5149 }
5150 Devlink::ResourceOcc(val) => {
5151 if last_off == offset {
5152 stack.push(("ResourceOcc", last_off));
5153 break;
5154 }
5155 }
5156 Devlink::DpipeTableResourceId(val) => {
5157 if last_off == offset {
5158 stack.push(("DpipeTableResourceId", last_off));
5159 break;
5160 }
5161 }
5162 Devlink::DpipeTableResourceUnits(val) => {
5163 if last_off == offset {
5164 stack.push(("DpipeTableResourceUnits", last_off));
5165 break;
5166 }
5167 }
5168 Devlink::PortFlavour(val) => {
5169 if last_off == offset {
5170 stack.push(("PortFlavour", last_off));
5171 break;
5172 }
5173 }
5174 Devlink::PortNumber(val) => {
5175 if last_off == offset {
5176 stack.push(("PortNumber", last_off));
5177 break;
5178 }
5179 }
5180 Devlink::PortSplitSubportNumber(val) => {
5181 if last_off == offset {
5182 stack.push(("PortSplitSubportNumber", last_off));
5183 break;
5184 }
5185 }
5186 Devlink::Param(val) => {
5187 (stack, missing) = val.lookup_attr(offset, missing_type);
5188 if !stack.is_empty() {
5189 break;
5190 }
5191 }
5192 Devlink::ParamName(val) => {
5193 if last_off == offset {
5194 stack.push(("ParamName", last_off));
5195 break;
5196 }
5197 }
5198 Devlink::ParamGeneric(val) => {
5199 if last_off == offset {
5200 stack.push(("ParamGeneric", last_off));
5201 break;
5202 }
5203 }
5204 Devlink::ParamType(val) => {
5205 if last_off == offset {
5206 stack.push(("ParamType", last_off));
5207 break;
5208 }
5209 }
5210 Devlink::ParamValueCmode(val) => {
5211 if last_off == offset {
5212 stack.push(("ParamValueCmode", last_off));
5213 break;
5214 }
5215 }
5216 Devlink::RegionName(val) => {
5217 if last_off == offset {
5218 stack.push(("RegionName", last_off));
5219 break;
5220 }
5221 }
5222 Devlink::RegionSize(val) => {
5223 if last_off == offset {
5224 stack.push(("RegionSize", last_off));
5225 break;
5226 }
5227 }
5228 Devlink::RegionSnapshots(val) => {
5229 (stack, missing) = val.lookup_attr(offset, missing_type);
5230 if !stack.is_empty() {
5231 break;
5232 }
5233 }
5234 Devlink::RegionSnapshot(val) => {
5235 (stack, missing) = val.lookup_attr(offset, missing_type);
5236 if !stack.is_empty() {
5237 break;
5238 }
5239 }
5240 Devlink::RegionSnapshotId(val) => {
5241 if last_off == offset {
5242 stack.push(("RegionSnapshotId", last_off));
5243 break;
5244 }
5245 }
5246 Devlink::RegionChunks(val) => {
5247 (stack, missing) = val.lookup_attr(offset, missing_type);
5248 if !stack.is_empty() {
5249 break;
5250 }
5251 }
5252 Devlink::RegionChunk(val) => {
5253 (stack, missing) = val.lookup_attr(offset, missing_type);
5254 if !stack.is_empty() {
5255 break;
5256 }
5257 }
5258 Devlink::RegionChunkData(val) => {
5259 if last_off == offset {
5260 stack.push(("RegionChunkData", last_off));
5261 break;
5262 }
5263 }
5264 Devlink::RegionChunkAddr(val) => {
5265 if last_off == offset {
5266 stack.push(("RegionChunkAddr", last_off));
5267 break;
5268 }
5269 }
5270 Devlink::RegionChunkLen(val) => {
5271 if last_off == offset {
5272 stack.push(("RegionChunkLen", last_off));
5273 break;
5274 }
5275 }
5276 Devlink::InfoDriverName(val) => {
5277 if last_off == offset {
5278 stack.push(("InfoDriverName", last_off));
5279 break;
5280 }
5281 }
5282 Devlink::InfoSerialNumber(val) => {
5283 if last_off == offset {
5284 stack.push(("InfoSerialNumber", last_off));
5285 break;
5286 }
5287 }
5288 Devlink::InfoVersionFixed(val) => {
5289 (stack, missing) = val.lookup_attr(offset, missing_type);
5290 if !stack.is_empty() {
5291 break;
5292 }
5293 }
5294 Devlink::InfoVersionRunning(val) => {
5295 (stack, missing) = val.lookup_attr(offset, missing_type);
5296 if !stack.is_empty() {
5297 break;
5298 }
5299 }
5300 Devlink::InfoVersionStored(val) => {
5301 (stack, missing) = val.lookup_attr(offset, missing_type);
5302 if !stack.is_empty() {
5303 break;
5304 }
5305 }
5306 Devlink::InfoVersionName(val) => {
5307 if last_off == offset {
5308 stack.push(("InfoVersionName", last_off));
5309 break;
5310 }
5311 }
5312 Devlink::InfoVersionValue(val) => {
5313 if last_off == offset {
5314 stack.push(("InfoVersionValue", last_off));
5315 break;
5316 }
5317 }
5318 Devlink::SbPoolCellSize(val) => {
5319 if last_off == offset {
5320 stack.push(("SbPoolCellSize", last_off));
5321 break;
5322 }
5323 }
5324 Devlink::Fmsg(val) => {
5325 (stack, missing) = val.lookup_attr(offset, missing_type);
5326 if !stack.is_empty() {
5327 break;
5328 }
5329 }
5330 Devlink::FmsgObjNestStart(val) => {
5331 if last_off == offset {
5332 stack.push(("FmsgObjNestStart", last_off));
5333 break;
5334 }
5335 }
5336 Devlink::FmsgPairNestStart(val) => {
5337 if last_off == offset {
5338 stack.push(("FmsgPairNestStart", last_off));
5339 break;
5340 }
5341 }
5342 Devlink::FmsgArrNestStart(val) => {
5343 if last_off == offset {
5344 stack.push(("FmsgArrNestStart", last_off));
5345 break;
5346 }
5347 }
5348 Devlink::FmsgNestEnd(val) => {
5349 if last_off == offset {
5350 stack.push(("FmsgNestEnd", last_off));
5351 break;
5352 }
5353 }
5354 Devlink::FmsgObjName(val) => {
5355 if last_off == offset {
5356 stack.push(("FmsgObjName", last_off));
5357 break;
5358 }
5359 }
5360 Devlink::FmsgObjValueType(val) => {
5361 if last_off == offset {
5362 stack.push(("FmsgObjValueType", last_off));
5363 break;
5364 }
5365 }
5366 Devlink::HealthReporter(val) => {
5367 (stack, missing) = val.lookup_attr(offset, missing_type);
5368 if !stack.is_empty() {
5369 break;
5370 }
5371 }
5372 Devlink::HealthReporterName(val) => {
5373 if last_off == offset {
5374 stack.push(("HealthReporterName", last_off));
5375 break;
5376 }
5377 }
5378 Devlink::HealthReporterState(val) => {
5379 if last_off == offset {
5380 stack.push(("HealthReporterState", last_off));
5381 break;
5382 }
5383 }
5384 Devlink::HealthReporterErrCount(val) => {
5385 if last_off == offset {
5386 stack.push(("HealthReporterErrCount", last_off));
5387 break;
5388 }
5389 }
5390 Devlink::HealthReporterRecoverCount(val) => {
5391 if last_off == offset {
5392 stack.push(("HealthReporterRecoverCount", last_off));
5393 break;
5394 }
5395 }
5396 Devlink::HealthReporterDumpTs(val) => {
5397 if last_off == offset {
5398 stack.push(("HealthReporterDumpTs", last_off));
5399 break;
5400 }
5401 }
5402 Devlink::HealthReporterGracefulPeriod(val) => {
5403 if last_off == offset {
5404 stack.push(("HealthReporterGracefulPeriod", last_off));
5405 break;
5406 }
5407 }
5408 Devlink::HealthReporterAutoRecover(val) => {
5409 if last_off == offset {
5410 stack.push(("HealthReporterAutoRecover", last_off));
5411 break;
5412 }
5413 }
5414 Devlink::FlashUpdateFileName(val) => {
5415 if last_off == offset {
5416 stack.push(("FlashUpdateFileName", last_off));
5417 break;
5418 }
5419 }
5420 Devlink::FlashUpdateComponent(val) => {
5421 if last_off == offset {
5422 stack.push(("FlashUpdateComponent", last_off));
5423 break;
5424 }
5425 }
5426 Devlink::FlashUpdateStatusMsg(val) => {
5427 if last_off == offset {
5428 stack.push(("FlashUpdateStatusMsg", last_off));
5429 break;
5430 }
5431 }
5432 Devlink::FlashUpdateStatusDone(val) => {
5433 if last_off == offset {
5434 stack.push(("FlashUpdateStatusDone", last_off));
5435 break;
5436 }
5437 }
5438 Devlink::FlashUpdateStatusTotal(val) => {
5439 if last_off == offset {
5440 stack.push(("FlashUpdateStatusTotal", last_off));
5441 break;
5442 }
5443 }
5444 Devlink::PortPciPfNumber(val) => {
5445 if last_off == offset {
5446 stack.push(("PortPciPfNumber", last_off));
5447 break;
5448 }
5449 }
5450 Devlink::PortPciVfNumber(val) => {
5451 if last_off == offset {
5452 stack.push(("PortPciVfNumber", last_off));
5453 break;
5454 }
5455 }
5456 Devlink::Stats(val) => {
5457 (stack, missing) = val.lookup_attr(offset, missing_type);
5458 if !stack.is_empty() {
5459 break;
5460 }
5461 }
5462 Devlink::TrapName(val) => {
5463 if last_off == offset {
5464 stack.push(("TrapName", last_off));
5465 break;
5466 }
5467 }
5468 Devlink::TrapAction(val) => {
5469 if last_off == offset {
5470 stack.push(("TrapAction", last_off));
5471 break;
5472 }
5473 }
5474 Devlink::TrapType(val) => {
5475 if last_off == offset {
5476 stack.push(("TrapType", last_off));
5477 break;
5478 }
5479 }
5480 Devlink::TrapGeneric(val) => {
5481 if last_off == offset {
5482 stack.push(("TrapGeneric", last_off));
5483 break;
5484 }
5485 }
5486 Devlink::TrapMetadata(val) => {
5487 (stack, missing) = val.lookup_attr(offset, missing_type);
5488 if !stack.is_empty() {
5489 break;
5490 }
5491 }
5492 Devlink::TrapGroupName(val) => {
5493 if last_off == offset {
5494 stack.push(("TrapGroupName", last_off));
5495 break;
5496 }
5497 }
5498 Devlink::ReloadFailed(val) => {
5499 if last_off == offset {
5500 stack.push(("ReloadFailed", last_off));
5501 break;
5502 }
5503 }
5504 Devlink::HealthReporterDumpTsNs(val) => {
5505 if last_off == offset {
5506 stack.push(("HealthReporterDumpTsNs", last_off));
5507 break;
5508 }
5509 }
5510 Devlink::NetnsFd(val) => {
5511 if last_off == offset {
5512 stack.push(("NetnsFd", last_off));
5513 break;
5514 }
5515 }
5516 Devlink::NetnsPid(val) => {
5517 if last_off == offset {
5518 stack.push(("NetnsPid", last_off));
5519 break;
5520 }
5521 }
5522 Devlink::NetnsId(val) => {
5523 if last_off == offset {
5524 stack.push(("NetnsId", last_off));
5525 break;
5526 }
5527 }
5528 Devlink::HealthReporterAutoDump(val) => {
5529 if last_off == offset {
5530 stack.push(("HealthReporterAutoDump", last_off));
5531 break;
5532 }
5533 }
5534 Devlink::TrapPolicerId(val) => {
5535 if last_off == offset {
5536 stack.push(("TrapPolicerId", last_off));
5537 break;
5538 }
5539 }
5540 Devlink::TrapPolicerRate(val) => {
5541 if last_off == offset {
5542 stack.push(("TrapPolicerRate", last_off));
5543 break;
5544 }
5545 }
5546 Devlink::TrapPolicerBurst(val) => {
5547 if last_off == offset {
5548 stack.push(("TrapPolicerBurst", last_off));
5549 break;
5550 }
5551 }
5552 Devlink::PortFunction(val) => {
5553 (stack, missing) = val.lookup_attr(offset, missing_type);
5554 if !stack.is_empty() {
5555 break;
5556 }
5557 }
5558 Devlink::InfoBoardSerialNumber(val) => {
5559 if last_off == offset {
5560 stack.push(("InfoBoardSerialNumber", last_off));
5561 break;
5562 }
5563 }
5564 Devlink::PortLanes(val) => {
5565 if last_off == offset {
5566 stack.push(("PortLanes", last_off));
5567 break;
5568 }
5569 }
5570 Devlink::PortSplittable(val) => {
5571 if last_off == offset {
5572 stack.push(("PortSplittable", last_off));
5573 break;
5574 }
5575 }
5576 Devlink::PortExternal(val) => {
5577 if last_off == offset {
5578 stack.push(("PortExternal", last_off));
5579 break;
5580 }
5581 }
5582 Devlink::PortControllerNumber(val) => {
5583 if last_off == offset {
5584 stack.push(("PortControllerNumber", last_off));
5585 break;
5586 }
5587 }
5588 Devlink::FlashUpdateStatusTimeout(val) => {
5589 if last_off == offset {
5590 stack.push(("FlashUpdateStatusTimeout", last_off));
5591 break;
5592 }
5593 }
5594 Devlink::FlashUpdateOverwriteMask(val) => {
5595 if last_off == offset {
5596 stack.push(("FlashUpdateOverwriteMask", last_off));
5597 break;
5598 }
5599 }
5600 Devlink::ReloadAction(val) => {
5601 if last_off == offset {
5602 stack.push(("ReloadAction", last_off));
5603 break;
5604 }
5605 }
5606 Devlink::ReloadActionsPerformed(val) => {
5607 if last_off == offset {
5608 stack.push(("ReloadActionsPerformed", last_off));
5609 break;
5610 }
5611 }
5612 Devlink::ReloadLimits(val) => {
5613 if last_off == offset {
5614 stack.push(("ReloadLimits", last_off));
5615 break;
5616 }
5617 }
5618 Devlink::DevStats(val) => {
5619 (stack, missing) = val.lookup_attr(offset, missing_type);
5620 if !stack.is_empty() {
5621 break;
5622 }
5623 }
5624 Devlink::ReloadStats(val) => {
5625 (stack, missing) = val.lookup_attr(offset, missing_type);
5626 if !stack.is_empty() {
5627 break;
5628 }
5629 }
5630 Devlink::ReloadStatsEntry(val) => {
5631 (stack, missing) = val.lookup_attr(offset, missing_type);
5632 if !stack.is_empty() {
5633 break;
5634 }
5635 }
5636 Devlink::ReloadStatsLimit(val) => {
5637 if last_off == offset {
5638 stack.push(("ReloadStatsLimit", last_off));
5639 break;
5640 }
5641 }
5642 Devlink::ReloadStatsValue(val) => {
5643 if last_off == offset {
5644 stack.push(("ReloadStatsValue", last_off));
5645 break;
5646 }
5647 }
5648 Devlink::RemoteReloadStats(val) => {
5649 (stack, missing) = val.lookup_attr(offset, missing_type);
5650 if !stack.is_empty() {
5651 break;
5652 }
5653 }
5654 Devlink::ReloadActionInfo(val) => {
5655 (stack, missing) = val.lookup_attr(offset, missing_type);
5656 if !stack.is_empty() {
5657 break;
5658 }
5659 }
5660 Devlink::ReloadActionStats(val) => {
5661 (stack, missing) = val.lookup_attr(offset, missing_type);
5662 if !stack.is_empty() {
5663 break;
5664 }
5665 }
5666 Devlink::PortPciSfNumber(val) => {
5667 if last_off == offset {
5668 stack.push(("PortPciSfNumber", last_off));
5669 break;
5670 }
5671 }
5672 Devlink::RateType(val) => {
5673 if last_off == offset {
5674 stack.push(("RateType", last_off));
5675 break;
5676 }
5677 }
5678 Devlink::RateTxShare(val) => {
5679 if last_off == offset {
5680 stack.push(("RateTxShare", last_off));
5681 break;
5682 }
5683 }
5684 Devlink::RateTxMax(val) => {
5685 if last_off == offset {
5686 stack.push(("RateTxMax", last_off));
5687 break;
5688 }
5689 }
5690 Devlink::RateNodeName(val) => {
5691 if last_off == offset {
5692 stack.push(("RateNodeName", last_off));
5693 break;
5694 }
5695 }
5696 Devlink::RateParentNodeName(val) => {
5697 if last_off == offset {
5698 stack.push(("RateParentNodeName", last_off));
5699 break;
5700 }
5701 }
5702 Devlink::RegionMaxSnapshots(val) => {
5703 if last_off == offset {
5704 stack.push(("RegionMaxSnapshots", last_off));
5705 break;
5706 }
5707 }
5708 Devlink::LinecardIndex(val) => {
5709 if last_off == offset {
5710 stack.push(("LinecardIndex", last_off));
5711 break;
5712 }
5713 }
5714 Devlink::LinecardState(val) => {
5715 if last_off == offset {
5716 stack.push(("LinecardState", last_off));
5717 break;
5718 }
5719 }
5720 Devlink::LinecardType(val) => {
5721 if last_off == offset {
5722 stack.push(("LinecardType", last_off));
5723 break;
5724 }
5725 }
5726 Devlink::LinecardSupportedTypes(val) => {
5727 (stack, missing) = val.lookup_attr(offset, missing_type);
5728 if !stack.is_empty() {
5729 break;
5730 }
5731 }
5732 Devlink::Selftests(val) => {
5733 (stack, missing) = val.lookup_attr(offset, missing_type);
5734 if !stack.is_empty() {
5735 break;
5736 }
5737 }
5738 Devlink::RateTxPriority(val) => {
5739 if last_off == offset {
5740 stack.push(("RateTxPriority", last_off));
5741 break;
5742 }
5743 }
5744 Devlink::RateTxWeight(val) => {
5745 if last_off == offset {
5746 stack.push(("RateTxWeight", last_off));
5747 break;
5748 }
5749 }
5750 Devlink::RegionDirect(val) => {
5751 if last_off == offset {
5752 stack.push(("RegionDirect", last_off));
5753 break;
5754 }
5755 }
5756 Devlink::RateTcBws(val) => {
5757 (stack, missing) = val.lookup_attr(offset, missing_type);
5758 if !stack.is_empty() {
5759 break;
5760 }
5761 }
5762 Devlink::HealthReporterBurstPeriod(val) => {
5763 if last_off == offset {
5764 stack.push(("HealthReporterBurstPeriod", last_off));
5765 break;
5766 }
5767 }
5768 Devlink::ParamResetDefault(val) => {
5769 if last_off == offset {
5770 stack.push(("ParamResetDefault", last_off));
5771 break;
5772 }
5773 }
5774 Devlink::Index(val) => {
5775 if last_off == offset {
5776 stack.push(("Index", last_off));
5777 break;
5778 }
5779 }
5780 Devlink::ResourceScopeMask(val) => {
5781 if last_off == offset {
5782 stack.push(("ResourceScopeMask", last_off));
5783 break;
5784 }
5785 }
5786 _ => {}
5787 };
5788 last_off = cur + attrs.pos;
5789 }
5790 if !stack.is_empty() {
5791 stack.push(("Devlink", cur));
5792 }
5793 (stack, missing)
5794 }
5795}
5796#[derive(Clone)]
5797pub enum DlDevStats<'a> {
5798 ReloadStats(IterableDlReloadStats<'a>),
5799 RemoteReloadStats(IterableDlReloadStats<'a>),
5800}
5801impl<'a> IterableDlDevStats<'a> {
5802 pub fn get_reload_stats(&self) -> Result<IterableDlReloadStats<'a>, ErrorContext> {
5803 let mut iter = self.clone();
5804 iter.pos = 0;
5805 for attr in iter {
5806 if let Ok(DlDevStats::ReloadStats(val)) = attr {
5807 return Ok(val);
5808 }
5809 }
5810 Err(ErrorContext::new_missing(
5811 "DlDevStats",
5812 "ReloadStats",
5813 self.orig_loc,
5814 self.buf.as_ptr() as usize,
5815 ))
5816 }
5817 pub fn get_remote_reload_stats(&self) -> Result<IterableDlReloadStats<'a>, ErrorContext> {
5818 let mut iter = self.clone();
5819 iter.pos = 0;
5820 for attr in iter {
5821 if let Ok(DlDevStats::RemoteReloadStats(val)) = attr {
5822 return Ok(val);
5823 }
5824 }
5825 Err(ErrorContext::new_missing(
5826 "DlDevStats",
5827 "RemoteReloadStats",
5828 self.orig_loc,
5829 self.buf.as_ptr() as usize,
5830 ))
5831 }
5832}
5833impl DlDevStats<'_> {
5834 pub fn new<'a>(buf: &'a [u8]) -> IterableDlDevStats<'a> {
5835 IterableDlDevStats::with_loc(buf, buf.as_ptr() as usize)
5836 }
5837 fn attr_from_type(r#type: u16) -> Option<&'static str> {
5838 Devlink::attr_from_type(r#type)
5839 }
5840}
5841#[derive(Clone, Copy, Default)]
5842pub struct IterableDlDevStats<'a> {
5843 buf: &'a [u8],
5844 pos: usize,
5845 orig_loc: usize,
5846}
5847impl<'a> IterableDlDevStats<'a> {
5848 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
5849 Self {
5850 buf,
5851 pos: 0,
5852 orig_loc,
5853 }
5854 }
5855 pub fn get_buf(&self) -> &'a [u8] {
5856 self.buf
5857 }
5858}
5859impl<'a> Iterator for IterableDlDevStats<'a> {
5860 type Item = Result<DlDevStats<'a>, ErrorContext>;
5861 fn next(&mut self) -> Option<Self::Item> {
5862 let mut pos;
5863 let mut r#type;
5864 loop {
5865 pos = self.pos;
5866 r#type = None;
5867 if self.buf.len() == self.pos {
5868 return None;
5869 }
5870 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
5871 self.pos = self.buf.len();
5872 break;
5873 };
5874 r#type = Some(header.r#type);
5875 let res = match header.r#type {
5876 157u16 => DlDevStats::ReloadStats({
5877 let res = Some(IterableDlReloadStats::with_loc(next, self.orig_loc));
5878 let Some(val) = res else { break };
5879 val
5880 }),
5881 161u16 => DlDevStats::RemoteReloadStats({
5882 let res = Some(IterableDlReloadStats::with_loc(next, self.orig_loc));
5883 let Some(val) = res else { break };
5884 val
5885 }),
5886 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
5887 n => continue,
5888 };
5889 return Some(Ok(res));
5890 }
5891 Some(Err(ErrorContext::new(
5892 "DlDevStats",
5893 r#type.and_then(|t| DlDevStats::attr_from_type(t)),
5894 self.orig_loc,
5895 self.buf.as_ptr().wrapping_add(pos) as usize,
5896 )))
5897 }
5898}
5899impl<'a> std::fmt::Debug for IterableDlDevStats<'_> {
5900 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5901 let mut fmt = f.debug_struct("DlDevStats");
5902 for attr in self.clone() {
5903 let attr = match attr {
5904 Ok(a) => a,
5905 Err(err) => {
5906 fmt.finish()?;
5907 f.write_str("Err(")?;
5908 err.fmt(f)?;
5909 return f.write_str(")");
5910 }
5911 };
5912 match attr {
5913 DlDevStats::ReloadStats(val) => fmt.field("ReloadStats", &val),
5914 DlDevStats::RemoteReloadStats(val) => fmt.field("RemoteReloadStats", &val),
5915 };
5916 }
5917 fmt.finish()
5918 }
5919}
5920impl IterableDlDevStats<'_> {
5921 pub fn lookup_attr(
5922 &self,
5923 offset: usize,
5924 missing_type: Option<u16>,
5925 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
5926 let mut stack = Vec::new();
5927 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
5928 if missing_type.is_some() && cur == offset {
5929 stack.push(("DlDevStats", offset));
5930 return (
5931 stack,
5932 missing_type.and_then(|t| DlDevStats::attr_from_type(t)),
5933 );
5934 }
5935 if cur > offset || cur + self.buf.len() < offset {
5936 return (stack, None);
5937 }
5938 let mut attrs = self.clone();
5939 let mut last_off = cur + attrs.pos;
5940 let mut missing = None;
5941 while let Some(attr) = attrs.next() {
5942 let Ok(attr) = attr else { break };
5943 match attr {
5944 DlDevStats::ReloadStats(val) => {
5945 (stack, missing) = val.lookup_attr(offset, missing_type);
5946 if !stack.is_empty() {
5947 break;
5948 }
5949 }
5950 DlDevStats::RemoteReloadStats(val) => {
5951 (stack, missing) = val.lookup_attr(offset, missing_type);
5952 if !stack.is_empty() {
5953 break;
5954 }
5955 }
5956 _ => {}
5957 };
5958 last_off = cur + attrs.pos;
5959 }
5960 if !stack.is_empty() {
5961 stack.push(("DlDevStats", cur));
5962 }
5963 (stack, missing)
5964 }
5965}
5966#[derive(Clone)]
5967pub enum DlReloadStats<'a> {
5968 #[doc = "Attribute may repeat multiple times (treat it as array)"]
5969 ReloadActionInfo(IterableDlReloadActInfo<'a>),
5970}
5971impl<'a> IterableDlReloadStats<'a> {
5972 #[doc = "Attribute may repeat multiple times (treat it as array)"]
5973 pub fn get_reload_action_info(
5974 &self,
5975 ) -> MultiAttrIterable<Self, DlReloadStats<'a>, IterableDlReloadActInfo<'a>> {
5976 MultiAttrIterable::new(self.clone(), |variant| {
5977 if let DlReloadStats::ReloadActionInfo(val) = variant {
5978 Some(val)
5979 } else {
5980 None
5981 }
5982 })
5983 }
5984}
5985impl DlReloadStats<'_> {
5986 pub fn new<'a>(buf: &'a [u8]) -> IterableDlReloadStats<'a> {
5987 IterableDlReloadStats::with_loc(buf, buf.as_ptr() as usize)
5988 }
5989 fn attr_from_type(r#type: u16) -> Option<&'static str> {
5990 Devlink::attr_from_type(r#type)
5991 }
5992}
5993#[derive(Clone, Copy, Default)]
5994pub struct IterableDlReloadStats<'a> {
5995 buf: &'a [u8],
5996 pos: usize,
5997 orig_loc: usize,
5998}
5999impl<'a> IterableDlReloadStats<'a> {
6000 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
6001 Self {
6002 buf,
6003 pos: 0,
6004 orig_loc,
6005 }
6006 }
6007 pub fn get_buf(&self) -> &'a [u8] {
6008 self.buf
6009 }
6010}
6011impl<'a> Iterator for IterableDlReloadStats<'a> {
6012 type Item = Result<DlReloadStats<'a>, ErrorContext>;
6013 fn next(&mut self) -> Option<Self::Item> {
6014 let mut pos;
6015 let mut r#type;
6016 loop {
6017 pos = self.pos;
6018 r#type = None;
6019 if self.buf.len() == self.pos {
6020 return None;
6021 }
6022 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
6023 self.pos = self.buf.len();
6024 break;
6025 };
6026 r#type = Some(header.r#type);
6027 let res = match header.r#type {
6028 162u16 => DlReloadStats::ReloadActionInfo({
6029 let res = Some(IterableDlReloadActInfo::with_loc(next, self.orig_loc));
6030 let Some(val) = res else { break };
6031 val
6032 }),
6033 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
6034 n => continue,
6035 };
6036 return Some(Ok(res));
6037 }
6038 Some(Err(ErrorContext::new(
6039 "DlReloadStats",
6040 r#type.and_then(|t| DlReloadStats::attr_from_type(t)),
6041 self.orig_loc,
6042 self.buf.as_ptr().wrapping_add(pos) as usize,
6043 )))
6044 }
6045}
6046impl<'a> std::fmt::Debug for IterableDlReloadStats<'_> {
6047 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6048 let mut fmt = f.debug_struct("DlReloadStats");
6049 for attr in self.clone() {
6050 let attr = match attr {
6051 Ok(a) => a,
6052 Err(err) => {
6053 fmt.finish()?;
6054 f.write_str("Err(")?;
6055 err.fmt(f)?;
6056 return f.write_str(")");
6057 }
6058 };
6059 match attr {
6060 DlReloadStats::ReloadActionInfo(val) => fmt.field("ReloadActionInfo", &val),
6061 };
6062 }
6063 fmt.finish()
6064 }
6065}
6066impl IterableDlReloadStats<'_> {
6067 pub fn lookup_attr(
6068 &self,
6069 offset: usize,
6070 missing_type: Option<u16>,
6071 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
6072 let mut stack = Vec::new();
6073 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
6074 if missing_type.is_some() && cur == offset {
6075 stack.push(("DlReloadStats", offset));
6076 return (
6077 stack,
6078 missing_type.and_then(|t| DlReloadStats::attr_from_type(t)),
6079 );
6080 }
6081 if cur > offset || cur + self.buf.len() < offset {
6082 return (stack, None);
6083 }
6084 let mut attrs = self.clone();
6085 let mut last_off = cur + attrs.pos;
6086 let mut missing = None;
6087 while let Some(attr) = attrs.next() {
6088 let Ok(attr) = attr else { break };
6089 match attr {
6090 DlReloadStats::ReloadActionInfo(val) => {
6091 (stack, missing) = val.lookup_attr(offset, missing_type);
6092 if !stack.is_empty() {
6093 break;
6094 }
6095 }
6096 _ => {}
6097 };
6098 last_off = cur + attrs.pos;
6099 }
6100 if !stack.is_empty() {
6101 stack.push(("DlReloadStats", cur));
6102 }
6103 (stack, missing)
6104 }
6105}
6106#[derive(Clone)]
6107pub enum DlReloadActInfo<'a> {
6108 #[doc = "Associated type: [`ReloadAction`] (enum)"]
6109 ReloadAction(u8),
6110 #[doc = "Attribute may repeat multiple times (treat it as array)"]
6111 ReloadActionStats(IterableDlReloadActStats<'a>),
6112}
6113impl<'a> IterableDlReloadActInfo<'a> {
6114 #[doc = "Associated type: [`ReloadAction`] (enum)"]
6115 pub fn get_reload_action(&self) -> Result<u8, ErrorContext> {
6116 let mut iter = self.clone();
6117 iter.pos = 0;
6118 for attr in iter {
6119 if let Ok(DlReloadActInfo::ReloadAction(val)) = attr {
6120 return Ok(val);
6121 }
6122 }
6123 Err(ErrorContext::new_missing(
6124 "DlReloadActInfo",
6125 "ReloadAction",
6126 self.orig_loc,
6127 self.buf.as_ptr() as usize,
6128 ))
6129 }
6130 #[doc = "Attribute may repeat multiple times (treat it as array)"]
6131 pub fn get_reload_action_stats(
6132 &self,
6133 ) -> MultiAttrIterable<Self, DlReloadActInfo<'a>, IterableDlReloadActStats<'a>> {
6134 MultiAttrIterable::new(self.clone(), |variant| {
6135 if let DlReloadActInfo::ReloadActionStats(val) = variant {
6136 Some(val)
6137 } else {
6138 None
6139 }
6140 })
6141 }
6142}
6143impl DlReloadActInfo<'_> {
6144 pub fn new<'a>(buf: &'a [u8]) -> IterableDlReloadActInfo<'a> {
6145 IterableDlReloadActInfo::with_loc(buf, buf.as_ptr() as usize)
6146 }
6147 fn attr_from_type(r#type: u16) -> Option<&'static str> {
6148 Devlink::attr_from_type(r#type)
6149 }
6150}
6151#[derive(Clone, Copy, Default)]
6152pub struct IterableDlReloadActInfo<'a> {
6153 buf: &'a [u8],
6154 pos: usize,
6155 orig_loc: usize,
6156}
6157impl<'a> IterableDlReloadActInfo<'a> {
6158 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
6159 Self {
6160 buf,
6161 pos: 0,
6162 orig_loc,
6163 }
6164 }
6165 pub fn get_buf(&self) -> &'a [u8] {
6166 self.buf
6167 }
6168}
6169impl<'a> Iterator for IterableDlReloadActInfo<'a> {
6170 type Item = Result<DlReloadActInfo<'a>, ErrorContext>;
6171 fn next(&mut self) -> Option<Self::Item> {
6172 let mut pos;
6173 let mut r#type;
6174 loop {
6175 pos = self.pos;
6176 r#type = None;
6177 if self.buf.len() == self.pos {
6178 return None;
6179 }
6180 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
6181 self.pos = self.buf.len();
6182 break;
6183 };
6184 r#type = Some(header.r#type);
6185 let res = match header.r#type {
6186 153u16 => DlReloadActInfo::ReloadAction({
6187 let res = parse_u8(next);
6188 let Some(val) = res else { break };
6189 val
6190 }),
6191 163u16 => DlReloadActInfo::ReloadActionStats({
6192 let res = Some(IterableDlReloadActStats::with_loc(next, self.orig_loc));
6193 let Some(val) = res else { break };
6194 val
6195 }),
6196 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
6197 n => continue,
6198 };
6199 return Some(Ok(res));
6200 }
6201 Some(Err(ErrorContext::new(
6202 "DlReloadActInfo",
6203 r#type.and_then(|t| DlReloadActInfo::attr_from_type(t)),
6204 self.orig_loc,
6205 self.buf.as_ptr().wrapping_add(pos) as usize,
6206 )))
6207 }
6208}
6209impl<'a> std::fmt::Debug for IterableDlReloadActInfo<'_> {
6210 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6211 let mut fmt = f.debug_struct("DlReloadActInfo");
6212 for attr in self.clone() {
6213 let attr = match attr {
6214 Ok(a) => a,
6215 Err(err) => {
6216 fmt.finish()?;
6217 f.write_str("Err(")?;
6218 err.fmt(f)?;
6219 return f.write_str(")");
6220 }
6221 };
6222 match attr {
6223 DlReloadActInfo::ReloadAction(val) => fmt.field(
6224 "ReloadAction",
6225 &FormatEnum(val.into(), ReloadAction::from_value),
6226 ),
6227 DlReloadActInfo::ReloadActionStats(val) => fmt.field("ReloadActionStats", &val),
6228 };
6229 }
6230 fmt.finish()
6231 }
6232}
6233impl IterableDlReloadActInfo<'_> {
6234 pub fn lookup_attr(
6235 &self,
6236 offset: usize,
6237 missing_type: Option<u16>,
6238 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
6239 let mut stack = Vec::new();
6240 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
6241 if missing_type.is_some() && cur == offset {
6242 stack.push(("DlReloadActInfo", offset));
6243 return (
6244 stack,
6245 missing_type.and_then(|t| DlReloadActInfo::attr_from_type(t)),
6246 );
6247 }
6248 if cur > offset || cur + self.buf.len() < offset {
6249 return (stack, None);
6250 }
6251 let mut attrs = self.clone();
6252 let mut last_off = cur + attrs.pos;
6253 let mut missing = None;
6254 while let Some(attr) = attrs.next() {
6255 let Ok(attr) = attr else { break };
6256 match attr {
6257 DlReloadActInfo::ReloadAction(val) => {
6258 if last_off == offset {
6259 stack.push(("ReloadAction", last_off));
6260 break;
6261 }
6262 }
6263 DlReloadActInfo::ReloadActionStats(val) => {
6264 (stack, missing) = val.lookup_attr(offset, missing_type);
6265 if !stack.is_empty() {
6266 break;
6267 }
6268 }
6269 _ => {}
6270 };
6271 last_off = cur + attrs.pos;
6272 }
6273 if !stack.is_empty() {
6274 stack.push(("DlReloadActInfo", cur));
6275 }
6276 (stack, missing)
6277 }
6278}
6279#[derive(Clone)]
6280pub enum DlReloadActStats<'a> {
6281 #[doc = "Attribute may repeat multiple times (treat it as array)"]
6282 ReloadStatsEntry(IterableDlReloadStatsEntry<'a>),
6283}
6284impl<'a> IterableDlReloadActStats<'a> {
6285 #[doc = "Attribute may repeat multiple times (treat it as array)"]
6286 pub fn get_reload_stats_entry(
6287 &self,
6288 ) -> MultiAttrIterable<Self, DlReloadActStats<'a>, IterableDlReloadStatsEntry<'a>> {
6289 MultiAttrIterable::new(self.clone(), |variant| {
6290 if let DlReloadActStats::ReloadStatsEntry(val) = variant {
6291 Some(val)
6292 } else {
6293 None
6294 }
6295 })
6296 }
6297}
6298impl DlReloadActStats<'_> {
6299 pub fn new<'a>(buf: &'a [u8]) -> IterableDlReloadActStats<'a> {
6300 IterableDlReloadActStats::with_loc(buf, buf.as_ptr() as usize)
6301 }
6302 fn attr_from_type(r#type: u16) -> Option<&'static str> {
6303 Devlink::attr_from_type(r#type)
6304 }
6305}
6306#[derive(Clone, Copy, Default)]
6307pub struct IterableDlReloadActStats<'a> {
6308 buf: &'a [u8],
6309 pos: usize,
6310 orig_loc: usize,
6311}
6312impl<'a> IterableDlReloadActStats<'a> {
6313 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
6314 Self {
6315 buf,
6316 pos: 0,
6317 orig_loc,
6318 }
6319 }
6320 pub fn get_buf(&self) -> &'a [u8] {
6321 self.buf
6322 }
6323}
6324impl<'a> Iterator for IterableDlReloadActStats<'a> {
6325 type Item = Result<DlReloadActStats<'a>, ErrorContext>;
6326 fn next(&mut self) -> Option<Self::Item> {
6327 let mut pos;
6328 let mut r#type;
6329 loop {
6330 pos = self.pos;
6331 r#type = None;
6332 if self.buf.len() == self.pos {
6333 return None;
6334 }
6335 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
6336 self.pos = self.buf.len();
6337 break;
6338 };
6339 r#type = Some(header.r#type);
6340 let res = match header.r#type {
6341 158u16 => DlReloadActStats::ReloadStatsEntry({
6342 let res = Some(IterableDlReloadStatsEntry::with_loc(next, self.orig_loc));
6343 let Some(val) = res else { break };
6344 val
6345 }),
6346 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
6347 n => continue,
6348 };
6349 return Some(Ok(res));
6350 }
6351 Some(Err(ErrorContext::new(
6352 "DlReloadActStats",
6353 r#type.and_then(|t| DlReloadActStats::attr_from_type(t)),
6354 self.orig_loc,
6355 self.buf.as_ptr().wrapping_add(pos) as usize,
6356 )))
6357 }
6358}
6359impl<'a> std::fmt::Debug for IterableDlReloadActStats<'_> {
6360 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6361 let mut fmt = f.debug_struct("DlReloadActStats");
6362 for attr in self.clone() {
6363 let attr = match attr {
6364 Ok(a) => a,
6365 Err(err) => {
6366 fmt.finish()?;
6367 f.write_str("Err(")?;
6368 err.fmt(f)?;
6369 return f.write_str(")");
6370 }
6371 };
6372 match attr {
6373 DlReloadActStats::ReloadStatsEntry(val) => fmt.field("ReloadStatsEntry", &val),
6374 };
6375 }
6376 fmt.finish()
6377 }
6378}
6379impl IterableDlReloadActStats<'_> {
6380 pub fn lookup_attr(
6381 &self,
6382 offset: usize,
6383 missing_type: Option<u16>,
6384 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
6385 let mut stack = Vec::new();
6386 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
6387 if missing_type.is_some() && cur == offset {
6388 stack.push(("DlReloadActStats", offset));
6389 return (
6390 stack,
6391 missing_type.and_then(|t| DlReloadActStats::attr_from_type(t)),
6392 );
6393 }
6394 if cur > offset || cur + self.buf.len() < offset {
6395 return (stack, None);
6396 }
6397 let mut attrs = self.clone();
6398 let mut last_off = cur + attrs.pos;
6399 let mut missing = None;
6400 while let Some(attr) = attrs.next() {
6401 let Ok(attr) = attr else { break };
6402 match attr {
6403 DlReloadActStats::ReloadStatsEntry(val) => {
6404 (stack, missing) = val.lookup_attr(offset, missing_type);
6405 if !stack.is_empty() {
6406 break;
6407 }
6408 }
6409 _ => {}
6410 };
6411 last_off = cur + attrs.pos;
6412 }
6413 if !stack.is_empty() {
6414 stack.push(("DlReloadActStats", cur));
6415 }
6416 (stack, missing)
6417 }
6418}
6419#[derive(Clone)]
6420pub enum DlReloadStatsEntry {
6421 ReloadStatsLimit(u8),
6422 ReloadStatsValue(u32),
6423}
6424impl<'a> IterableDlReloadStatsEntry<'a> {
6425 pub fn get_reload_stats_limit(&self) -> Result<u8, ErrorContext> {
6426 let mut iter = self.clone();
6427 iter.pos = 0;
6428 for attr in iter {
6429 if let Ok(DlReloadStatsEntry::ReloadStatsLimit(val)) = attr {
6430 return Ok(val);
6431 }
6432 }
6433 Err(ErrorContext::new_missing(
6434 "DlReloadStatsEntry",
6435 "ReloadStatsLimit",
6436 self.orig_loc,
6437 self.buf.as_ptr() as usize,
6438 ))
6439 }
6440 pub fn get_reload_stats_value(&self) -> Result<u32, ErrorContext> {
6441 let mut iter = self.clone();
6442 iter.pos = 0;
6443 for attr in iter {
6444 if let Ok(DlReloadStatsEntry::ReloadStatsValue(val)) = attr {
6445 return Ok(val);
6446 }
6447 }
6448 Err(ErrorContext::new_missing(
6449 "DlReloadStatsEntry",
6450 "ReloadStatsValue",
6451 self.orig_loc,
6452 self.buf.as_ptr() as usize,
6453 ))
6454 }
6455}
6456impl DlReloadStatsEntry {
6457 pub fn new<'a>(buf: &'a [u8]) -> IterableDlReloadStatsEntry<'a> {
6458 IterableDlReloadStatsEntry::with_loc(buf, buf.as_ptr() as usize)
6459 }
6460 fn attr_from_type(r#type: u16) -> Option<&'static str> {
6461 Devlink::attr_from_type(r#type)
6462 }
6463}
6464#[derive(Clone, Copy, Default)]
6465pub struct IterableDlReloadStatsEntry<'a> {
6466 buf: &'a [u8],
6467 pos: usize,
6468 orig_loc: usize,
6469}
6470impl<'a> IterableDlReloadStatsEntry<'a> {
6471 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
6472 Self {
6473 buf,
6474 pos: 0,
6475 orig_loc,
6476 }
6477 }
6478 pub fn get_buf(&self) -> &'a [u8] {
6479 self.buf
6480 }
6481}
6482impl<'a> Iterator for IterableDlReloadStatsEntry<'a> {
6483 type Item = Result<DlReloadStatsEntry, ErrorContext>;
6484 fn next(&mut self) -> Option<Self::Item> {
6485 let mut pos;
6486 let mut r#type;
6487 loop {
6488 pos = self.pos;
6489 r#type = None;
6490 if self.buf.len() == self.pos {
6491 return None;
6492 }
6493 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
6494 self.pos = self.buf.len();
6495 break;
6496 };
6497 r#type = Some(header.r#type);
6498 let res = match header.r#type {
6499 159u16 => DlReloadStatsEntry::ReloadStatsLimit({
6500 let res = parse_u8(next);
6501 let Some(val) = res else { break };
6502 val
6503 }),
6504 160u16 => DlReloadStatsEntry::ReloadStatsValue({
6505 let res = parse_u32(next);
6506 let Some(val) = res else { break };
6507 val
6508 }),
6509 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
6510 n => continue,
6511 };
6512 return Some(Ok(res));
6513 }
6514 Some(Err(ErrorContext::new(
6515 "DlReloadStatsEntry",
6516 r#type.and_then(|t| DlReloadStatsEntry::attr_from_type(t)),
6517 self.orig_loc,
6518 self.buf.as_ptr().wrapping_add(pos) as usize,
6519 )))
6520 }
6521}
6522impl std::fmt::Debug for IterableDlReloadStatsEntry<'_> {
6523 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6524 let mut fmt = f.debug_struct("DlReloadStatsEntry");
6525 for attr in self.clone() {
6526 let attr = match attr {
6527 Ok(a) => a,
6528 Err(err) => {
6529 fmt.finish()?;
6530 f.write_str("Err(")?;
6531 err.fmt(f)?;
6532 return f.write_str(")");
6533 }
6534 };
6535 match attr {
6536 DlReloadStatsEntry::ReloadStatsLimit(val) => fmt.field("ReloadStatsLimit", &val),
6537 DlReloadStatsEntry::ReloadStatsValue(val) => fmt.field("ReloadStatsValue", &val),
6538 };
6539 }
6540 fmt.finish()
6541 }
6542}
6543impl IterableDlReloadStatsEntry<'_> {
6544 pub fn lookup_attr(
6545 &self,
6546 offset: usize,
6547 missing_type: Option<u16>,
6548 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
6549 let mut stack = Vec::new();
6550 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
6551 if missing_type.is_some() && cur == offset {
6552 stack.push(("DlReloadStatsEntry", offset));
6553 return (
6554 stack,
6555 missing_type.and_then(|t| DlReloadStatsEntry::attr_from_type(t)),
6556 );
6557 }
6558 if cur > offset || cur + self.buf.len() < offset {
6559 return (stack, None);
6560 }
6561 let mut attrs = self.clone();
6562 let mut last_off = cur + attrs.pos;
6563 while let Some(attr) = attrs.next() {
6564 let Ok(attr) = attr else { break };
6565 match attr {
6566 DlReloadStatsEntry::ReloadStatsLimit(val) => {
6567 if last_off == offset {
6568 stack.push(("ReloadStatsLimit", last_off));
6569 break;
6570 }
6571 }
6572 DlReloadStatsEntry::ReloadStatsValue(val) => {
6573 if last_off == offset {
6574 stack.push(("ReloadStatsValue", last_off));
6575 break;
6576 }
6577 }
6578 _ => {}
6579 };
6580 last_off = cur + attrs.pos;
6581 }
6582 if !stack.is_empty() {
6583 stack.push(("DlReloadStatsEntry", cur));
6584 }
6585 (stack, None)
6586 }
6587}
6588#[derive(Clone)]
6589pub enum DlInfoVersion<'a> {
6590 InfoVersionName(&'a CStr),
6591 InfoVersionValue(&'a CStr),
6592}
6593impl<'a> IterableDlInfoVersion<'a> {
6594 pub fn get_info_version_name(&self) -> Result<&'a CStr, ErrorContext> {
6595 let mut iter = self.clone();
6596 iter.pos = 0;
6597 for attr in iter {
6598 if let Ok(DlInfoVersion::InfoVersionName(val)) = attr {
6599 return Ok(val);
6600 }
6601 }
6602 Err(ErrorContext::new_missing(
6603 "DlInfoVersion",
6604 "InfoVersionName",
6605 self.orig_loc,
6606 self.buf.as_ptr() as usize,
6607 ))
6608 }
6609 pub fn get_info_version_value(&self) -> Result<&'a CStr, ErrorContext> {
6610 let mut iter = self.clone();
6611 iter.pos = 0;
6612 for attr in iter {
6613 if let Ok(DlInfoVersion::InfoVersionValue(val)) = attr {
6614 return Ok(val);
6615 }
6616 }
6617 Err(ErrorContext::new_missing(
6618 "DlInfoVersion",
6619 "InfoVersionValue",
6620 self.orig_loc,
6621 self.buf.as_ptr() as usize,
6622 ))
6623 }
6624}
6625impl DlInfoVersion<'_> {
6626 pub fn new<'a>(buf: &'a [u8]) -> IterableDlInfoVersion<'a> {
6627 IterableDlInfoVersion::with_loc(buf, buf.as_ptr() as usize)
6628 }
6629 fn attr_from_type(r#type: u16) -> Option<&'static str> {
6630 Devlink::attr_from_type(r#type)
6631 }
6632}
6633#[derive(Clone, Copy, Default)]
6634pub struct IterableDlInfoVersion<'a> {
6635 buf: &'a [u8],
6636 pos: usize,
6637 orig_loc: usize,
6638}
6639impl<'a> IterableDlInfoVersion<'a> {
6640 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
6641 Self {
6642 buf,
6643 pos: 0,
6644 orig_loc,
6645 }
6646 }
6647 pub fn get_buf(&self) -> &'a [u8] {
6648 self.buf
6649 }
6650}
6651impl<'a> Iterator for IterableDlInfoVersion<'a> {
6652 type Item = Result<DlInfoVersion<'a>, ErrorContext>;
6653 fn next(&mut self) -> Option<Self::Item> {
6654 let mut pos;
6655 let mut r#type;
6656 loop {
6657 pos = self.pos;
6658 r#type = None;
6659 if self.buf.len() == self.pos {
6660 return None;
6661 }
6662 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
6663 self.pos = self.buf.len();
6664 break;
6665 };
6666 r#type = Some(header.r#type);
6667 let res = match header.r#type {
6668 103u16 => DlInfoVersion::InfoVersionName({
6669 let res = CStr::from_bytes_with_nul(next).ok();
6670 let Some(val) = res else { break };
6671 val
6672 }),
6673 104u16 => DlInfoVersion::InfoVersionValue({
6674 let res = CStr::from_bytes_with_nul(next).ok();
6675 let Some(val) = res else { break };
6676 val
6677 }),
6678 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
6679 n => continue,
6680 };
6681 return Some(Ok(res));
6682 }
6683 Some(Err(ErrorContext::new(
6684 "DlInfoVersion",
6685 r#type.and_then(|t| DlInfoVersion::attr_from_type(t)),
6686 self.orig_loc,
6687 self.buf.as_ptr().wrapping_add(pos) as usize,
6688 )))
6689 }
6690}
6691impl<'a> std::fmt::Debug for IterableDlInfoVersion<'_> {
6692 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6693 let mut fmt = f.debug_struct("DlInfoVersion");
6694 for attr in self.clone() {
6695 let attr = match attr {
6696 Ok(a) => a,
6697 Err(err) => {
6698 fmt.finish()?;
6699 f.write_str("Err(")?;
6700 err.fmt(f)?;
6701 return f.write_str(")");
6702 }
6703 };
6704 match attr {
6705 DlInfoVersion::InfoVersionName(val) => fmt.field("InfoVersionName", &val),
6706 DlInfoVersion::InfoVersionValue(val) => fmt.field("InfoVersionValue", &val),
6707 };
6708 }
6709 fmt.finish()
6710 }
6711}
6712impl IterableDlInfoVersion<'_> {
6713 pub fn lookup_attr(
6714 &self,
6715 offset: usize,
6716 missing_type: Option<u16>,
6717 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
6718 let mut stack = Vec::new();
6719 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
6720 if missing_type.is_some() && cur == offset {
6721 stack.push(("DlInfoVersion", offset));
6722 return (
6723 stack,
6724 missing_type.and_then(|t| DlInfoVersion::attr_from_type(t)),
6725 );
6726 }
6727 if cur > offset || cur + self.buf.len() < offset {
6728 return (stack, None);
6729 }
6730 let mut attrs = self.clone();
6731 let mut last_off = cur + attrs.pos;
6732 while let Some(attr) = attrs.next() {
6733 let Ok(attr) = attr else { break };
6734 match attr {
6735 DlInfoVersion::InfoVersionName(val) => {
6736 if last_off == offset {
6737 stack.push(("InfoVersionName", last_off));
6738 break;
6739 }
6740 }
6741 DlInfoVersion::InfoVersionValue(val) => {
6742 if last_off == offset {
6743 stack.push(("InfoVersionValue", last_off));
6744 break;
6745 }
6746 }
6747 _ => {}
6748 };
6749 last_off = cur + attrs.pos;
6750 }
6751 if !stack.is_empty() {
6752 stack.push(("DlInfoVersion", cur));
6753 }
6754 (stack, None)
6755 }
6756}
6757#[derive(Clone)]
6758pub enum DlPortFunction<'a> {
6759 HwAddr(&'a [u8]),
6760 #[doc = "Associated type: [`PortFnState`] (enum)"]
6761 State(u8),
6762 #[doc = "Associated type: [`PortFnOpstate`] (enum)"]
6763 Opstate(u8),
6764 #[doc = "Associated type: [`PortFnAttrCap`] (1 bit per enumeration)"]
6765 Caps(BuiltinBitfield32),
6766}
6767impl<'a> IterableDlPortFunction<'a> {
6768 pub fn get_hw_addr(&self) -> Result<&'a [u8], ErrorContext> {
6769 let mut iter = self.clone();
6770 iter.pos = 0;
6771 for attr in iter {
6772 if let Ok(DlPortFunction::HwAddr(val)) = attr {
6773 return Ok(val);
6774 }
6775 }
6776 Err(ErrorContext::new_missing(
6777 "DlPortFunction",
6778 "HwAddr",
6779 self.orig_loc,
6780 self.buf.as_ptr() as usize,
6781 ))
6782 }
6783 #[doc = "Associated type: [`PortFnState`] (enum)"]
6784 pub fn get_state(&self) -> Result<u8, ErrorContext> {
6785 let mut iter = self.clone();
6786 iter.pos = 0;
6787 for attr in iter {
6788 if let Ok(DlPortFunction::State(val)) = attr {
6789 return Ok(val);
6790 }
6791 }
6792 Err(ErrorContext::new_missing(
6793 "DlPortFunction",
6794 "State",
6795 self.orig_loc,
6796 self.buf.as_ptr() as usize,
6797 ))
6798 }
6799 #[doc = "Associated type: [`PortFnOpstate`] (enum)"]
6800 pub fn get_opstate(&self) -> Result<u8, ErrorContext> {
6801 let mut iter = self.clone();
6802 iter.pos = 0;
6803 for attr in iter {
6804 if let Ok(DlPortFunction::Opstate(val)) = attr {
6805 return Ok(val);
6806 }
6807 }
6808 Err(ErrorContext::new_missing(
6809 "DlPortFunction",
6810 "Opstate",
6811 self.orig_loc,
6812 self.buf.as_ptr() as usize,
6813 ))
6814 }
6815 #[doc = "Associated type: [`PortFnAttrCap`] (1 bit per enumeration)"]
6816 pub fn get_caps(&self) -> Result<BuiltinBitfield32, ErrorContext> {
6817 let mut iter = self.clone();
6818 iter.pos = 0;
6819 for attr in iter {
6820 if let Ok(DlPortFunction::Caps(val)) = attr {
6821 return Ok(val);
6822 }
6823 }
6824 Err(ErrorContext::new_missing(
6825 "DlPortFunction",
6826 "Caps",
6827 self.orig_loc,
6828 self.buf.as_ptr() as usize,
6829 ))
6830 }
6831}
6832impl DlPortFunction<'_> {
6833 pub fn new<'a>(buf: &'a [u8]) -> IterableDlPortFunction<'a> {
6834 IterableDlPortFunction::with_loc(buf, buf.as_ptr() as usize)
6835 }
6836 fn attr_from_type(r#type: u16) -> Option<&'static str> {
6837 let res = match r#type {
6838 1u16 => "HwAddr",
6839 2u16 => "State",
6840 3u16 => "Opstate",
6841 4u16 => "Caps",
6842 _ => return None,
6843 };
6844 Some(res)
6845 }
6846}
6847#[derive(Clone, Copy, Default)]
6848pub struct IterableDlPortFunction<'a> {
6849 buf: &'a [u8],
6850 pos: usize,
6851 orig_loc: usize,
6852}
6853impl<'a> IterableDlPortFunction<'a> {
6854 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
6855 Self {
6856 buf,
6857 pos: 0,
6858 orig_loc,
6859 }
6860 }
6861 pub fn get_buf(&self) -> &'a [u8] {
6862 self.buf
6863 }
6864}
6865impl<'a> Iterator for IterableDlPortFunction<'a> {
6866 type Item = Result<DlPortFunction<'a>, ErrorContext>;
6867 fn next(&mut self) -> Option<Self::Item> {
6868 let mut pos;
6869 let mut r#type;
6870 loop {
6871 pos = self.pos;
6872 r#type = None;
6873 if self.buf.len() == self.pos {
6874 return None;
6875 }
6876 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
6877 self.pos = self.buf.len();
6878 break;
6879 };
6880 r#type = Some(header.r#type);
6881 let res = match header.r#type {
6882 1u16 => DlPortFunction::HwAddr({
6883 let res = Some(next);
6884 let Some(val) = res else { break };
6885 val
6886 }),
6887 2u16 => DlPortFunction::State({
6888 let res = parse_u8(next);
6889 let Some(val) = res else { break };
6890 val
6891 }),
6892 3u16 => DlPortFunction::Opstate({
6893 let res = parse_u8(next);
6894 let Some(val) = res else { break };
6895 val
6896 }),
6897 4u16 => DlPortFunction::Caps({
6898 let res = BuiltinBitfield32::new_from_slice(next);
6899 let Some(val) = res else { break };
6900 val
6901 }),
6902 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
6903 n => continue,
6904 };
6905 return Some(Ok(res));
6906 }
6907 Some(Err(ErrorContext::new(
6908 "DlPortFunction",
6909 r#type.and_then(|t| DlPortFunction::attr_from_type(t)),
6910 self.orig_loc,
6911 self.buf.as_ptr().wrapping_add(pos) as usize,
6912 )))
6913 }
6914}
6915impl<'a> std::fmt::Debug for IterableDlPortFunction<'_> {
6916 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6917 let mut fmt = f.debug_struct("DlPortFunction");
6918 for attr in self.clone() {
6919 let attr = match attr {
6920 Ok(a) => a,
6921 Err(err) => {
6922 fmt.finish()?;
6923 f.write_str("Err(")?;
6924 err.fmt(f)?;
6925 return f.write_str(")");
6926 }
6927 };
6928 match attr {
6929 DlPortFunction::HwAddr(val) => fmt.field("HwAddr", &val),
6930 DlPortFunction::State(val) => {
6931 fmt.field("State", &FormatEnum(val.into(), PortFnState::from_value))
6932 }
6933 DlPortFunction::Opstate(val) => fmt.field(
6934 "Opstate",
6935 &FormatEnum(val.into(), PortFnOpstate::from_value),
6936 ),
6937 DlPortFunction::Caps(val) => fmt.field(
6938 "Caps",
6939 &FormatFlags(val.value.into(), |val| {
6940 PortFnAttrCap::from_value(val.trailing_zeros().into())
6941 }),
6942 ),
6943 };
6944 }
6945 fmt.finish()
6946 }
6947}
6948impl IterableDlPortFunction<'_> {
6949 pub fn lookup_attr(
6950 &self,
6951 offset: usize,
6952 missing_type: Option<u16>,
6953 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
6954 let mut stack = Vec::new();
6955 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
6956 if missing_type.is_some() && cur == offset {
6957 stack.push(("DlPortFunction", offset));
6958 return (
6959 stack,
6960 missing_type.and_then(|t| DlPortFunction::attr_from_type(t)),
6961 );
6962 }
6963 if cur > offset || cur + self.buf.len() < offset {
6964 return (stack, None);
6965 }
6966 let mut attrs = self.clone();
6967 let mut last_off = cur + attrs.pos;
6968 while let Some(attr) = attrs.next() {
6969 let Ok(attr) = attr else { break };
6970 match attr {
6971 DlPortFunction::HwAddr(val) => {
6972 if last_off == offset {
6973 stack.push(("HwAddr", last_off));
6974 break;
6975 }
6976 }
6977 DlPortFunction::State(val) => {
6978 if last_off == offset {
6979 stack.push(("State", last_off));
6980 break;
6981 }
6982 }
6983 DlPortFunction::Opstate(val) => {
6984 if last_off == offset {
6985 stack.push(("Opstate", last_off));
6986 break;
6987 }
6988 }
6989 DlPortFunction::Caps(val) => {
6990 if last_off == offset {
6991 stack.push(("Caps", last_off));
6992 break;
6993 }
6994 }
6995 _ => {}
6996 };
6997 last_off = cur + attrs.pos;
6998 }
6999 if !stack.is_empty() {
7000 stack.push(("DlPortFunction", cur));
7001 }
7002 (stack, None)
7003 }
7004}
7005#[derive(Clone)]
7006pub enum DlDpipeTables<'a> {
7007 #[doc = "Attribute may repeat multiple times (treat it as array)"]
7008 DpipeTable(IterableDlDpipeTable<'a>),
7009}
7010impl<'a> IterableDlDpipeTables<'a> {
7011 #[doc = "Attribute may repeat multiple times (treat it as array)"]
7012 pub fn get_dpipe_table(
7013 &self,
7014 ) -> MultiAttrIterable<Self, DlDpipeTables<'a>, IterableDlDpipeTable<'a>> {
7015 MultiAttrIterable::new(self.clone(), |variant| {
7016 if let DlDpipeTables::DpipeTable(val) = variant {
7017 Some(val)
7018 } else {
7019 None
7020 }
7021 })
7022 }
7023}
7024impl DlDpipeTables<'_> {
7025 pub fn new<'a>(buf: &'a [u8]) -> IterableDlDpipeTables<'a> {
7026 IterableDlDpipeTables::with_loc(buf, buf.as_ptr() as usize)
7027 }
7028 fn attr_from_type(r#type: u16) -> Option<&'static str> {
7029 Devlink::attr_from_type(r#type)
7030 }
7031}
7032#[derive(Clone, Copy, Default)]
7033pub struct IterableDlDpipeTables<'a> {
7034 buf: &'a [u8],
7035 pos: usize,
7036 orig_loc: usize,
7037}
7038impl<'a> IterableDlDpipeTables<'a> {
7039 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
7040 Self {
7041 buf,
7042 pos: 0,
7043 orig_loc,
7044 }
7045 }
7046 pub fn get_buf(&self) -> &'a [u8] {
7047 self.buf
7048 }
7049}
7050impl<'a> Iterator for IterableDlDpipeTables<'a> {
7051 type Item = Result<DlDpipeTables<'a>, ErrorContext>;
7052 fn next(&mut self) -> Option<Self::Item> {
7053 let mut pos;
7054 let mut r#type;
7055 loop {
7056 pos = self.pos;
7057 r#type = None;
7058 if self.buf.len() == self.pos {
7059 return None;
7060 }
7061 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
7062 self.pos = self.buf.len();
7063 break;
7064 };
7065 r#type = Some(header.r#type);
7066 let res = match header.r#type {
7067 28u16 => DlDpipeTables::DpipeTable({
7068 let res = Some(IterableDlDpipeTable::with_loc(next, self.orig_loc));
7069 let Some(val) = res else { break };
7070 val
7071 }),
7072 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
7073 n => continue,
7074 };
7075 return Some(Ok(res));
7076 }
7077 Some(Err(ErrorContext::new(
7078 "DlDpipeTables",
7079 r#type.and_then(|t| DlDpipeTables::attr_from_type(t)),
7080 self.orig_loc,
7081 self.buf.as_ptr().wrapping_add(pos) as usize,
7082 )))
7083 }
7084}
7085impl<'a> std::fmt::Debug for IterableDlDpipeTables<'_> {
7086 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7087 let mut fmt = f.debug_struct("DlDpipeTables");
7088 for attr in self.clone() {
7089 let attr = match attr {
7090 Ok(a) => a,
7091 Err(err) => {
7092 fmt.finish()?;
7093 f.write_str("Err(")?;
7094 err.fmt(f)?;
7095 return f.write_str(")");
7096 }
7097 };
7098 match attr {
7099 DlDpipeTables::DpipeTable(val) => fmt.field("DpipeTable", &val),
7100 };
7101 }
7102 fmt.finish()
7103 }
7104}
7105impl IterableDlDpipeTables<'_> {
7106 pub fn lookup_attr(
7107 &self,
7108 offset: usize,
7109 missing_type: Option<u16>,
7110 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
7111 let mut stack = Vec::new();
7112 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
7113 if missing_type.is_some() && cur == offset {
7114 stack.push(("DlDpipeTables", offset));
7115 return (
7116 stack,
7117 missing_type.and_then(|t| DlDpipeTables::attr_from_type(t)),
7118 );
7119 }
7120 if cur > offset || cur + self.buf.len() < offset {
7121 return (stack, None);
7122 }
7123 let mut attrs = self.clone();
7124 let mut last_off = cur + attrs.pos;
7125 let mut missing = None;
7126 while let Some(attr) = attrs.next() {
7127 let Ok(attr) = attr else { break };
7128 match attr {
7129 DlDpipeTables::DpipeTable(val) => {
7130 (stack, missing) = val.lookup_attr(offset, missing_type);
7131 if !stack.is_empty() {
7132 break;
7133 }
7134 }
7135 _ => {}
7136 };
7137 last_off = cur + attrs.pos;
7138 }
7139 if !stack.is_empty() {
7140 stack.push(("DlDpipeTables", cur));
7141 }
7142 (stack, missing)
7143 }
7144}
7145#[derive(Clone)]
7146pub enum DlDpipeTable<'a> {
7147 DpipeTableName(&'a CStr),
7148 DpipeTableSize(u64),
7149 DpipeTableMatches(IterableDlDpipeTableMatches<'a>),
7150 DpipeTableActions(IterableDlDpipeTableActions<'a>),
7151 DpipeTableCountersEnabled(u8),
7152 DpipeTableResourceId(u64),
7153 DpipeTableResourceUnits(u64),
7154}
7155impl<'a> IterableDlDpipeTable<'a> {
7156 pub fn get_dpipe_table_name(&self) -> Result<&'a CStr, ErrorContext> {
7157 let mut iter = self.clone();
7158 iter.pos = 0;
7159 for attr in iter {
7160 if let Ok(DlDpipeTable::DpipeTableName(val)) = attr {
7161 return Ok(val);
7162 }
7163 }
7164 Err(ErrorContext::new_missing(
7165 "DlDpipeTable",
7166 "DpipeTableName",
7167 self.orig_loc,
7168 self.buf.as_ptr() as usize,
7169 ))
7170 }
7171 pub fn get_dpipe_table_size(&self) -> Result<u64, ErrorContext> {
7172 let mut iter = self.clone();
7173 iter.pos = 0;
7174 for attr in iter {
7175 if let Ok(DlDpipeTable::DpipeTableSize(val)) = attr {
7176 return Ok(val);
7177 }
7178 }
7179 Err(ErrorContext::new_missing(
7180 "DlDpipeTable",
7181 "DpipeTableSize",
7182 self.orig_loc,
7183 self.buf.as_ptr() as usize,
7184 ))
7185 }
7186 pub fn get_dpipe_table_matches(&self) -> Result<IterableDlDpipeTableMatches<'a>, ErrorContext> {
7187 let mut iter = self.clone();
7188 iter.pos = 0;
7189 for attr in iter {
7190 if let Ok(DlDpipeTable::DpipeTableMatches(val)) = attr {
7191 return Ok(val);
7192 }
7193 }
7194 Err(ErrorContext::new_missing(
7195 "DlDpipeTable",
7196 "DpipeTableMatches",
7197 self.orig_loc,
7198 self.buf.as_ptr() as usize,
7199 ))
7200 }
7201 pub fn get_dpipe_table_actions(&self) -> Result<IterableDlDpipeTableActions<'a>, ErrorContext> {
7202 let mut iter = self.clone();
7203 iter.pos = 0;
7204 for attr in iter {
7205 if let Ok(DlDpipeTable::DpipeTableActions(val)) = attr {
7206 return Ok(val);
7207 }
7208 }
7209 Err(ErrorContext::new_missing(
7210 "DlDpipeTable",
7211 "DpipeTableActions",
7212 self.orig_loc,
7213 self.buf.as_ptr() as usize,
7214 ))
7215 }
7216 pub fn get_dpipe_table_counters_enabled(&self) -> Result<u8, ErrorContext> {
7217 let mut iter = self.clone();
7218 iter.pos = 0;
7219 for attr in iter {
7220 if let Ok(DlDpipeTable::DpipeTableCountersEnabled(val)) = attr {
7221 return Ok(val);
7222 }
7223 }
7224 Err(ErrorContext::new_missing(
7225 "DlDpipeTable",
7226 "DpipeTableCountersEnabled",
7227 self.orig_loc,
7228 self.buf.as_ptr() as usize,
7229 ))
7230 }
7231 pub fn get_dpipe_table_resource_id(&self) -> Result<u64, ErrorContext> {
7232 let mut iter = self.clone();
7233 iter.pos = 0;
7234 for attr in iter {
7235 if let Ok(DlDpipeTable::DpipeTableResourceId(val)) = attr {
7236 return Ok(val);
7237 }
7238 }
7239 Err(ErrorContext::new_missing(
7240 "DlDpipeTable",
7241 "DpipeTableResourceId",
7242 self.orig_loc,
7243 self.buf.as_ptr() as usize,
7244 ))
7245 }
7246 pub fn get_dpipe_table_resource_units(&self) -> Result<u64, ErrorContext> {
7247 let mut iter = self.clone();
7248 iter.pos = 0;
7249 for attr in iter {
7250 if let Ok(DlDpipeTable::DpipeTableResourceUnits(val)) = attr {
7251 return Ok(val);
7252 }
7253 }
7254 Err(ErrorContext::new_missing(
7255 "DlDpipeTable",
7256 "DpipeTableResourceUnits",
7257 self.orig_loc,
7258 self.buf.as_ptr() as usize,
7259 ))
7260 }
7261}
7262impl DlDpipeTable<'_> {
7263 pub fn new<'a>(buf: &'a [u8]) -> IterableDlDpipeTable<'a> {
7264 IterableDlDpipeTable::with_loc(buf, buf.as_ptr() as usize)
7265 }
7266 fn attr_from_type(r#type: u16) -> Option<&'static str> {
7267 Devlink::attr_from_type(r#type)
7268 }
7269}
7270#[derive(Clone, Copy, Default)]
7271pub struct IterableDlDpipeTable<'a> {
7272 buf: &'a [u8],
7273 pos: usize,
7274 orig_loc: usize,
7275}
7276impl<'a> IterableDlDpipeTable<'a> {
7277 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
7278 Self {
7279 buf,
7280 pos: 0,
7281 orig_loc,
7282 }
7283 }
7284 pub fn get_buf(&self) -> &'a [u8] {
7285 self.buf
7286 }
7287}
7288impl<'a> Iterator for IterableDlDpipeTable<'a> {
7289 type Item = Result<DlDpipeTable<'a>, ErrorContext>;
7290 fn next(&mut self) -> Option<Self::Item> {
7291 let mut pos;
7292 let mut r#type;
7293 loop {
7294 pos = self.pos;
7295 r#type = None;
7296 if self.buf.len() == self.pos {
7297 return None;
7298 }
7299 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
7300 self.pos = self.buf.len();
7301 break;
7302 };
7303 r#type = Some(header.r#type);
7304 let res = match header.r#type {
7305 29u16 => DlDpipeTable::DpipeTableName({
7306 let res = CStr::from_bytes_with_nul(next).ok();
7307 let Some(val) = res else { break };
7308 val
7309 }),
7310 30u16 => DlDpipeTable::DpipeTableSize({
7311 let res = parse_u64(next);
7312 let Some(val) = res else { break };
7313 val
7314 }),
7315 31u16 => DlDpipeTable::DpipeTableMatches({
7316 let res = Some(IterableDlDpipeTableMatches::with_loc(next, self.orig_loc));
7317 let Some(val) = res else { break };
7318 val
7319 }),
7320 32u16 => DlDpipeTable::DpipeTableActions({
7321 let res = Some(IterableDlDpipeTableActions::with_loc(next, self.orig_loc));
7322 let Some(val) = res else { break };
7323 val
7324 }),
7325 33u16 => DlDpipeTable::DpipeTableCountersEnabled({
7326 let res = parse_u8(next);
7327 let Some(val) = res else { break };
7328 val
7329 }),
7330 75u16 => DlDpipeTable::DpipeTableResourceId({
7331 let res = parse_u64(next);
7332 let Some(val) = res else { break };
7333 val
7334 }),
7335 76u16 => DlDpipeTable::DpipeTableResourceUnits({
7336 let res = parse_u64(next);
7337 let Some(val) = res else { break };
7338 val
7339 }),
7340 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
7341 n => continue,
7342 };
7343 return Some(Ok(res));
7344 }
7345 Some(Err(ErrorContext::new(
7346 "DlDpipeTable",
7347 r#type.and_then(|t| DlDpipeTable::attr_from_type(t)),
7348 self.orig_loc,
7349 self.buf.as_ptr().wrapping_add(pos) as usize,
7350 )))
7351 }
7352}
7353impl<'a> std::fmt::Debug for IterableDlDpipeTable<'_> {
7354 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7355 let mut fmt = f.debug_struct("DlDpipeTable");
7356 for attr in self.clone() {
7357 let attr = match attr {
7358 Ok(a) => a,
7359 Err(err) => {
7360 fmt.finish()?;
7361 f.write_str("Err(")?;
7362 err.fmt(f)?;
7363 return f.write_str(")");
7364 }
7365 };
7366 match attr {
7367 DlDpipeTable::DpipeTableName(val) => fmt.field("DpipeTableName", &val),
7368 DlDpipeTable::DpipeTableSize(val) => fmt.field("DpipeTableSize", &val),
7369 DlDpipeTable::DpipeTableMatches(val) => fmt.field("DpipeTableMatches", &val),
7370 DlDpipeTable::DpipeTableActions(val) => fmt.field("DpipeTableActions", &val),
7371 DlDpipeTable::DpipeTableCountersEnabled(val) => {
7372 fmt.field("DpipeTableCountersEnabled", &val)
7373 }
7374 DlDpipeTable::DpipeTableResourceId(val) => fmt.field("DpipeTableResourceId", &val),
7375 DlDpipeTable::DpipeTableResourceUnits(val) => {
7376 fmt.field("DpipeTableResourceUnits", &val)
7377 }
7378 };
7379 }
7380 fmt.finish()
7381 }
7382}
7383impl IterableDlDpipeTable<'_> {
7384 pub fn lookup_attr(
7385 &self,
7386 offset: usize,
7387 missing_type: Option<u16>,
7388 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
7389 let mut stack = Vec::new();
7390 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
7391 if missing_type.is_some() && cur == offset {
7392 stack.push(("DlDpipeTable", offset));
7393 return (
7394 stack,
7395 missing_type.and_then(|t| DlDpipeTable::attr_from_type(t)),
7396 );
7397 }
7398 if cur > offset || cur + self.buf.len() < offset {
7399 return (stack, None);
7400 }
7401 let mut attrs = self.clone();
7402 let mut last_off = cur + attrs.pos;
7403 let mut missing = None;
7404 while let Some(attr) = attrs.next() {
7405 let Ok(attr) = attr else { break };
7406 match attr {
7407 DlDpipeTable::DpipeTableName(val) => {
7408 if last_off == offset {
7409 stack.push(("DpipeTableName", last_off));
7410 break;
7411 }
7412 }
7413 DlDpipeTable::DpipeTableSize(val) => {
7414 if last_off == offset {
7415 stack.push(("DpipeTableSize", last_off));
7416 break;
7417 }
7418 }
7419 DlDpipeTable::DpipeTableMatches(val) => {
7420 (stack, missing) = val.lookup_attr(offset, missing_type);
7421 if !stack.is_empty() {
7422 break;
7423 }
7424 }
7425 DlDpipeTable::DpipeTableActions(val) => {
7426 (stack, missing) = val.lookup_attr(offset, missing_type);
7427 if !stack.is_empty() {
7428 break;
7429 }
7430 }
7431 DlDpipeTable::DpipeTableCountersEnabled(val) => {
7432 if last_off == offset {
7433 stack.push(("DpipeTableCountersEnabled", last_off));
7434 break;
7435 }
7436 }
7437 DlDpipeTable::DpipeTableResourceId(val) => {
7438 if last_off == offset {
7439 stack.push(("DpipeTableResourceId", last_off));
7440 break;
7441 }
7442 }
7443 DlDpipeTable::DpipeTableResourceUnits(val) => {
7444 if last_off == offset {
7445 stack.push(("DpipeTableResourceUnits", last_off));
7446 break;
7447 }
7448 }
7449 _ => {}
7450 };
7451 last_off = cur + attrs.pos;
7452 }
7453 if !stack.is_empty() {
7454 stack.push(("DlDpipeTable", cur));
7455 }
7456 (stack, missing)
7457 }
7458}
7459#[derive(Clone)]
7460pub enum DlDpipeTableMatches<'a> {
7461 #[doc = "Attribute may repeat multiple times (treat it as array)"]
7462 DpipeMatch(IterableDlDpipeMatch<'a>),
7463}
7464impl<'a> IterableDlDpipeTableMatches<'a> {
7465 #[doc = "Attribute may repeat multiple times (treat it as array)"]
7466 pub fn get_dpipe_match(
7467 &self,
7468 ) -> MultiAttrIterable<Self, DlDpipeTableMatches<'a>, IterableDlDpipeMatch<'a>> {
7469 MultiAttrIterable::new(self.clone(), |variant| {
7470 if let DlDpipeTableMatches::DpipeMatch(val) = variant {
7471 Some(val)
7472 } else {
7473 None
7474 }
7475 })
7476 }
7477}
7478impl DlDpipeTableMatches<'_> {
7479 pub fn new<'a>(buf: &'a [u8]) -> IterableDlDpipeTableMatches<'a> {
7480 IterableDlDpipeTableMatches::with_loc(buf, buf.as_ptr() as usize)
7481 }
7482 fn attr_from_type(r#type: u16) -> Option<&'static str> {
7483 Devlink::attr_from_type(r#type)
7484 }
7485}
7486#[derive(Clone, Copy, Default)]
7487pub struct IterableDlDpipeTableMatches<'a> {
7488 buf: &'a [u8],
7489 pos: usize,
7490 orig_loc: usize,
7491}
7492impl<'a> IterableDlDpipeTableMatches<'a> {
7493 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
7494 Self {
7495 buf,
7496 pos: 0,
7497 orig_loc,
7498 }
7499 }
7500 pub fn get_buf(&self) -> &'a [u8] {
7501 self.buf
7502 }
7503}
7504impl<'a> Iterator for IterableDlDpipeTableMatches<'a> {
7505 type Item = Result<DlDpipeTableMatches<'a>, ErrorContext>;
7506 fn next(&mut self) -> Option<Self::Item> {
7507 let mut pos;
7508 let mut r#type;
7509 loop {
7510 pos = self.pos;
7511 r#type = None;
7512 if self.buf.len() == self.pos {
7513 return None;
7514 }
7515 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
7516 self.pos = self.buf.len();
7517 break;
7518 };
7519 r#type = Some(header.r#type);
7520 let res = match header.r#type {
7521 40u16 => DlDpipeTableMatches::DpipeMatch({
7522 let res = Some(IterableDlDpipeMatch::with_loc(next, self.orig_loc));
7523 let Some(val) = res else { break };
7524 val
7525 }),
7526 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
7527 n => continue,
7528 };
7529 return Some(Ok(res));
7530 }
7531 Some(Err(ErrorContext::new(
7532 "DlDpipeTableMatches",
7533 r#type.and_then(|t| DlDpipeTableMatches::attr_from_type(t)),
7534 self.orig_loc,
7535 self.buf.as_ptr().wrapping_add(pos) as usize,
7536 )))
7537 }
7538}
7539impl<'a> std::fmt::Debug for IterableDlDpipeTableMatches<'_> {
7540 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7541 let mut fmt = f.debug_struct("DlDpipeTableMatches");
7542 for attr in self.clone() {
7543 let attr = match attr {
7544 Ok(a) => a,
7545 Err(err) => {
7546 fmt.finish()?;
7547 f.write_str("Err(")?;
7548 err.fmt(f)?;
7549 return f.write_str(")");
7550 }
7551 };
7552 match attr {
7553 DlDpipeTableMatches::DpipeMatch(val) => fmt.field("DpipeMatch", &val),
7554 };
7555 }
7556 fmt.finish()
7557 }
7558}
7559impl IterableDlDpipeTableMatches<'_> {
7560 pub fn lookup_attr(
7561 &self,
7562 offset: usize,
7563 missing_type: Option<u16>,
7564 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
7565 let mut stack = Vec::new();
7566 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
7567 if missing_type.is_some() && cur == offset {
7568 stack.push(("DlDpipeTableMatches", offset));
7569 return (
7570 stack,
7571 missing_type.and_then(|t| DlDpipeTableMatches::attr_from_type(t)),
7572 );
7573 }
7574 if cur > offset || cur + self.buf.len() < offset {
7575 return (stack, None);
7576 }
7577 let mut attrs = self.clone();
7578 let mut last_off = cur + attrs.pos;
7579 let mut missing = None;
7580 while let Some(attr) = attrs.next() {
7581 let Ok(attr) = attr else { break };
7582 match attr {
7583 DlDpipeTableMatches::DpipeMatch(val) => {
7584 (stack, missing) = val.lookup_attr(offset, missing_type);
7585 if !stack.is_empty() {
7586 break;
7587 }
7588 }
7589 _ => {}
7590 };
7591 last_off = cur + attrs.pos;
7592 }
7593 if !stack.is_empty() {
7594 stack.push(("DlDpipeTableMatches", cur));
7595 }
7596 (stack, missing)
7597 }
7598}
7599#[derive(Clone)]
7600pub enum DlDpipeTableActions<'a> {
7601 #[doc = "Attribute may repeat multiple times (treat it as array)"]
7602 DpipeAction(IterableDlDpipeAction<'a>),
7603}
7604impl<'a> IterableDlDpipeTableActions<'a> {
7605 #[doc = "Attribute may repeat multiple times (treat it as array)"]
7606 pub fn get_dpipe_action(
7607 &self,
7608 ) -> MultiAttrIterable<Self, DlDpipeTableActions<'a>, IterableDlDpipeAction<'a>> {
7609 MultiAttrIterable::new(self.clone(), |variant| {
7610 if let DlDpipeTableActions::DpipeAction(val) = variant {
7611 Some(val)
7612 } else {
7613 None
7614 }
7615 })
7616 }
7617}
7618impl DlDpipeTableActions<'_> {
7619 pub fn new<'a>(buf: &'a [u8]) -> IterableDlDpipeTableActions<'a> {
7620 IterableDlDpipeTableActions::with_loc(buf, buf.as_ptr() as usize)
7621 }
7622 fn attr_from_type(r#type: u16) -> Option<&'static str> {
7623 Devlink::attr_from_type(r#type)
7624 }
7625}
7626#[derive(Clone, Copy, Default)]
7627pub struct IterableDlDpipeTableActions<'a> {
7628 buf: &'a [u8],
7629 pos: usize,
7630 orig_loc: usize,
7631}
7632impl<'a> IterableDlDpipeTableActions<'a> {
7633 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
7634 Self {
7635 buf,
7636 pos: 0,
7637 orig_loc,
7638 }
7639 }
7640 pub fn get_buf(&self) -> &'a [u8] {
7641 self.buf
7642 }
7643}
7644impl<'a> Iterator for IterableDlDpipeTableActions<'a> {
7645 type Item = Result<DlDpipeTableActions<'a>, ErrorContext>;
7646 fn next(&mut self) -> Option<Self::Item> {
7647 let mut pos;
7648 let mut r#type;
7649 loop {
7650 pos = self.pos;
7651 r#type = None;
7652 if self.buf.len() == self.pos {
7653 return None;
7654 }
7655 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
7656 self.pos = self.buf.len();
7657 break;
7658 };
7659 r#type = Some(header.r#type);
7660 let res = match header.r#type {
7661 43u16 => DlDpipeTableActions::DpipeAction({
7662 let res = Some(IterableDlDpipeAction::with_loc(next, self.orig_loc));
7663 let Some(val) = res else { break };
7664 val
7665 }),
7666 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
7667 n => continue,
7668 };
7669 return Some(Ok(res));
7670 }
7671 Some(Err(ErrorContext::new(
7672 "DlDpipeTableActions",
7673 r#type.and_then(|t| DlDpipeTableActions::attr_from_type(t)),
7674 self.orig_loc,
7675 self.buf.as_ptr().wrapping_add(pos) as usize,
7676 )))
7677 }
7678}
7679impl<'a> std::fmt::Debug for IterableDlDpipeTableActions<'_> {
7680 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7681 let mut fmt = f.debug_struct("DlDpipeTableActions");
7682 for attr in self.clone() {
7683 let attr = match attr {
7684 Ok(a) => a,
7685 Err(err) => {
7686 fmt.finish()?;
7687 f.write_str("Err(")?;
7688 err.fmt(f)?;
7689 return f.write_str(")");
7690 }
7691 };
7692 match attr {
7693 DlDpipeTableActions::DpipeAction(val) => fmt.field("DpipeAction", &val),
7694 };
7695 }
7696 fmt.finish()
7697 }
7698}
7699impl IterableDlDpipeTableActions<'_> {
7700 pub fn lookup_attr(
7701 &self,
7702 offset: usize,
7703 missing_type: Option<u16>,
7704 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
7705 let mut stack = Vec::new();
7706 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
7707 if missing_type.is_some() && cur == offset {
7708 stack.push(("DlDpipeTableActions", offset));
7709 return (
7710 stack,
7711 missing_type.and_then(|t| DlDpipeTableActions::attr_from_type(t)),
7712 );
7713 }
7714 if cur > offset || cur + self.buf.len() < offset {
7715 return (stack, None);
7716 }
7717 let mut attrs = self.clone();
7718 let mut last_off = cur + attrs.pos;
7719 let mut missing = None;
7720 while let Some(attr) = attrs.next() {
7721 let Ok(attr) = attr else { break };
7722 match attr {
7723 DlDpipeTableActions::DpipeAction(val) => {
7724 (stack, missing) = val.lookup_attr(offset, missing_type);
7725 if !stack.is_empty() {
7726 break;
7727 }
7728 }
7729 _ => {}
7730 };
7731 last_off = cur + attrs.pos;
7732 }
7733 if !stack.is_empty() {
7734 stack.push(("DlDpipeTableActions", cur));
7735 }
7736 (stack, missing)
7737 }
7738}
7739#[derive(Clone)]
7740pub enum DlDpipeEntries<'a> {
7741 #[doc = "Attribute may repeat multiple times (treat it as array)"]
7742 DpipeEntry(IterableDlDpipeEntry<'a>),
7743}
7744impl<'a> IterableDlDpipeEntries<'a> {
7745 #[doc = "Attribute may repeat multiple times (treat it as array)"]
7746 pub fn get_dpipe_entry(
7747 &self,
7748 ) -> MultiAttrIterable<Self, DlDpipeEntries<'a>, IterableDlDpipeEntry<'a>> {
7749 MultiAttrIterable::new(self.clone(), |variant| {
7750 if let DlDpipeEntries::DpipeEntry(val) = variant {
7751 Some(val)
7752 } else {
7753 None
7754 }
7755 })
7756 }
7757}
7758impl DlDpipeEntries<'_> {
7759 pub fn new<'a>(buf: &'a [u8]) -> IterableDlDpipeEntries<'a> {
7760 IterableDlDpipeEntries::with_loc(buf, buf.as_ptr() as usize)
7761 }
7762 fn attr_from_type(r#type: u16) -> Option<&'static str> {
7763 Devlink::attr_from_type(r#type)
7764 }
7765}
7766#[derive(Clone, Copy, Default)]
7767pub struct IterableDlDpipeEntries<'a> {
7768 buf: &'a [u8],
7769 pos: usize,
7770 orig_loc: usize,
7771}
7772impl<'a> IterableDlDpipeEntries<'a> {
7773 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
7774 Self {
7775 buf,
7776 pos: 0,
7777 orig_loc,
7778 }
7779 }
7780 pub fn get_buf(&self) -> &'a [u8] {
7781 self.buf
7782 }
7783}
7784impl<'a> Iterator for IterableDlDpipeEntries<'a> {
7785 type Item = Result<DlDpipeEntries<'a>, ErrorContext>;
7786 fn next(&mut self) -> Option<Self::Item> {
7787 let mut pos;
7788 let mut r#type;
7789 loop {
7790 pos = self.pos;
7791 r#type = None;
7792 if self.buf.len() == self.pos {
7793 return None;
7794 }
7795 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
7796 self.pos = self.buf.len();
7797 break;
7798 };
7799 r#type = Some(header.r#type);
7800 let res = match header.r#type {
7801 35u16 => DlDpipeEntries::DpipeEntry({
7802 let res = Some(IterableDlDpipeEntry::with_loc(next, self.orig_loc));
7803 let Some(val) = res else { break };
7804 val
7805 }),
7806 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
7807 n => continue,
7808 };
7809 return Some(Ok(res));
7810 }
7811 Some(Err(ErrorContext::new(
7812 "DlDpipeEntries",
7813 r#type.and_then(|t| DlDpipeEntries::attr_from_type(t)),
7814 self.orig_loc,
7815 self.buf.as_ptr().wrapping_add(pos) as usize,
7816 )))
7817 }
7818}
7819impl<'a> std::fmt::Debug for IterableDlDpipeEntries<'_> {
7820 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7821 let mut fmt = f.debug_struct("DlDpipeEntries");
7822 for attr in self.clone() {
7823 let attr = match attr {
7824 Ok(a) => a,
7825 Err(err) => {
7826 fmt.finish()?;
7827 f.write_str("Err(")?;
7828 err.fmt(f)?;
7829 return f.write_str(")");
7830 }
7831 };
7832 match attr {
7833 DlDpipeEntries::DpipeEntry(val) => fmt.field("DpipeEntry", &val),
7834 };
7835 }
7836 fmt.finish()
7837 }
7838}
7839impl IterableDlDpipeEntries<'_> {
7840 pub fn lookup_attr(
7841 &self,
7842 offset: usize,
7843 missing_type: Option<u16>,
7844 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
7845 let mut stack = Vec::new();
7846 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
7847 if missing_type.is_some() && cur == offset {
7848 stack.push(("DlDpipeEntries", offset));
7849 return (
7850 stack,
7851 missing_type.and_then(|t| DlDpipeEntries::attr_from_type(t)),
7852 );
7853 }
7854 if cur > offset || cur + self.buf.len() < offset {
7855 return (stack, None);
7856 }
7857 let mut attrs = self.clone();
7858 let mut last_off = cur + attrs.pos;
7859 let mut missing = None;
7860 while let Some(attr) = attrs.next() {
7861 let Ok(attr) = attr else { break };
7862 match attr {
7863 DlDpipeEntries::DpipeEntry(val) => {
7864 (stack, missing) = val.lookup_attr(offset, missing_type);
7865 if !stack.is_empty() {
7866 break;
7867 }
7868 }
7869 _ => {}
7870 };
7871 last_off = cur + attrs.pos;
7872 }
7873 if !stack.is_empty() {
7874 stack.push(("DlDpipeEntries", cur));
7875 }
7876 (stack, missing)
7877 }
7878}
7879#[derive(Clone)]
7880pub enum DlDpipeEntry<'a> {
7881 DpipeEntryIndex(u64),
7882 DpipeEntryMatchValues(IterableDlDpipeEntryMatchValues<'a>),
7883 DpipeEntryActionValues(IterableDlDpipeEntryActionValues<'a>),
7884 DpipeEntryCounter(u64),
7885}
7886impl<'a> IterableDlDpipeEntry<'a> {
7887 pub fn get_dpipe_entry_index(&self) -> Result<u64, ErrorContext> {
7888 let mut iter = self.clone();
7889 iter.pos = 0;
7890 for attr in iter {
7891 if let Ok(DlDpipeEntry::DpipeEntryIndex(val)) = attr {
7892 return Ok(val);
7893 }
7894 }
7895 Err(ErrorContext::new_missing(
7896 "DlDpipeEntry",
7897 "DpipeEntryIndex",
7898 self.orig_loc,
7899 self.buf.as_ptr() as usize,
7900 ))
7901 }
7902 pub fn get_dpipe_entry_match_values(
7903 &self,
7904 ) -> Result<IterableDlDpipeEntryMatchValues<'a>, ErrorContext> {
7905 let mut iter = self.clone();
7906 iter.pos = 0;
7907 for attr in iter {
7908 if let Ok(DlDpipeEntry::DpipeEntryMatchValues(val)) = attr {
7909 return Ok(val);
7910 }
7911 }
7912 Err(ErrorContext::new_missing(
7913 "DlDpipeEntry",
7914 "DpipeEntryMatchValues",
7915 self.orig_loc,
7916 self.buf.as_ptr() as usize,
7917 ))
7918 }
7919 pub fn get_dpipe_entry_action_values(
7920 &self,
7921 ) -> Result<IterableDlDpipeEntryActionValues<'a>, ErrorContext> {
7922 let mut iter = self.clone();
7923 iter.pos = 0;
7924 for attr in iter {
7925 if let Ok(DlDpipeEntry::DpipeEntryActionValues(val)) = attr {
7926 return Ok(val);
7927 }
7928 }
7929 Err(ErrorContext::new_missing(
7930 "DlDpipeEntry",
7931 "DpipeEntryActionValues",
7932 self.orig_loc,
7933 self.buf.as_ptr() as usize,
7934 ))
7935 }
7936 pub fn get_dpipe_entry_counter(&self) -> Result<u64, ErrorContext> {
7937 let mut iter = self.clone();
7938 iter.pos = 0;
7939 for attr in iter {
7940 if let Ok(DlDpipeEntry::DpipeEntryCounter(val)) = attr {
7941 return Ok(val);
7942 }
7943 }
7944 Err(ErrorContext::new_missing(
7945 "DlDpipeEntry",
7946 "DpipeEntryCounter",
7947 self.orig_loc,
7948 self.buf.as_ptr() as usize,
7949 ))
7950 }
7951}
7952impl DlDpipeEntry<'_> {
7953 pub fn new<'a>(buf: &'a [u8]) -> IterableDlDpipeEntry<'a> {
7954 IterableDlDpipeEntry::with_loc(buf, buf.as_ptr() as usize)
7955 }
7956 fn attr_from_type(r#type: u16) -> Option<&'static str> {
7957 Devlink::attr_from_type(r#type)
7958 }
7959}
7960#[derive(Clone, Copy, Default)]
7961pub struct IterableDlDpipeEntry<'a> {
7962 buf: &'a [u8],
7963 pos: usize,
7964 orig_loc: usize,
7965}
7966impl<'a> IterableDlDpipeEntry<'a> {
7967 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
7968 Self {
7969 buf,
7970 pos: 0,
7971 orig_loc,
7972 }
7973 }
7974 pub fn get_buf(&self) -> &'a [u8] {
7975 self.buf
7976 }
7977}
7978impl<'a> Iterator for IterableDlDpipeEntry<'a> {
7979 type Item = Result<DlDpipeEntry<'a>, ErrorContext>;
7980 fn next(&mut self) -> Option<Self::Item> {
7981 let mut pos;
7982 let mut r#type;
7983 loop {
7984 pos = self.pos;
7985 r#type = None;
7986 if self.buf.len() == self.pos {
7987 return None;
7988 }
7989 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
7990 self.pos = self.buf.len();
7991 break;
7992 };
7993 r#type = Some(header.r#type);
7994 let res = match header.r#type {
7995 36u16 => DlDpipeEntry::DpipeEntryIndex({
7996 let res = parse_u64(next);
7997 let Some(val) = res else { break };
7998 val
7999 }),
8000 37u16 => DlDpipeEntry::DpipeEntryMatchValues({
8001 let res = Some(IterableDlDpipeEntryMatchValues::with_loc(
8002 next,
8003 self.orig_loc,
8004 ));
8005 let Some(val) = res else { break };
8006 val
8007 }),
8008 38u16 => DlDpipeEntry::DpipeEntryActionValues({
8009 let res = Some(IterableDlDpipeEntryActionValues::with_loc(
8010 next,
8011 self.orig_loc,
8012 ));
8013 let Some(val) = res else { break };
8014 val
8015 }),
8016 39u16 => DlDpipeEntry::DpipeEntryCounter({
8017 let res = parse_u64(next);
8018 let Some(val) = res else { break };
8019 val
8020 }),
8021 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
8022 n => continue,
8023 };
8024 return Some(Ok(res));
8025 }
8026 Some(Err(ErrorContext::new(
8027 "DlDpipeEntry",
8028 r#type.and_then(|t| DlDpipeEntry::attr_from_type(t)),
8029 self.orig_loc,
8030 self.buf.as_ptr().wrapping_add(pos) as usize,
8031 )))
8032 }
8033}
8034impl<'a> std::fmt::Debug for IterableDlDpipeEntry<'_> {
8035 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8036 let mut fmt = f.debug_struct("DlDpipeEntry");
8037 for attr in self.clone() {
8038 let attr = match attr {
8039 Ok(a) => a,
8040 Err(err) => {
8041 fmt.finish()?;
8042 f.write_str("Err(")?;
8043 err.fmt(f)?;
8044 return f.write_str(")");
8045 }
8046 };
8047 match attr {
8048 DlDpipeEntry::DpipeEntryIndex(val) => fmt.field("DpipeEntryIndex", &val),
8049 DlDpipeEntry::DpipeEntryMatchValues(val) => {
8050 fmt.field("DpipeEntryMatchValues", &val)
8051 }
8052 DlDpipeEntry::DpipeEntryActionValues(val) => {
8053 fmt.field("DpipeEntryActionValues", &val)
8054 }
8055 DlDpipeEntry::DpipeEntryCounter(val) => fmt.field("DpipeEntryCounter", &val),
8056 };
8057 }
8058 fmt.finish()
8059 }
8060}
8061impl IterableDlDpipeEntry<'_> {
8062 pub fn lookup_attr(
8063 &self,
8064 offset: usize,
8065 missing_type: Option<u16>,
8066 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
8067 let mut stack = Vec::new();
8068 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
8069 if missing_type.is_some() && cur == offset {
8070 stack.push(("DlDpipeEntry", offset));
8071 return (
8072 stack,
8073 missing_type.and_then(|t| DlDpipeEntry::attr_from_type(t)),
8074 );
8075 }
8076 if cur > offset || cur + self.buf.len() < offset {
8077 return (stack, None);
8078 }
8079 let mut attrs = self.clone();
8080 let mut last_off = cur + attrs.pos;
8081 let mut missing = None;
8082 while let Some(attr) = attrs.next() {
8083 let Ok(attr) = attr else { break };
8084 match attr {
8085 DlDpipeEntry::DpipeEntryIndex(val) => {
8086 if last_off == offset {
8087 stack.push(("DpipeEntryIndex", last_off));
8088 break;
8089 }
8090 }
8091 DlDpipeEntry::DpipeEntryMatchValues(val) => {
8092 (stack, missing) = val.lookup_attr(offset, missing_type);
8093 if !stack.is_empty() {
8094 break;
8095 }
8096 }
8097 DlDpipeEntry::DpipeEntryActionValues(val) => {
8098 (stack, missing) = val.lookup_attr(offset, missing_type);
8099 if !stack.is_empty() {
8100 break;
8101 }
8102 }
8103 DlDpipeEntry::DpipeEntryCounter(val) => {
8104 if last_off == offset {
8105 stack.push(("DpipeEntryCounter", last_off));
8106 break;
8107 }
8108 }
8109 _ => {}
8110 };
8111 last_off = cur + attrs.pos;
8112 }
8113 if !stack.is_empty() {
8114 stack.push(("DlDpipeEntry", cur));
8115 }
8116 (stack, missing)
8117 }
8118}
8119#[derive(Clone)]
8120pub enum DlDpipeEntryMatchValues<'a> {
8121 #[doc = "Attribute may repeat multiple times (treat it as array)"]
8122 DpipeMatchValue(IterableDlDpipeMatchValue<'a>),
8123}
8124impl<'a> IterableDlDpipeEntryMatchValues<'a> {
8125 #[doc = "Attribute may repeat multiple times (treat it as array)"]
8126 pub fn get_dpipe_match_value(
8127 &self,
8128 ) -> MultiAttrIterable<Self, DlDpipeEntryMatchValues<'a>, IterableDlDpipeMatchValue<'a>> {
8129 MultiAttrIterable::new(self.clone(), |variant| {
8130 if let DlDpipeEntryMatchValues::DpipeMatchValue(val) = variant {
8131 Some(val)
8132 } else {
8133 None
8134 }
8135 })
8136 }
8137}
8138impl DlDpipeEntryMatchValues<'_> {
8139 pub fn new<'a>(buf: &'a [u8]) -> IterableDlDpipeEntryMatchValues<'a> {
8140 IterableDlDpipeEntryMatchValues::with_loc(buf, buf.as_ptr() as usize)
8141 }
8142 fn attr_from_type(r#type: u16) -> Option<&'static str> {
8143 Devlink::attr_from_type(r#type)
8144 }
8145}
8146#[derive(Clone, Copy, Default)]
8147pub struct IterableDlDpipeEntryMatchValues<'a> {
8148 buf: &'a [u8],
8149 pos: usize,
8150 orig_loc: usize,
8151}
8152impl<'a> IterableDlDpipeEntryMatchValues<'a> {
8153 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
8154 Self {
8155 buf,
8156 pos: 0,
8157 orig_loc,
8158 }
8159 }
8160 pub fn get_buf(&self) -> &'a [u8] {
8161 self.buf
8162 }
8163}
8164impl<'a> Iterator for IterableDlDpipeEntryMatchValues<'a> {
8165 type Item = Result<DlDpipeEntryMatchValues<'a>, ErrorContext>;
8166 fn next(&mut self) -> Option<Self::Item> {
8167 let mut pos;
8168 let mut r#type;
8169 loop {
8170 pos = self.pos;
8171 r#type = None;
8172 if self.buf.len() == self.pos {
8173 return None;
8174 }
8175 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
8176 self.pos = self.buf.len();
8177 break;
8178 };
8179 r#type = Some(header.r#type);
8180 let res = match header.r#type {
8181 41u16 => DlDpipeEntryMatchValues::DpipeMatchValue({
8182 let res = Some(IterableDlDpipeMatchValue::with_loc(next, self.orig_loc));
8183 let Some(val) = res else { break };
8184 val
8185 }),
8186 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
8187 n => continue,
8188 };
8189 return Some(Ok(res));
8190 }
8191 Some(Err(ErrorContext::new(
8192 "DlDpipeEntryMatchValues",
8193 r#type.and_then(|t| DlDpipeEntryMatchValues::attr_from_type(t)),
8194 self.orig_loc,
8195 self.buf.as_ptr().wrapping_add(pos) as usize,
8196 )))
8197 }
8198}
8199impl<'a> std::fmt::Debug for IterableDlDpipeEntryMatchValues<'_> {
8200 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8201 let mut fmt = f.debug_struct("DlDpipeEntryMatchValues");
8202 for attr in self.clone() {
8203 let attr = match attr {
8204 Ok(a) => a,
8205 Err(err) => {
8206 fmt.finish()?;
8207 f.write_str("Err(")?;
8208 err.fmt(f)?;
8209 return f.write_str(")");
8210 }
8211 };
8212 match attr {
8213 DlDpipeEntryMatchValues::DpipeMatchValue(val) => fmt.field("DpipeMatchValue", &val),
8214 };
8215 }
8216 fmt.finish()
8217 }
8218}
8219impl IterableDlDpipeEntryMatchValues<'_> {
8220 pub fn lookup_attr(
8221 &self,
8222 offset: usize,
8223 missing_type: Option<u16>,
8224 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
8225 let mut stack = Vec::new();
8226 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
8227 if missing_type.is_some() && cur == offset {
8228 stack.push(("DlDpipeEntryMatchValues", offset));
8229 return (
8230 stack,
8231 missing_type.and_then(|t| DlDpipeEntryMatchValues::attr_from_type(t)),
8232 );
8233 }
8234 if cur > offset || cur + self.buf.len() < offset {
8235 return (stack, None);
8236 }
8237 let mut attrs = self.clone();
8238 let mut last_off = cur + attrs.pos;
8239 let mut missing = None;
8240 while let Some(attr) = attrs.next() {
8241 let Ok(attr) = attr else { break };
8242 match attr {
8243 DlDpipeEntryMatchValues::DpipeMatchValue(val) => {
8244 (stack, missing) = val.lookup_attr(offset, missing_type);
8245 if !stack.is_empty() {
8246 break;
8247 }
8248 }
8249 _ => {}
8250 };
8251 last_off = cur + attrs.pos;
8252 }
8253 if !stack.is_empty() {
8254 stack.push(("DlDpipeEntryMatchValues", cur));
8255 }
8256 (stack, missing)
8257 }
8258}
8259#[derive(Clone)]
8260pub enum DlDpipeEntryActionValues<'a> {
8261 #[doc = "Attribute may repeat multiple times (treat it as array)"]
8262 DpipeActionValue(IterableDlDpipeActionValue<'a>),
8263}
8264impl<'a> IterableDlDpipeEntryActionValues<'a> {
8265 #[doc = "Attribute may repeat multiple times (treat it as array)"]
8266 pub fn get_dpipe_action_value(
8267 &self,
8268 ) -> MultiAttrIterable<Self, DlDpipeEntryActionValues<'a>, IterableDlDpipeActionValue<'a>> {
8269 MultiAttrIterable::new(self.clone(), |variant| {
8270 if let DlDpipeEntryActionValues::DpipeActionValue(val) = variant {
8271 Some(val)
8272 } else {
8273 None
8274 }
8275 })
8276 }
8277}
8278impl DlDpipeEntryActionValues<'_> {
8279 pub fn new<'a>(buf: &'a [u8]) -> IterableDlDpipeEntryActionValues<'a> {
8280 IterableDlDpipeEntryActionValues::with_loc(buf, buf.as_ptr() as usize)
8281 }
8282 fn attr_from_type(r#type: u16) -> Option<&'static str> {
8283 Devlink::attr_from_type(r#type)
8284 }
8285}
8286#[derive(Clone, Copy, Default)]
8287pub struct IterableDlDpipeEntryActionValues<'a> {
8288 buf: &'a [u8],
8289 pos: usize,
8290 orig_loc: usize,
8291}
8292impl<'a> IterableDlDpipeEntryActionValues<'a> {
8293 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
8294 Self {
8295 buf,
8296 pos: 0,
8297 orig_loc,
8298 }
8299 }
8300 pub fn get_buf(&self) -> &'a [u8] {
8301 self.buf
8302 }
8303}
8304impl<'a> Iterator for IterableDlDpipeEntryActionValues<'a> {
8305 type Item = Result<DlDpipeEntryActionValues<'a>, ErrorContext>;
8306 fn next(&mut self) -> Option<Self::Item> {
8307 let mut pos;
8308 let mut r#type;
8309 loop {
8310 pos = self.pos;
8311 r#type = None;
8312 if self.buf.len() == self.pos {
8313 return None;
8314 }
8315 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
8316 self.pos = self.buf.len();
8317 break;
8318 };
8319 r#type = Some(header.r#type);
8320 let res = match header.r#type {
8321 44u16 => DlDpipeEntryActionValues::DpipeActionValue({
8322 let res = Some(IterableDlDpipeActionValue::with_loc(next, self.orig_loc));
8323 let Some(val) = res else { break };
8324 val
8325 }),
8326 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
8327 n => continue,
8328 };
8329 return Some(Ok(res));
8330 }
8331 Some(Err(ErrorContext::new(
8332 "DlDpipeEntryActionValues",
8333 r#type.and_then(|t| DlDpipeEntryActionValues::attr_from_type(t)),
8334 self.orig_loc,
8335 self.buf.as_ptr().wrapping_add(pos) as usize,
8336 )))
8337 }
8338}
8339impl<'a> std::fmt::Debug for IterableDlDpipeEntryActionValues<'_> {
8340 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8341 let mut fmt = f.debug_struct("DlDpipeEntryActionValues");
8342 for attr in self.clone() {
8343 let attr = match attr {
8344 Ok(a) => a,
8345 Err(err) => {
8346 fmt.finish()?;
8347 f.write_str("Err(")?;
8348 err.fmt(f)?;
8349 return f.write_str(")");
8350 }
8351 };
8352 match attr {
8353 DlDpipeEntryActionValues::DpipeActionValue(val) => {
8354 fmt.field("DpipeActionValue", &val)
8355 }
8356 };
8357 }
8358 fmt.finish()
8359 }
8360}
8361impl IterableDlDpipeEntryActionValues<'_> {
8362 pub fn lookup_attr(
8363 &self,
8364 offset: usize,
8365 missing_type: Option<u16>,
8366 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
8367 let mut stack = Vec::new();
8368 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
8369 if missing_type.is_some() && cur == offset {
8370 stack.push(("DlDpipeEntryActionValues", offset));
8371 return (
8372 stack,
8373 missing_type.and_then(|t| DlDpipeEntryActionValues::attr_from_type(t)),
8374 );
8375 }
8376 if cur > offset || cur + self.buf.len() < offset {
8377 return (stack, None);
8378 }
8379 let mut attrs = self.clone();
8380 let mut last_off = cur + attrs.pos;
8381 let mut missing = None;
8382 while let Some(attr) = attrs.next() {
8383 let Ok(attr) = attr else { break };
8384 match attr {
8385 DlDpipeEntryActionValues::DpipeActionValue(val) => {
8386 (stack, missing) = val.lookup_attr(offset, missing_type);
8387 if !stack.is_empty() {
8388 break;
8389 }
8390 }
8391 _ => {}
8392 };
8393 last_off = cur + attrs.pos;
8394 }
8395 if !stack.is_empty() {
8396 stack.push(("DlDpipeEntryActionValues", cur));
8397 }
8398 (stack, missing)
8399 }
8400}
8401#[derive(Clone)]
8402pub enum DlDpipeMatch {
8403 #[doc = "Associated type: [`DpipeMatchType`] (enum)"]
8404 DpipeMatchType(u32),
8405 #[doc = "Associated type: [`DpipeHeaderId`] (enum)"]
8406 DpipeHeaderId(u32),
8407 DpipeHeaderGlobal(u8),
8408 DpipeHeaderIndex(u32),
8409 DpipeFieldId(u32),
8410}
8411impl<'a> IterableDlDpipeMatch<'a> {
8412 #[doc = "Associated type: [`DpipeMatchType`] (enum)"]
8413 pub fn get_dpipe_match_type(&self) -> Result<u32, ErrorContext> {
8414 let mut iter = self.clone();
8415 iter.pos = 0;
8416 for attr in iter {
8417 if let Ok(DlDpipeMatch::DpipeMatchType(val)) = attr {
8418 return Ok(val);
8419 }
8420 }
8421 Err(ErrorContext::new_missing(
8422 "DlDpipeMatch",
8423 "DpipeMatchType",
8424 self.orig_loc,
8425 self.buf.as_ptr() as usize,
8426 ))
8427 }
8428 #[doc = "Associated type: [`DpipeHeaderId`] (enum)"]
8429 pub fn get_dpipe_header_id(&self) -> Result<u32, ErrorContext> {
8430 let mut iter = self.clone();
8431 iter.pos = 0;
8432 for attr in iter {
8433 if let Ok(DlDpipeMatch::DpipeHeaderId(val)) = attr {
8434 return Ok(val);
8435 }
8436 }
8437 Err(ErrorContext::new_missing(
8438 "DlDpipeMatch",
8439 "DpipeHeaderId",
8440 self.orig_loc,
8441 self.buf.as_ptr() as usize,
8442 ))
8443 }
8444 pub fn get_dpipe_header_global(&self) -> Result<u8, ErrorContext> {
8445 let mut iter = self.clone();
8446 iter.pos = 0;
8447 for attr in iter {
8448 if let Ok(DlDpipeMatch::DpipeHeaderGlobal(val)) = attr {
8449 return Ok(val);
8450 }
8451 }
8452 Err(ErrorContext::new_missing(
8453 "DlDpipeMatch",
8454 "DpipeHeaderGlobal",
8455 self.orig_loc,
8456 self.buf.as_ptr() as usize,
8457 ))
8458 }
8459 pub fn get_dpipe_header_index(&self) -> Result<u32, ErrorContext> {
8460 let mut iter = self.clone();
8461 iter.pos = 0;
8462 for attr in iter {
8463 if let Ok(DlDpipeMatch::DpipeHeaderIndex(val)) = attr {
8464 return Ok(val);
8465 }
8466 }
8467 Err(ErrorContext::new_missing(
8468 "DlDpipeMatch",
8469 "DpipeHeaderIndex",
8470 self.orig_loc,
8471 self.buf.as_ptr() as usize,
8472 ))
8473 }
8474 pub fn get_dpipe_field_id(&self) -> Result<u32, ErrorContext> {
8475 let mut iter = self.clone();
8476 iter.pos = 0;
8477 for attr in iter {
8478 if let Ok(DlDpipeMatch::DpipeFieldId(val)) = attr {
8479 return Ok(val);
8480 }
8481 }
8482 Err(ErrorContext::new_missing(
8483 "DlDpipeMatch",
8484 "DpipeFieldId",
8485 self.orig_loc,
8486 self.buf.as_ptr() as usize,
8487 ))
8488 }
8489}
8490impl DlDpipeMatch {
8491 pub fn new<'a>(buf: &'a [u8]) -> IterableDlDpipeMatch<'a> {
8492 IterableDlDpipeMatch::with_loc(buf, buf.as_ptr() as usize)
8493 }
8494 fn attr_from_type(r#type: u16) -> Option<&'static str> {
8495 Devlink::attr_from_type(r#type)
8496 }
8497}
8498#[derive(Clone, Copy, Default)]
8499pub struct IterableDlDpipeMatch<'a> {
8500 buf: &'a [u8],
8501 pos: usize,
8502 orig_loc: usize,
8503}
8504impl<'a> IterableDlDpipeMatch<'a> {
8505 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
8506 Self {
8507 buf,
8508 pos: 0,
8509 orig_loc,
8510 }
8511 }
8512 pub fn get_buf(&self) -> &'a [u8] {
8513 self.buf
8514 }
8515}
8516impl<'a> Iterator for IterableDlDpipeMatch<'a> {
8517 type Item = Result<DlDpipeMatch, ErrorContext>;
8518 fn next(&mut self) -> Option<Self::Item> {
8519 let mut pos;
8520 let mut r#type;
8521 loop {
8522 pos = self.pos;
8523 r#type = None;
8524 if self.buf.len() == self.pos {
8525 return None;
8526 }
8527 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
8528 self.pos = self.buf.len();
8529 break;
8530 };
8531 r#type = Some(header.r#type);
8532 let res = match header.r#type {
8533 42u16 => DlDpipeMatch::DpipeMatchType({
8534 let res = parse_u32(next);
8535 let Some(val) = res else { break };
8536 val
8537 }),
8538 52u16 => DlDpipeMatch::DpipeHeaderId({
8539 let res = parse_u32(next);
8540 let Some(val) = res else { break };
8541 val
8542 }),
8543 54u16 => DlDpipeMatch::DpipeHeaderGlobal({
8544 let res = parse_u8(next);
8545 let Some(val) = res else { break };
8546 val
8547 }),
8548 55u16 => DlDpipeMatch::DpipeHeaderIndex({
8549 let res = parse_u32(next);
8550 let Some(val) = res else { break };
8551 val
8552 }),
8553 58u16 => DlDpipeMatch::DpipeFieldId({
8554 let res = parse_u32(next);
8555 let Some(val) = res else { break };
8556 val
8557 }),
8558 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
8559 n => continue,
8560 };
8561 return Some(Ok(res));
8562 }
8563 Some(Err(ErrorContext::new(
8564 "DlDpipeMatch",
8565 r#type.and_then(|t| DlDpipeMatch::attr_from_type(t)),
8566 self.orig_loc,
8567 self.buf.as_ptr().wrapping_add(pos) as usize,
8568 )))
8569 }
8570}
8571impl std::fmt::Debug for IterableDlDpipeMatch<'_> {
8572 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8573 let mut fmt = f.debug_struct("DlDpipeMatch");
8574 for attr in self.clone() {
8575 let attr = match attr {
8576 Ok(a) => a,
8577 Err(err) => {
8578 fmt.finish()?;
8579 f.write_str("Err(")?;
8580 err.fmt(f)?;
8581 return f.write_str(")");
8582 }
8583 };
8584 match attr {
8585 DlDpipeMatch::DpipeMatchType(val) => fmt.field(
8586 "DpipeMatchType",
8587 &FormatEnum(val.into(), DpipeMatchType::from_value),
8588 ),
8589 DlDpipeMatch::DpipeHeaderId(val) => fmt.field(
8590 "DpipeHeaderId",
8591 &FormatEnum(val.into(), DpipeHeaderId::from_value),
8592 ),
8593 DlDpipeMatch::DpipeHeaderGlobal(val) => fmt.field("DpipeHeaderGlobal", &val),
8594 DlDpipeMatch::DpipeHeaderIndex(val) => fmt.field("DpipeHeaderIndex", &val),
8595 DlDpipeMatch::DpipeFieldId(val) => fmt.field("DpipeFieldId", &val),
8596 };
8597 }
8598 fmt.finish()
8599 }
8600}
8601impl IterableDlDpipeMatch<'_> {
8602 pub fn lookup_attr(
8603 &self,
8604 offset: usize,
8605 missing_type: Option<u16>,
8606 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
8607 let mut stack = Vec::new();
8608 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
8609 if missing_type.is_some() && cur == offset {
8610 stack.push(("DlDpipeMatch", offset));
8611 return (
8612 stack,
8613 missing_type.and_then(|t| DlDpipeMatch::attr_from_type(t)),
8614 );
8615 }
8616 if cur > offset || cur + self.buf.len() < offset {
8617 return (stack, None);
8618 }
8619 let mut attrs = self.clone();
8620 let mut last_off = cur + attrs.pos;
8621 while let Some(attr) = attrs.next() {
8622 let Ok(attr) = attr else { break };
8623 match attr {
8624 DlDpipeMatch::DpipeMatchType(val) => {
8625 if last_off == offset {
8626 stack.push(("DpipeMatchType", last_off));
8627 break;
8628 }
8629 }
8630 DlDpipeMatch::DpipeHeaderId(val) => {
8631 if last_off == offset {
8632 stack.push(("DpipeHeaderId", last_off));
8633 break;
8634 }
8635 }
8636 DlDpipeMatch::DpipeHeaderGlobal(val) => {
8637 if last_off == offset {
8638 stack.push(("DpipeHeaderGlobal", last_off));
8639 break;
8640 }
8641 }
8642 DlDpipeMatch::DpipeHeaderIndex(val) => {
8643 if last_off == offset {
8644 stack.push(("DpipeHeaderIndex", last_off));
8645 break;
8646 }
8647 }
8648 DlDpipeMatch::DpipeFieldId(val) => {
8649 if last_off == offset {
8650 stack.push(("DpipeFieldId", last_off));
8651 break;
8652 }
8653 }
8654 _ => {}
8655 };
8656 last_off = cur + attrs.pos;
8657 }
8658 if !stack.is_empty() {
8659 stack.push(("DlDpipeMatch", cur));
8660 }
8661 (stack, None)
8662 }
8663}
8664#[derive(Clone)]
8665pub enum DlDpipeMatchValue<'a> {
8666 #[doc = "Attribute may repeat multiple times (treat it as array)"]
8667 DpipeMatch(IterableDlDpipeMatch<'a>),
8668 DpipeValue(&'a [u8]),
8669 DpipeValueMask(&'a [u8]),
8670 DpipeValueMapping(u32),
8671}
8672impl<'a> IterableDlDpipeMatchValue<'a> {
8673 #[doc = "Attribute may repeat multiple times (treat it as array)"]
8674 pub fn get_dpipe_match(
8675 &self,
8676 ) -> MultiAttrIterable<Self, DlDpipeMatchValue<'a>, IterableDlDpipeMatch<'a>> {
8677 MultiAttrIterable::new(self.clone(), |variant| {
8678 if let DlDpipeMatchValue::DpipeMatch(val) = variant {
8679 Some(val)
8680 } else {
8681 None
8682 }
8683 })
8684 }
8685 pub fn get_dpipe_value(&self) -> Result<&'a [u8], ErrorContext> {
8686 let mut iter = self.clone();
8687 iter.pos = 0;
8688 for attr in iter {
8689 if let Ok(DlDpipeMatchValue::DpipeValue(val)) = attr {
8690 return Ok(val);
8691 }
8692 }
8693 Err(ErrorContext::new_missing(
8694 "DlDpipeMatchValue",
8695 "DpipeValue",
8696 self.orig_loc,
8697 self.buf.as_ptr() as usize,
8698 ))
8699 }
8700 pub fn get_dpipe_value_mask(&self) -> Result<&'a [u8], ErrorContext> {
8701 let mut iter = self.clone();
8702 iter.pos = 0;
8703 for attr in iter {
8704 if let Ok(DlDpipeMatchValue::DpipeValueMask(val)) = attr {
8705 return Ok(val);
8706 }
8707 }
8708 Err(ErrorContext::new_missing(
8709 "DlDpipeMatchValue",
8710 "DpipeValueMask",
8711 self.orig_loc,
8712 self.buf.as_ptr() as usize,
8713 ))
8714 }
8715 pub fn get_dpipe_value_mapping(&self) -> Result<u32, ErrorContext> {
8716 let mut iter = self.clone();
8717 iter.pos = 0;
8718 for attr in iter {
8719 if let Ok(DlDpipeMatchValue::DpipeValueMapping(val)) = attr {
8720 return Ok(val);
8721 }
8722 }
8723 Err(ErrorContext::new_missing(
8724 "DlDpipeMatchValue",
8725 "DpipeValueMapping",
8726 self.orig_loc,
8727 self.buf.as_ptr() as usize,
8728 ))
8729 }
8730}
8731impl DlDpipeMatchValue<'_> {
8732 pub fn new<'a>(buf: &'a [u8]) -> IterableDlDpipeMatchValue<'a> {
8733 IterableDlDpipeMatchValue::with_loc(buf, buf.as_ptr() as usize)
8734 }
8735 fn attr_from_type(r#type: u16) -> Option<&'static str> {
8736 Devlink::attr_from_type(r#type)
8737 }
8738}
8739#[derive(Clone, Copy, Default)]
8740pub struct IterableDlDpipeMatchValue<'a> {
8741 buf: &'a [u8],
8742 pos: usize,
8743 orig_loc: usize,
8744}
8745impl<'a> IterableDlDpipeMatchValue<'a> {
8746 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
8747 Self {
8748 buf,
8749 pos: 0,
8750 orig_loc,
8751 }
8752 }
8753 pub fn get_buf(&self) -> &'a [u8] {
8754 self.buf
8755 }
8756}
8757impl<'a> Iterator for IterableDlDpipeMatchValue<'a> {
8758 type Item = Result<DlDpipeMatchValue<'a>, ErrorContext>;
8759 fn next(&mut self) -> Option<Self::Item> {
8760 let mut pos;
8761 let mut r#type;
8762 loop {
8763 pos = self.pos;
8764 r#type = None;
8765 if self.buf.len() == self.pos {
8766 return None;
8767 }
8768 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
8769 self.pos = self.buf.len();
8770 break;
8771 };
8772 r#type = Some(header.r#type);
8773 let res = match header.r#type {
8774 40u16 => DlDpipeMatchValue::DpipeMatch({
8775 let res = Some(IterableDlDpipeMatch::with_loc(next, self.orig_loc));
8776 let Some(val) = res else { break };
8777 val
8778 }),
8779 46u16 => DlDpipeMatchValue::DpipeValue({
8780 let res = Some(next);
8781 let Some(val) = res else { break };
8782 val
8783 }),
8784 47u16 => DlDpipeMatchValue::DpipeValueMask({
8785 let res = Some(next);
8786 let Some(val) = res else { break };
8787 val
8788 }),
8789 48u16 => DlDpipeMatchValue::DpipeValueMapping({
8790 let res = parse_u32(next);
8791 let Some(val) = res else { break };
8792 val
8793 }),
8794 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
8795 n => continue,
8796 };
8797 return Some(Ok(res));
8798 }
8799 Some(Err(ErrorContext::new(
8800 "DlDpipeMatchValue",
8801 r#type.and_then(|t| DlDpipeMatchValue::attr_from_type(t)),
8802 self.orig_loc,
8803 self.buf.as_ptr().wrapping_add(pos) as usize,
8804 )))
8805 }
8806}
8807impl<'a> std::fmt::Debug for IterableDlDpipeMatchValue<'_> {
8808 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8809 let mut fmt = f.debug_struct("DlDpipeMatchValue");
8810 for attr in self.clone() {
8811 let attr = match attr {
8812 Ok(a) => a,
8813 Err(err) => {
8814 fmt.finish()?;
8815 f.write_str("Err(")?;
8816 err.fmt(f)?;
8817 return f.write_str(")");
8818 }
8819 };
8820 match attr {
8821 DlDpipeMatchValue::DpipeMatch(val) => fmt.field("DpipeMatch", &val),
8822 DlDpipeMatchValue::DpipeValue(val) => fmt.field("DpipeValue", &val),
8823 DlDpipeMatchValue::DpipeValueMask(val) => fmt.field("DpipeValueMask", &val),
8824 DlDpipeMatchValue::DpipeValueMapping(val) => fmt.field("DpipeValueMapping", &val),
8825 };
8826 }
8827 fmt.finish()
8828 }
8829}
8830impl IterableDlDpipeMatchValue<'_> {
8831 pub fn lookup_attr(
8832 &self,
8833 offset: usize,
8834 missing_type: Option<u16>,
8835 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
8836 let mut stack = Vec::new();
8837 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
8838 if missing_type.is_some() && cur == offset {
8839 stack.push(("DlDpipeMatchValue", offset));
8840 return (
8841 stack,
8842 missing_type.and_then(|t| DlDpipeMatchValue::attr_from_type(t)),
8843 );
8844 }
8845 if cur > offset || cur + self.buf.len() < offset {
8846 return (stack, None);
8847 }
8848 let mut attrs = self.clone();
8849 let mut last_off = cur + attrs.pos;
8850 let mut missing = None;
8851 while let Some(attr) = attrs.next() {
8852 let Ok(attr) = attr else { break };
8853 match attr {
8854 DlDpipeMatchValue::DpipeMatch(val) => {
8855 (stack, missing) = val.lookup_attr(offset, missing_type);
8856 if !stack.is_empty() {
8857 break;
8858 }
8859 }
8860 DlDpipeMatchValue::DpipeValue(val) => {
8861 if last_off == offset {
8862 stack.push(("DpipeValue", last_off));
8863 break;
8864 }
8865 }
8866 DlDpipeMatchValue::DpipeValueMask(val) => {
8867 if last_off == offset {
8868 stack.push(("DpipeValueMask", last_off));
8869 break;
8870 }
8871 }
8872 DlDpipeMatchValue::DpipeValueMapping(val) => {
8873 if last_off == offset {
8874 stack.push(("DpipeValueMapping", last_off));
8875 break;
8876 }
8877 }
8878 _ => {}
8879 };
8880 last_off = cur + attrs.pos;
8881 }
8882 if !stack.is_empty() {
8883 stack.push(("DlDpipeMatchValue", cur));
8884 }
8885 (stack, missing)
8886 }
8887}
8888#[derive(Clone)]
8889pub enum DlDpipeAction {
8890 #[doc = "Associated type: [`DpipeActionType`] (enum)"]
8891 DpipeActionType(u32),
8892 #[doc = "Associated type: [`DpipeHeaderId`] (enum)"]
8893 DpipeHeaderId(u32),
8894 DpipeHeaderGlobal(u8),
8895 DpipeHeaderIndex(u32),
8896 DpipeFieldId(u32),
8897}
8898impl<'a> IterableDlDpipeAction<'a> {
8899 #[doc = "Associated type: [`DpipeActionType`] (enum)"]
8900 pub fn get_dpipe_action_type(&self) -> Result<u32, ErrorContext> {
8901 let mut iter = self.clone();
8902 iter.pos = 0;
8903 for attr in iter {
8904 if let Ok(DlDpipeAction::DpipeActionType(val)) = attr {
8905 return Ok(val);
8906 }
8907 }
8908 Err(ErrorContext::new_missing(
8909 "DlDpipeAction",
8910 "DpipeActionType",
8911 self.orig_loc,
8912 self.buf.as_ptr() as usize,
8913 ))
8914 }
8915 #[doc = "Associated type: [`DpipeHeaderId`] (enum)"]
8916 pub fn get_dpipe_header_id(&self) -> Result<u32, ErrorContext> {
8917 let mut iter = self.clone();
8918 iter.pos = 0;
8919 for attr in iter {
8920 if let Ok(DlDpipeAction::DpipeHeaderId(val)) = attr {
8921 return Ok(val);
8922 }
8923 }
8924 Err(ErrorContext::new_missing(
8925 "DlDpipeAction",
8926 "DpipeHeaderId",
8927 self.orig_loc,
8928 self.buf.as_ptr() as usize,
8929 ))
8930 }
8931 pub fn get_dpipe_header_global(&self) -> Result<u8, ErrorContext> {
8932 let mut iter = self.clone();
8933 iter.pos = 0;
8934 for attr in iter {
8935 if let Ok(DlDpipeAction::DpipeHeaderGlobal(val)) = attr {
8936 return Ok(val);
8937 }
8938 }
8939 Err(ErrorContext::new_missing(
8940 "DlDpipeAction",
8941 "DpipeHeaderGlobal",
8942 self.orig_loc,
8943 self.buf.as_ptr() as usize,
8944 ))
8945 }
8946 pub fn get_dpipe_header_index(&self) -> Result<u32, ErrorContext> {
8947 let mut iter = self.clone();
8948 iter.pos = 0;
8949 for attr in iter {
8950 if let Ok(DlDpipeAction::DpipeHeaderIndex(val)) = attr {
8951 return Ok(val);
8952 }
8953 }
8954 Err(ErrorContext::new_missing(
8955 "DlDpipeAction",
8956 "DpipeHeaderIndex",
8957 self.orig_loc,
8958 self.buf.as_ptr() as usize,
8959 ))
8960 }
8961 pub fn get_dpipe_field_id(&self) -> Result<u32, ErrorContext> {
8962 let mut iter = self.clone();
8963 iter.pos = 0;
8964 for attr in iter {
8965 if let Ok(DlDpipeAction::DpipeFieldId(val)) = attr {
8966 return Ok(val);
8967 }
8968 }
8969 Err(ErrorContext::new_missing(
8970 "DlDpipeAction",
8971 "DpipeFieldId",
8972 self.orig_loc,
8973 self.buf.as_ptr() as usize,
8974 ))
8975 }
8976}
8977impl DlDpipeAction {
8978 pub fn new<'a>(buf: &'a [u8]) -> IterableDlDpipeAction<'a> {
8979 IterableDlDpipeAction::with_loc(buf, buf.as_ptr() as usize)
8980 }
8981 fn attr_from_type(r#type: u16) -> Option<&'static str> {
8982 Devlink::attr_from_type(r#type)
8983 }
8984}
8985#[derive(Clone, Copy, Default)]
8986pub struct IterableDlDpipeAction<'a> {
8987 buf: &'a [u8],
8988 pos: usize,
8989 orig_loc: usize,
8990}
8991impl<'a> IterableDlDpipeAction<'a> {
8992 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
8993 Self {
8994 buf,
8995 pos: 0,
8996 orig_loc,
8997 }
8998 }
8999 pub fn get_buf(&self) -> &'a [u8] {
9000 self.buf
9001 }
9002}
9003impl<'a> Iterator for IterableDlDpipeAction<'a> {
9004 type Item = Result<DlDpipeAction, ErrorContext>;
9005 fn next(&mut self) -> Option<Self::Item> {
9006 let mut pos;
9007 let mut r#type;
9008 loop {
9009 pos = self.pos;
9010 r#type = None;
9011 if self.buf.len() == self.pos {
9012 return None;
9013 }
9014 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
9015 self.pos = self.buf.len();
9016 break;
9017 };
9018 r#type = Some(header.r#type);
9019 let res = match header.r#type {
9020 45u16 => DlDpipeAction::DpipeActionType({
9021 let res = parse_u32(next);
9022 let Some(val) = res else { break };
9023 val
9024 }),
9025 52u16 => DlDpipeAction::DpipeHeaderId({
9026 let res = parse_u32(next);
9027 let Some(val) = res else { break };
9028 val
9029 }),
9030 54u16 => DlDpipeAction::DpipeHeaderGlobal({
9031 let res = parse_u8(next);
9032 let Some(val) = res else { break };
9033 val
9034 }),
9035 55u16 => DlDpipeAction::DpipeHeaderIndex({
9036 let res = parse_u32(next);
9037 let Some(val) = res else { break };
9038 val
9039 }),
9040 58u16 => DlDpipeAction::DpipeFieldId({
9041 let res = parse_u32(next);
9042 let Some(val) = res else { break };
9043 val
9044 }),
9045 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
9046 n => continue,
9047 };
9048 return Some(Ok(res));
9049 }
9050 Some(Err(ErrorContext::new(
9051 "DlDpipeAction",
9052 r#type.and_then(|t| DlDpipeAction::attr_from_type(t)),
9053 self.orig_loc,
9054 self.buf.as_ptr().wrapping_add(pos) as usize,
9055 )))
9056 }
9057}
9058impl std::fmt::Debug for IterableDlDpipeAction<'_> {
9059 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9060 let mut fmt = f.debug_struct("DlDpipeAction");
9061 for attr in self.clone() {
9062 let attr = match attr {
9063 Ok(a) => a,
9064 Err(err) => {
9065 fmt.finish()?;
9066 f.write_str("Err(")?;
9067 err.fmt(f)?;
9068 return f.write_str(")");
9069 }
9070 };
9071 match attr {
9072 DlDpipeAction::DpipeActionType(val) => fmt.field(
9073 "DpipeActionType",
9074 &FormatEnum(val.into(), DpipeActionType::from_value),
9075 ),
9076 DlDpipeAction::DpipeHeaderId(val) => fmt.field(
9077 "DpipeHeaderId",
9078 &FormatEnum(val.into(), DpipeHeaderId::from_value),
9079 ),
9080 DlDpipeAction::DpipeHeaderGlobal(val) => fmt.field("DpipeHeaderGlobal", &val),
9081 DlDpipeAction::DpipeHeaderIndex(val) => fmt.field("DpipeHeaderIndex", &val),
9082 DlDpipeAction::DpipeFieldId(val) => fmt.field("DpipeFieldId", &val),
9083 };
9084 }
9085 fmt.finish()
9086 }
9087}
9088impl IterableDlDpipeAction<'_> {
9089 pub fn lookup_attr(
9090 &self,
9091 offset: usize,
9092 missing_type: Option<u16>,
9093 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
9094 let mut stack = Vec::new();
9095 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
9096 if missing_type.is_some() && cur == offset {
9097 stack.push(("DlDpipeAction", offset));
9098 return (
9099 stack,
9100 missing_type.and_then(|t| DlDpipeAction::attr_from_type(t)),
9101 );
9102 }
9103 if cur > offset || cur + self.buf.len() < offset {
9104 return (stack, None);
9105 }
9106 let mut attrs = self.clone();
9107 let mut last_off = cur + attrs.pos;
9108 while let Some(attr) = attrs.next() {
9109 let Ok(attr) = attr else { break };
9110 match attr {
9111 DlDpipeAction::DpipeActionType(val) => {
9112 if last_off == offset {
9113 stack.push(("DpipeActionType", last_off));
9114 break;
9115 }
9116 }
9117 DlDpipeAction::DpipeHeaderId(val) => {
9118 if last_off == offset {
9119 stack.push(("DpipeHeaderId", last_off));
9120 break;
9121 }
9122 }
9123 DlDpipeAction::DpipeHeaderGlobal(val) => {
9124 if last_off == offset {
9125 stack.push(("DpipeHeaderGlobal", last_off));
9126 break;
9127 }
9128 }
9129 DlDpipeAction::DpipeHeaderIndex(val) => {
9130 if last_off == offset {
9131 stack.push(("DpipeHeaderIndex", last_off));
9132 break;
9133 }
9134 }
9135 DlDpipeAction::DpipeFieldId(val) => {
9136 if last_off == offset {
9137 stack.push(("DpipeFieldId", last_off));
9138 break;
9139 }
9140 }
9141 _ => {}
9142 };
9143 last_off = cur + attrs.pos;
9144 }
9145 if !stack.is_empty() {
9146 stack.push(("DlDpipeAction", cur));
9147 }
9148 (stack, None)
9149 }
9150}
9151#[derive(Clone)]
9152pub enum DlDpipeActionValue<'a> {
9153 #[doc = "Attribute may repeat multiple times (treat it as array)"]
9154 DpipeAction(IterableDlDpipeAction<'a>),
9155 DpipeValue(&'a [u8]),
9156 DpipeValueMask(&'a [u8]),
9157 DpipeValueMapping(u32),
9158}
9159impl<'a> IterableDlDpipeActionValue<'a> {
9160 #[doc = "Attribute may repeat multiple times (treat it as array)"]
9161 pub fn get_dpipe_action(
9162 &self,
9163 ) -> MultiAttrIterable<Self, DlDpipeActionValue<'a>, IterableDlDpipeAction<'a>> {
9164 MultiAttrIterable::new(self.clone(), |variant| {
9165 if let DlDpipeActionValue::DpipeAction(val) = variant {
9166 Some(val)
9167 } else {
9168 None
9169 }
9170 })
9171 }
9172 pub fn get_dpipe_value(&self) -> Result<&'a [u8], ErrorContext> {
9173 let mut iter = self.clone();
9174 iter.pos = 0;
9175 for attr in iter {
9176 if let Ok(DlDpipeActionValue::DpipeValue(val)) = attr {
9177 return Ok(val);
9178 }
9179 }
9180 Err(ErrorContext::new_missing(
9181 "DlDpipeActionValue",
9182 "DpipeValue",
9183 self.orig_loc,
9184 self.buf.as_ptr() as usize,
9185 ))
9186 }
9187 pub fn get_dpipe_value_mask(&self) -> Result<&'a [u8], ErrorContext> {
9188 let mut iter = self.clone();
9189 iter.pos = 0;
9190 for attr in iter {
9191 if let Ok(DlDpipeActionValue::DpipeValueMask(val)) = attr {
9192 return Ok(val);
9193 }
9194 }
9195 Err(ErrorContext::new_missing(
9196 "DlDpipeActionValue",
9197 "DpipeValueMask",
9198 self.orig_loc,
9199 self.buf.as_ptr() as usize,
9200 ))
9201 }
9202 pub fn get_dpipe_value_mapping(&self) -> Result<u32, ErrorContext> {
9203 let mut iter = self.clone();
9204 iter.pos = 0;
9205 for attr in iter {
9206 if let Ok(DlDpipeActionValue::DpipeValueMapping(val)) = attr {
9207 return Ok(val);
9208 }
9209 }
9210 Err(ErrorContext::new_missing(
9211 "DlDpipeActionValue",
9212 "DpipeValueMapping",
9213 self.orig_loc,
9214 self.buf.as_ptr() as usize,
9215 ))
9216 }
9217}
9218impl DlDpipeActionValue<'_> {
9219 pub fn new<'a>(buf: &'a [u8]) -> IterableDlDpipeActionValue<'a> {
9220 IterableDlDpipeActionValue::with_loc(buf, buf.as_ptr() as usize)
9221 }
9222 fn attr_from_type(r#type: u16) -> Option<&'static str> {
9223 Devlink::attr_from_type(r#type)
9224 }
9225}
9226#[derive(Clone, Copy, Default)]
9227pub struct IterableDlDpipeActionValue<'a> {
9228 buf: &'a [u8],
9229 pos: usize,
9230 orig_loc: usize,
9231}
9232impl<'a> IterableDlDpipeActionValue<'a> {
9233 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
9234 Self {
9235 buf,
9236 pos: 0,
9237 orig_loc,
9238 }
9239 }
9240 pub fn get_buf(&self) -> &'a [u8] {
9241 self.buf
9242 }
9243}
9244impl<'a> Iterator for IterableDlDpipeActionValue<'a> {
9245 type Item = Result<DlDpipeActionValue<'a>, ErrorContext>;
9246 fn next(&mut self) -> Option<Self::Item> {
9247 let mut pos;
9248 let mut r#type;
9249 loop {
9250 pos = self.pos;
9251 r#type = None;
9252 if self.buf.len() == self.pos {
9253 return None;
9254 }
9255 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
9256 self.pos = self.buf.len();
9257 break;
9258 };
9259 r#type = Some(header.r#type);
9260 let res = match header.r#type {
9261 43u16 => DlDpipeActionValue::DpipeAction({
9262 let res = Some(IterableDlDpipeAction::with_loc(next, self.orig_loc));
9263 let Some(val) = res else { break };
9264 val
9265 }),
9266 46u16 => DlDpipeActionValue::DpipeValue({
9267 let res = Some(next);
9268 let Some(val) = res else { break };
9269 val
9270 }),
9271 47u16 => DlDpipeActionValue::DpipeValueMask({
9272 let res = Some(next);
9273 let Some(val) = res else { break };
9274 val
9275 }),
9276 48u16 => DlDpipeActionValue::DpipeValueMapping({
9277 let res = parse_u32(next);
9278 let Some(val) = res else { break };
9279 val
9280 }),
9281 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
9282 n => continue,
9283 };
9284 return Some(Ok(res));
9285 }
9286 Some(Err(ErrorContext::new(
9287 "DlDpipeActionValue",
9288 r#type.and_then(|t| DlDpipeActionValue::attr_from_type(t)),
9289 self.orig_loc,
9290 self.buf.as_ptr().wrapping_add(pos) as usize,
9291 )))
9292 }
9293}
9294impl<'a> std::fmt::Debug for IterableDlDpipeActionValue<'_> {
9295 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9296 let mut fmt = f.debug_struct("DlDpipeActionValue");
9297 for attr in self.clone() {
9298 let attr = match attr {
9299 Ok(a) => a,
9300 Err(err) => {
9301 fmt.finish()?;
9302 f.write_str("Err(")?;
9303 err.fmt(f)?;
9304 return f.write_str(")");
9305 }
9306 };
9307 match attr {
9308 DlDpipeActionValue::DpipeAction(val) => fmt.field("DpipeAction", &val),
9309 DlDpipeActionValue::DpipeValue(val) => fmt.field("DpipeValue", &val),
9310 DlDpipeActionValue::DpipeValueMask(val) => fmt.field("DpipeValueMask", &val),
9311 DlDpipeActionValue::DpipeValueMapping(val) => fmt.field("DpipeValueMapping", &val),
9312 };
9313 }
9314 fmt.finish()
9315 }
9316}
9317impl IterableDlDpipeActionValue<'_> {
9318 pub fn lookup_attr(
9319 &self,
9320 offset: usize,
9321 missing_type: Option<u16>,
9322 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
9323 let mut stack = Vec::new();
9324 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
9325 if missing_type.is_some() && cur == offset {
9326 stack.push(("DlDpipeActionValue", offset));
9327 return (
9328 stack,
9329 missing_type.and_then(|t| DlDpipeActionValue::attr_from_type(t)),
9330 );
9331 }
9332 if cur > offset || cur + self.buf.len() < offset {
9333 return (stack, None);
9334 }
9335 let mut attrs = self.clone();
9336 let mut last_off = cur + attrs.pos;
9337 let mut missing = None;
9338 while let Some(attr) = attrs.next() {
9339 let Ok(attr) = attr else { break };
9340 match attr {
9341 DlDpipeActionValue::DpipeAction(val) => {
9342 (stack, missing) = val.lookup_attr(offset, missing_type);
9343 if !stack.is_empty() {
9344 break;
9345 }
9346 }
9347 DlDpipeActionValue::DpipeValue(val) => {
9348 if last_off == offset {
9349 stack.push(("DpipeValue", last_off));
9350 break;
9351 }
9352 }
9353 DlDpipeActionValue::DpipeValueMask(val) => {
9354 if last_off == offset {
9355 stack.push(("DpipeValueMask", last_off));
9356 break;
9357 }
9358 }
9359 DlDpipeActionValue::DpipeValueMapping(val) => {
9360 if last_off == offset {
9361 stack.push(("DpipeValueMapping", last_off));
9362 break;
9363 }
9364 }
9365 _ => {}
9366 };
9367 last_off = cur + attrs.pos;
9368 }
9369 if !stack.is_empty() {
9370 stack.push(("DlDpipeActionValue", cur));
9371 }
9372 (stack, missing)
9373 }
9374}
9375#[derive(Clone)]
9376pub enum DlDpipeHeaders<'a> {
9377 #[doc = "Attribute may repeat multiple times (treat it as array)"]
9378 DpipeHeader(IterableDlDpipeHeader<'a>),
9379}
9380impl<'a> IterableDlDpipeHeaders<'a> {
9381 #[doc = "Attribute may repeat multiple times (treat it as array)"]
9382 pub fn get_dpipe_header(
9383 &self,
9384 ) -> MultiAttrIterable<Self, DlDpipeHeaders<'a>, IterableDlDpipeHeader<'a>> {
9385 MultiAttrIterable::new(self.clone(), |variant| {
9386 if let DlDpipeHeaders::DpipeHeader(val) = variant {
9387 Some(val)
9388 } else {
9389 None
9390 }
9391 })
9392 }
9393}
9394impl DlDpipeHeaders<'_> {
9395 pub fn new<'a>(buf: &'a [u8]) -> IterableDlDpipeHeaders<'a> {
9396 IterableDlDpipeHeaders::with_loc(buf, buf.as_ptr() as usize)
9397 }
9398 fn attr_from_type(r#type: u16) -> Option<&'static str> {
9399 Devlink::attr_from_type(r#type)
9400 }
9401}
9402#[derive(Clone, Copy, Default)]
9403pub struct IterableDlDpipeHeaders<'a> {
9404 buf: &'a [u8],
9405 pos: usize,
9406 orig_loc: usize,
9407}
9408impl<'a> IterableDlDpipeHeaders<'a> {
9409 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
9410 Self {
9411 buf,
9412 pos: 0,
9413 orig_loc,
9414 }
9415 }
9416 pub fn get_buf(&self) -> &'a [u8] {
9417 self.buf
9418 }
9419}
9420impl<'a> Iterator for IterableDlDpipeHeaders<'a> {
9421 type Item = Result<DlDpipeHeaders<'a>, ErrorContext>;
9422 fn next(&mut self) -> Option<Self::Item> {
9423 let mut pos;
9424 let mut r#type;
9425 loop {
9426 pos = self.pos;
9427 r#type = None;
9428 if self.buf.len() == self.pos {
9429 return None;
9430 }
9431 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
9432 self.pos = self.buf.len();
9433 break;
9434 };
9435 r#type = Some(header.r#type);
9436 let res = match header.r#type {
9437 50u16 => DlDpipeHeaders::DpipeHeader({
9438 let res = Some(IterableDlDpipeHeader::with_loc(next, self.orig_loc));
9439 let Some(val) = res else { break };
9440 val
9441 }),
9442 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
9443 n => continue,
9444 };
9445 return Some(Ok(res));
9446 }
9447 Some(Err(ErrorContext::new(
9448 "DlDpipeHeaders",
9449 r#type.and_then(|t| DlDpipeHeaders::attr_from_type(t)),
9450 self.orig_loc,
9451 self.buf.as_ptr().wrapping_add(pos) as usize,
9452 )))
9453 }
9454}
9455impl<'a> std::fmt::Debug for IterableDlDpipeHeaders<'_> {
9456 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9457 let mut fmt = f.debug_struct("DlDpipeHeaders");
9458 for attr in self.clone() {
9459 let attr = match attr {
9460 Ok(a) => a,
9461 Err(err) => {
9462 fmt.finish()?;
9463 f.write_str("Err(")?;
9464 err.fmt(f)?;
9465 return f.write_str(")");
9466 }
9467 };
9468 match attr {
9469 DlDpipeHeaders::DpipeHeader(val) => fmt.field("DpipeHeader", &val),
9470 };
9471 }
9472 fmt.finish()
9473 }
9474}
9475impl IterableDlDpipeHeaders<'_> {
9476 pub fn lookup_attr(
9477 &self,
9478 offset: usize,
9479 missing_type: Option<u16>,
9480 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
9481 let mut stack = Vec::new();
9482 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
9483 if missing_type.is_some() && cur == offset {
9484 stack.push(("DlDpipeHeaders", offset));
9485 return (
9486 stack,
9487 missing_type.and_then(|t| DlDpipeHeaders::attr_from_type(t)),
9488 );
9489 }
9490 if cur > offset || cur + self.buf.len() < offset {
9491 return (stack, None);
9492 }
9493 let mut attrs = self.clone();
9494 let mut last_off = cur + attrs.pos;
9495 let mut missing = None;
9496 while let Some(attr) = attrs.next() {
9497 let Ok(attr) = attr else { break };
9498 match attr {
9499 DlDpipeHeaders::DpipeHeader(val) => {
9500 (stack, missing) = val.lookup_attr(offset, missing_type);
9501 if !stack.is_empty() {
9502 break;
9503 }
9504 }
9505 _ => {}
9506 };
9507 last_off = cur + attrs.pos;
9508 }
9509 if !stack.is_empty() {
9510 stack.push(("DlDpipeHeaders", cur));
9511 }
9512 (stack, missing)
9513 }
9514}
9515#[derive(Clone)]
9516pub enum DlDpipeHeader<'a> {
9517 DpipeHeaderName(&'a CStr),
9518 #[doc = "Associated type: [`DpipeHeaderId`] (enum)"]
9519 DpipeHeaderId(u32),
9520 DpipeHeaderFields(IterableDlDpipeHeaderFields<'a>),
9521 DpipeHeaderGlobal(u8),
9522}
9523impl<'a> IterableDlDpipeHeader<'a> {
9524 pub fn get_dpipe_header_name(&self) -> Result<&'a CStr, ErrorContext> {
9525 let mut iter = self.clone();
9526 iter.pos = 0;
9527 for attr in iter {
9528 if let Ok(DlDpipeHeader::DpipeHeaderName(val)) = attr {
9529 return Ok(val);
9530 }
9531 }
9532 Err(ErrorContext::new_missing(
9533 "DlDpipeHeader",
9534 "DpipeHeaderName",
9535 self.orig_loc,
9536 self.buf.as_ptr() as usize,
9537 ))
9538 }
9539 #[doc = "Associated type: [`DpipeHeaderId`] (enum)"]
9540 pub fn get_dpipe_header_id(&self) -> Result<u32, ErrorContext> {
9541 let mut iter = self.clone();
9542 iter.pos = 0;
9543 for attr in iter {
9544 if let Ok(DlDpipeHeader::DpipeHeaderId(val)) = attr {
9545 return Ok(val);
9546 }
9547 }
9548 Err(ErrorContext::new_missing(
9549 "DlDpipeHeader",
9550 "DpipeHeaderId",
9551 self.orig_loc,
9552 self.buf.as_ptr() as usize,
9553 ))
9554 }
9555 pub fn get_dpipe_header_fields(&self) -> Result<IterableDlDpipeHeaderFields<'a>, ErrorContext> {
9556 let mut iter = self.clone();
9557 iter.pos = 0;
9558 for attr in iter {
9559 if let Ok(DlDpipeHeader::DpipeHeaderFields(val)) = attr {
9560 return Ok(val);
9561 }
9562 }
9563 Err(ErrorContext::new_missing(
9564 "DlDpipeHeader",
9565 "DpipeHeaderFields",
9566 self.orig_loc,
9567 self.buf.as_ptr() as usize,
9568 ))
9569 }
9570 pub fn get_dpipe_header_global(&self) -> Result<u8, ErrorContext> {
9571 let mut iter = self.clone();
9572 iter.pos = 0;
9573 for attr in iter {
9574 if let Ok(DlDpipeHeader::DpipeHeaderGlobal(val)) = attr {
9575 return Ok(val);
9576 }
9577 }
9578 Err(ErrorContext::new_missing(
9579 "DlDpipeHeader",
9580 "DpipeHeaderGlobal",
9581 self.orig_loc,
9582 self.buf.as_ptr() as usize,
9583 ))
9584 }
9585}
9586impl DlDpipeHeader<'_> {
9587 pub fn new<'a>(buf: &'a [u8]) -> IterableDlDpipeHeader<'a> {
9588 IterableDlDpipeHeader::with_loc(buf, buf.as_ptr() as usize)
9589 }
9590 fn attr_from_type(r#type: u16) -> Option<&'static str> {
9591 Devlink::attr_from_type(r#type)
9592 }
9593}
9594#[derive(Clone, Copy, Default)]
9595pub struct IterableDlDpipeHeader<'a> {
9596 buf: &'a [u8],
9597 pos: usize,
9598 orig_loc: usize,
9599}
9600impl<'a> IterableDlDpipeHeader<'a> {
9601 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
9602 Self {
9603 buf,
9604 pos: 0,
9605 orig_loc,
9606 }
9607 }
9608 pub fn get_buf(&self) -> &'a [u8] {
9609 self.buf
9610 }
9611}
9612impl<'a> Iterator for IterableDlDpipeHeader<'a> {
9613 type Item = Result<DlDpipeHeader<'a>, ErrorContext>;
9614 fn next(&mut self) -> Option<Self::Item> {
9615 let mut pos;
9616 let mut r#type;
9617 loop {
9618 pos = self.pos;
9619 r#type = None;
9620 if self.buf.len() == self.pos {
9621 return None;
9622 }
9623 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
9624 self.pos = self.buf.len();
9625 break;
9626 };
9627 r#type = Some(header.r#type);
9628 let res = match header.r#type {
9629 51u16 => DlDpipeHeader::DpipeHeaderName({
9630 let res = CStr::from_bytes_with_nul(next).ok();
9631 let Some(val) = res else { break };
9632 val
9633 }),
9634 52u16 => DlDpipeHeader::DpipeHeaderId({
9635 let res = parse_u32(next);
9636 let Some(val) = res else { break };
9637 val
9638 }),
9639 53u16 => DlDpipeHeader::DpipeHeaderFields({
9640 let res = Some(IterableDlDpipeHeaderFields::with_loc(next, self.orig_loc));
9641 let Some(val) = res else { break };
9642 val
9643 }),
9644 54u16 => DlDpipeHeader::DpipeHeaderGlobal({
9645 let res = parse_u8(next);
9646 let Some(val) = res else { break };
9647 val
9648 }),
9649 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
9650 n => continue,
9651 };
9652 return Some(Ok(res));
9653 }
9654 Some(Err(ErrorContext::new(
9655 "DlDpipeHeader",
9656 r#type.and_then(|t| DlDpipeHeader::attr_from_type(t)),
9657 self.orig_loc,
9658 self.buf.as_ptr().wrapping_add(pos) as usize,
9659 )))
9660 }
9661}
9662impl<'a> std::fmt::Debug for IterableDlDpipeHeader<'_> {
9663 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9664 let mut fmt = f.debug_struct("DlDpipeHeader");
9665 for attr in self.clone() {
9666 let attr = match attr {
9667 Ok(a) => a,
9668 Err(err) => {
9669 fmt.finish()?;
9670 f.write_str("Err(")?;
9671 err.fmt(f)?;
9672 return f.write_str(")");
9673 }
9674 };
9675 match attr {
9676 DlDpipeHeader::DpipeHeaderName(val) => fmt.field("DpipeHeaderName", &val),
9677 DlDpipeHeader::DpipeHeaderId(val) => fmt.field(
9678 "DpipeHeaderId",
9679 &FormatEnum(val.into(), DpipeHeaderId::from_value),
9680 ),
9681 DlDpipeHeader::DpipeHeaderFields(val) => fmt.field("DpipeHeaderFields", &val),
9682 DlDpipeHeader::DpipeHeaderGlobal(val) => fmt.field("DpipeHeaderGlobal", &val),
9683 };
9684 }
9685 fmt.finish()
9686 }
9687}
9688impl IterableDlDpipeHeader<'_> {
9689 pub fn lookup_attr(
9690 &self,
9691 offset: usize,
9692 missing_type: Option<u16>,
9693 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
9694 let mut stack = Vec::new();
9695 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
9696 if missing_type.is_some() && cur == offset {
9697 stack.push(("DlDpipeHeader", offset));
9698 return (
9699 stack,
9700 missing_type.and_then(|t| DlDpipeHeader::attr_from_type(t)),
9701 );
9702 }
9703 if cur > offset || cur + self.buf.len() < offset {
9704 return (stack, None);
9705 }
9706 let mut attrs = self.clone();
9707 let mut last_off = cur + attrs.pos;
9708 let mut missing = None;
9709 while let Some(attr) = attrs.next() {
9710 let Ok(attr) = attr else { break };
9711 match attr {
9712 DlDpipeHeader::DpipeHeaderName(val) => {
9713 if last_off == offset {
9714 stack.push(("DpipeHeaderName", last_off));
9715 break;
9716 }
9717 }
9718 DlDpipeHeader::DpipeHeaderId(val) => {
9719 if last_off == offset {
9720 stack.push(("DpipeHeaderId", last_off));
9721 break;
9722 }
9723 }
9724 DlDpipeHeader::DpipeHeaderFields(val) => {
9725 (stack, missing) = val.lookup_attr(offset, missing_type);
9726 if !stack.is_empty() {
9727 break;
9728 }
9729 }
9730 DlDpipeHeader::DpipeHeaderGlobal(val) => {
9731 if last_off == offset {
9732 stack.push(("DpipeHeaderGlobal", last_off));
9733 break;
9734 }
9735 }
9736 _ => {}
9737 };
9738 last_off = cur + attrs.pos;
9739 }
9740 if !stack.is_empty() {
9741 stack.push(("DlDpipeHeader", cur));
9742 }
9743 (stack, missing)
9744 }
9745}
9746#[derive(Clone)]
9747pub enum DlDpipeHeaderFields<'a> {
9748 #[doc = "Attribute may repeat multiple times (treat it as array)"]
9749 DpipeField(IterableDlDpipeField<'a>),
9750}
9751impl<'a> IterableDlDpipeHeaderFields<'a> {
9752 #[doc = "Attribute may repeat multiple times (treat it as array)"]
9753 pub fn get_dpipe_field(
9754 &self,
9755 ) -> MultiAttrIterable<Self, DlDpipeHeaderFields<'a>, IterableDlDpipeField<'a>> {
9756 MultiAttrIterable::new(self.clone(), |variant| {
9757 if let DlDpipeHeaderFields::DpipeField(val) = variant {
9758 Some(val)
9759 } else {
9760 None
9761 }
9762 })
9763 }
9764}
9765impl DlDpipeHeaderFields<'_> {
9766 pub fn new<'a>(buf: &'a [u8]) -> IterableDlDpipeHeaderFields<'a> {
9767 IterableDlDpipeHeaderFields::with_loc(buf, buf.as_ptr() as usize)
9768 }
9769 fn attr_from_type(r#type: u16) -> Option<&'static str> {
9770 Devlink::attr_from_type(r#type)
9771 }
9772}
9773#[derive(Clone, Copy, Default)]
9774pub struct IterableDlDpipeHeaderFields<'a> {
9775 buf: &'a [u8],
9776 pos: usize,
9777 orig_loc: usize,
9778}
9779impl<'a> IterableDlDpipeHeaderFields<'a> {
9780 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
9781 Self {
9782 buf,
9783 pos: 0,
9784 orig_loc,
9785 }
9786 }
9787 pub fn get_buf(&self) -> &'a [u8] {
9788 self.buf
9789 }
9790}
9791impl<'a> Iterator for IterableDlDpipeHeaderFields<'a> {
9792 type Item = Result<DlDpipeHeaderFields<'a>, ErrorContext>;
9793 fn next(&mut self) -> Option<Self::Item> {
9794 let mut pos;
9795 let mut r#type;
9796 loop {
9797 pos = self.pos;
9798 r#type = None;
9799 if self.buf.len() == self.pos {
9800 return None;
9801 }
9802 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
9803 self.pos = self.buf.len();
9804 break;
9805 };
9806 r#type = Some(header.r#type);
9807 let res = match header.r#type {
9808 56u16 => DlDpipeHeaderFields::DpipeField({
9809 let res = Some(IterableDlDpipeField::with_loc(next, self.orig_loc));
9810 let Some(val) = res else { break };
9811 val
9812 }),
9813 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
9814 n => continue,
9815 };
9816 return Some(Ok(res));
9817 }
9818 Some(Err(ErrorContext::new(
9819 "DlDpipeHeaderFields",
9820 r#type.and_then(|t| DlDpipeHeaderFields::attr_from_type(t)),
9821 self.orig_loc,
9822 self.buf.as_ptr().wrapping_add(pos) as usize,
9823 )))
9824 }
9825}
9826impl<'a> std::fmt::Debug for IterableDlDpipeHeaderFields<'_> {
9827 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9828 let mut fmt = f.debug_struct("DlDpipeHeaderFields");
9829 for attr in self.clone() {
9830 let attr = match attr {
9831 Ok(a) => a,
9832 Err(err) => {
9833 fmt.finish()?;
9834 f.write_str("Err(")?;
9835 err.fmt(f)?;
9836 return f.write_str(")");
9837 }
9838 };
9839 match attr {
9840 DlDpipeHeaderFields::DpipeField(val) => fmt.field("DpipeField", &val),
9841 };
9842 }
9843 fmt.finish()
9844 }
9845}
9846impl IterableDlDpipeHeaderFields<'_> {
9847 pub fn lookup_attr(
9848 &self,
9849 offset: usize,
9850 missing_type: Option<u16>,
9851 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
9852 let mut stack = Vec::new();
9853 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
9854 if missing_type.is_some() && cur == offset {
9855 stack.push(("DlDpipeHeaderFields", offset));
9856 return (
9857 stack,
9858 missing_type.and_then(|t| DlDpipeHeaderFields::attr_from_type(t)),
9859 );
9860 }
9861 if cur > offset || cur + self.buf.len() < offset {
9862 return (stack, None);
9863 }
9864 let mut attrs = self.clone();
9865 let mut last_off = cur + attrs.pos;
9866 let mut missing = None;
9867 while let Some(attr) = attrs.next() {
9868 let Ok(attr) = attr else { break };
9869 match attr {
9870 DlDpipeHeaderFields::DpipeField(val) => {
9871 (stack, missing) = val.lookup_attr(offset, missing_type);
9872 if !stack.is_empty() {
9873 break;
9874 }
9875 }
9876 _ => {}
9877 };
9878 last_off = cur + attrs.pos;
9879 }
9880 if !stack.is_empty() {
9881 stack.push(("DlDpipeHeaderFields", cur));
9882 }
9883 (stack, missing)
9884 }
9885}
9886#[derive(Clone)]
9887pub enum DlDpipeField<'a> {
9888 DpipeFieldName(&'a CStr),
9889 DpipeFieldId(u32),
9890 DpipeFieldBitwidth(u32),
9891 #[doc = "Associated type: [`DpipeFieldMappingType`] (enum)"]
9892 DpipeFieldMappingType(u32),
9893}
9894impl<'a> IterableDlDpipeField<'a> {
9895 pub fn get_dpipe_field_name(&self) -> Result<&'a CStr, ErrorContext> {
9896 let mut iter = self.clone();
9897 iter.pos = 0;
9898 for attr in iter {
9899 if let Ok(DlDpipeField::DpipeFieldName(val)) = attr {
9900 return Ok(val);
9901 }
9902 }
9903 Err(ErrorContext::new_missing(
9904 "DlDpipeField",
9905 "DpipeFieldName",
9906 self.orig_loc,
9907 self.buf.as_ptr() as usize,
9908 ))
9909 }
9910 pub fn get_dpipe_field_id(&self) -> Result<u32, ErrorContext> {
9911 let mut iter = self.clone();
9912 iter.pos = 0;
9913 for attr in iter {
9914 if let Ok(DlDpipeField::DpipeFieldId(val)) = attr {
9915 return Ok(val);
9916 }
9917 }
9918 Err(ErrorContext::new_missing(
9919 "DlDpipeField",
9920 "DpipeFieldId",
9921 self.orig_loc,
9922 self.buf.as_ptr() as usize,
9923 ))
9924 }
9925 pub fn get_dpipe_field_bitwidth(&self) -> Result<u32, ErrorContext> {
9926 let mut iter = self.clone();
9927 iter.pos = 0;
9928 for attr in iter {
9929 if let Ok(DlDpipeField::DpipeFieldBitwidth(val)) = attr {
9930 return Ok(val);
9931 }
9932 }
9933 Err(ErrorContext::new_missing(
9934 "DlDpipeField",
9935 "DpipeFieldBitwidth",
9936 self.orig_loc,
9937 self.buf.as_ptr() as usize,
9938 ))
9939 }
9940 #[doc = "Associated type: [`DpipeFieldMappingType`] (enum)"]
9941 pub fn get_dpipe_field_mapping_type(&self) -> Result<u32, ErrorContext> {
9942 let mut iter = self.clone();
9943 iter.pos = 0;
9944 for attr in iter {
9945 if let Ok(DlDpipeField::DpipeFieldMappingType(val)) = attr {
9946 return Ok(val);
9947 }
9948 }
9949 Err(ErrorContext::new_missing(
9950 "DlDpipeField",
9951 "DpipeFieldMappingType",
9952 self.orig_loc,
9953 self.buf.as_ptr() as usize,
9954 ))
9955 }
9956}
9957impl DlDpipeField<'_> {
9958 pub fn new<'a>(buf: &'a [u8]) -> IterableDlDpipeField<'a> {
9959 IterableDlDpipeField::with_loc(buf, buf.as_ptr() as usize)
9960 }
9961 fn attr_from_type(r#type: u16) -> Option<&'static str> {
9962 Devlink::attr_from_type(r#type)
9963 }
9964}
9965#[derive(Clone, Copy, Default)]
9966pub struct IterableDlDpipeField<'a> {
9967 buf: &'a [u8],
9968 pos: usize,
9969 orig_loc: usize,
9970}
9971impl<'a> IterableDlDpipeField<'a> {
9972 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
9973 Self {
9974 buf,
9975 pos: 0,
9976 orig_loc,
9977 }
9978 }
9979 pub fn get_buf(&self) -> &'a [u8] {
9980 self.buf
9981 }
9982}
9983impl<'a> Iterator for IterableDlDpipeField<'a> {
9984 type Item = Result<DlDpipeField<'a>, ErrorContext>;
9985 fn next(&mut self) -> Option<Self::Item> {
9986 let mut pos;
9987 let mut r#type;
9988 loop {
9989 pos = self.pos;
9990 r#type = None;
9991 if self.buf.len() == self.pos {
9992 return None;
9993 }
9994 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
9995 self.pos = self.buf.len();
9996 break;
9997 };
9998 r#type = Some(header.r#type);
9999 let res = match header.r#type {
10000 57u16 => DlDpipeField::DpipeFieldName({
10001 let res = CStr::from_bytes_with_nul(next).ok();
10002 let Some(val) = res else { break };
10003 val
10004 }),
10005 58u16 => DlDpipeField::DpipeFieldId({
10006 let res = parse_u32(next);
10007 let Some(val) = res else { break };
10008 val
10009 }),
10010 59u16 => DlDpipeField::DpipeFieldBitwidth({
10011 let res = parse_u32(next);
10012 let Some(val) = res else { break };
10013 val
10014 }),
10015 60u16 => DlDpipeField::DpipeFieldMappingType({
10016 let res = parse_u32(next);
10017 let Some(val) = res else { break };
10018 val
10019 }),
10020 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
10021 n => continue,
10022 };
10023 return Some(Ok(res));
10024 }
10025 Some(Err(ErrorContext::new(
10026 "DlDpipeField",
10027 r#type.and_then(|t| DlDpipeField::attr_from_type(t)),
10028 self.orig_loc,
10029 self.buf.as_ptr().wrapping_add(pos) as usize,
10030 )))
10031 }
10032}
10033impl<'a> std::fmt::Debug for IterableDlDpipeField<'_> {
10034 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10035 let mut fmt = f.debug_struct("DlDpipeField");
10036 for attr in self.clone() {
10037 let attr = match attr {
10038 Ok(a) => a,
10039 Err(err) => {
10040 fmt.finish()?;
10041 f.write_str("Err(")?;
10042 err.fmt(f)?;
10043 return f.write_str(")");
10044 }
10045 };
10046 match attr {
10047 DlDpipeField::DpipeFieldName(val) => fmt.field("DpipeFieldName", &val),
10048 DlDpipeField::DpipeFieldId(val) => fmt.field("DpipeFieldId", &val),
10049 DlDpipeField::DpipeFieldBitwidth(val) => fmt.field("DpipeFieldBitwidth", &val),
10050 DlDpipeField::DpipeFieldMappingType(val) => fmt.field(
10051 "DpipeFieldMappingType",
10052 &FormatEnum(val.into(), DpipeFieldMappingType::from_value),
10053 ),
10054 };
10055 }
10056 fmt.finish()
10057 }
10058}
10059impl IterableDlDpipeField<'_> {
10060 pub fn lookup_attr(
10061 &self,
10062 offset: usize,
10063 missing_type: Option<u16>,
10064 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
10065 let mut stack = Vec::new();
10066 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
10067 if missing_type.is_some() && cur == offset {
10068 stack.push(("DlDpipeField", offset));
10069 return (
10070 stack,
10071 missing_type.and_then(|t| DlDpipeField::attr_from_type(t)),
10072 );
10073 }
10074 if cur > offset || cur + self.buf.len() < offset {
10075 return (stack, None);
10076 }
10077 let mut attrs = self.clone();
10078 let mut last_off = cur + attrs.pos;
10079 while let Some(attr) = attrs.next() {
10080 let Ok(attr) = attr else { break };
10081 match attr {
10082 DlDpipeField::DpipeFieldName(val) => {
10083 if last_off == offset {
10084 stack.push(("DpipeFieldName", last_off));
10085 break;
10086 }
10087 }
10088 DlDpipeField::DpipeFieldId(val) => {
10089 if last_off == offset {
10090 stack.push(("DpipeFieldId", last_off));
10091 break;
10092 }
10093 }
10094 DlDpipeField::DpipeFieldBitwidth(val) => {
10095 if last_off == offset {
10096 stack.push(("DpipeFieldBitwidth", last_off));
10097 break;
10098 }
10099 }
10100 DlDpipeField::DpipeFieldMappingType(val) => {
10101 if last_off == offset {
10102 stack.push(("DpipeFieldMappingType", last_off));
10103 break;
10104 }
10105 }
10106 _ => {}
10107 };
10108 last_off = cur + attrs.pos;
10109 }
10110 if !stack.is_empty() {
10111 stack.push(("DlDpipeField", cur));
10112 }
10113 (stack, None)
10114 }
10115}
10116#[derive(Clone)]
10117pub enum DlResource<'a> {
10118 ResourceName(&'a CStr),
10119 ResourceId(u64),
10120 ResourceSize(u64),
10121 ResourceSizeNew(u64),
10122 ResourceSizeValid(u8),
10123 ResourceSizeMin(u64),
10124 ResourceSizeMax(u64),
10125 ResourceSizeGran(u64),
10126 #[doc = "Associated type: [`ResourceUnit`] (enum)"]
10127 ResourceUnit(u8),
10128 ResourceOcc(u64),
10129}
10130impl<'a> IterableDlResource<'a> {
10131 pub fn get_resource_name(&self) -> Result<&'a CStr, ErrorContext> {
10132 let mut iter = self.clone();
10133 iter.pos = 0;
10134 for attr in iter {
10135 if let Ok(DlResource::ResourceName(val)) = attr {
10136 return Ok(val);
10137 }
10138 }
10139 Err(ErrorContext::new_missing(
10140 "DlResource",
10141 "ResourceName",
10142 self.orig_loc,
10143 self.buf.as_ptr() as usize,
10144 ))
10145 }
10146 pub fn get_resource_id(&self) -> Result<u64, ErrorContext> {
10147 let mut iter = self.clone();
10148 iter.pos = 0;
10149 for attr in iter {
10150 if let Ok(DlResource::ResourceId(val)) = attr {
10151 return Ok(val);
10152 }
10153 }
10154 Err(ErrorContext::new_missing(
10155 "DlResource",
10156 "ResourceId",
10157 self.orig_loc,
10158 self.buf.as_ptr() as usize,
10159 ))
10160 }
10161 pub fn get_resource_size(&self) -> Result<u64, ErrorContext> {
10162 let mut iter = self.clone();
10163 iter.pos = 0;
10164 for attr in iter {
10165 if let Ok(DlResource::ResourceSize(val)) = attr {
10166 return Ok(val);
10167 }
10168 }
10169 Err(ErrorContext::new_missing(
10170 "DlResource",
10171 "ResourceSize",
10172 self.orig_loc,
10173 self.buf.as_ptr() as usize,
10174 ))
10175 }
10176 pub fn get_resource_size_new(&self) -> Result<u64, ErrorContext> {
10177 let mut iter = self.clone();
10178 iter.pos = 0;
10179 for attr in iter {
10180 if let Ok(DlResource::ResourceSizeNew(val)) = attr {
10181 return Ok(val);
10182 }
10183 }
10184 Err(ErrorContext::new_missing(
10185 "DlResource",
10186 "ResourceSizeNew",
10187 self.orig_loc,
10188 self.buf.as_ptr() as usize,
10189 ))
10190 }
10191 pub fn get_resource_size_valid(&self) -> Result<u8, ErrorContext> {
10192 let mut iter = self.clone();
10193 iter.pos = 0;
10194 for attr in iter {
10195 if let Ok(DlResource::ResourceSizeValid(val)) = attr {
10196 return Ok(val);
10197 }
10198 }
10199 Err(ErrorContext::new_missing(
10200 "DlResource",
10201 "ResourceSizeValid",
10202 self.orig_loc,
10203 self.buf.as_ptr() as usize,
10204 ))
10205 }
10206 pub fn get_resource_size_min(&self) -> Result<u64, ErrorContext> {
10207 let mut iter = self.clone();
10208 iter.pos = 0;
10209 for attr in iter {
10210 if let Ok(DlResource::ResourceSizeMin(val)) = attr {
10211 return Ok(val);
10212 }
10213 }
10214 Err(ErrorContext::new_missing(
10215 "DlResource",
10216 "ResourceSizeMin",
10217 self.orig_loc,
10218 self.buf.as_ptr() as usize,
10219 ))
10220 }
10221 pub fn get_resource_size_max(&self) -> Result<u64, ErrorContext> {
10222 let mut iter = self.clone();
10223 iter.pos = 0;
10224 for attr in iter {
10225 if let Ok(DlResource::ResourceSizeMax(val)) = attr {
10226 return Ok(val);
10227 }
10228 }
10229 Err(ErrorContext::new_missing(
10230 "DlResource",
10231 "ResourceSizeMax",
10232 self.orig_loc,
10233 self.buf.as_ptr() as usize,
10234 ))
10235 }
10236 pub fn get_resource_size_gran(&self) -> Result<u64, ErrorContext> {
10237 let mut iter = self.clone();
10238 iter.pos = 0;
10239 for attr in iter {
10240 if let Ok(DlResource::ResourceSizeGran(val)) = attr {
10241 return Ok(val);
10242 }
10243 }
10244 Err(ErrorContext::new_missing(
10245 "DlResource",
10246 "ResourceSizeGran",
10247 self.orig_loc,
10248 self.buf.as_ptr() as usize,
10249 ))
10250 }
10251 #[doc = "Associated type: [`ResourceUnit`] (enum)"]
10252 pub fn get_resource_unit(&self) -> Result<u8, ErrorContext> {
10253 let mut iter = self.clone();
10254 iter.pos = 0;
10255 for attr in iter {
10256 if let Ok(DlResource::ResourceUnit(val)) = attr {
10257 return Ok(val);
10258 }
10259 }
10260 Err(ErrorContext::new_missing(
10261 "DlResource",
10262 "ResourceUnit",
10263 self.orig_loc,
10264 self.buf.as_ptr() as usize,
10265 ))
10266 }
10267 pub fn get_resource_occ(&self) -> Result<u64, ErrorContext> {
10268 let mut iter = self.clone();
10269 iter.pos = 0;
10270 for attr in iter {
10271 if let Ok(DlResource::ResourceOcc(val)) = attr {
10272 return Ok(val);
10273 }
10274 }
10275 Err(ErrorContext::new_missing(
10276 "DlResource",
10277 "ResourceOcc",
10278 self.orig_loc,
10279 self.buf.as_ptr() as usize,
10280 ))
10281 }
10282}
10283impl DlResource<'_> {
10284 pub fn new<'a>(buf: &'a [u8]) -> IterableDlResource<'a> {
10285 IterableDlResource::with_loc(buf, buf.as_ptr() as usize)
10286 }
10287 fn attr_from_type(r#type: u16) -> Option<&'static str> {
10288 Devlink::attr_from_type(r#type)
10289 }
10290}
10291#[derive(Clone, Copy, Default)]
10292pub struct IterableDlResource<'a> {
10293 buf: &'a [u8],
10294 pos: usize,
10295 orig_loc: usize,
10296}
10297impl<'a> IterableDlResource<'a> {
10298 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
10299 Self {
10300 buf,
10301 pos: 0,
10302 orig_loc,
10303 }
10304 }
10305 pub fn get_buf(&self) -> &'a [u8] {
10306 self.buf
10307 }
10308}
10309impl<'a> Iterator for IterableDlResource<'a> {
10310 type Item = Result<DlResource<'a>, ErrorContext>;
10311 fn next(&mut self) -> Option<Self::Item> {
10312 let mut pos;
10313 let mut r#type;
10314 loop {
10315 pos = self.pos;
10316 r#type = None;
10317 if self.buf.len() == self.pos {
10318 return None;
10319 }
10320 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
10321 self.pos = self.buf.len();
10322 break;
10323 };
10324 r#type = Some(header.r#type);
10325 let res = match header.r#type {
10326 65u16 => DlResource::ResourceName({
10327 let res = CStr::from_bytes_with_nul(next).ok();
10328 let Some(val) = res else { break };
10329 val
10330 }),
10331 66u16 => DlResource::ResourceId({
10332 let res = parse_u64(next);
10333 let Some(val) = res else { break };
10334 val
10335 }),
10336 67u16 => DlResource::ResourceSize({
10337 let res = parse_u64(next);
10338 let Some(val) = res else { break };
10339 val
10340 }),
10341 68u16 => DlResource::ResourceSizeNew({
10342 let res = parse_u64(next);
10343 let Some(val) = res else { break };
10344 val
10345 }),
10346 69u16 => DlResource::ResourceSizeValid({
10347 let res = parse_u8(next);
10348 let Some(val) = res else { break };
10349 val
10350 }),
10351 70u16 => DlResource::ResourceSizeMin({
10352 let res = parse_u64(next);
10353 let Some(val) = res else { break };
10354 val
10355 }),
10356 71u16 => DlResource::ResourceSizeMax({
10357 let res = parse_u64(next);
10358 let Some(val) = res else { break };
10359 val
10360 }),
10361 72u16 => DlResource::ResourceSizeGran({
10362 let res = parse_u64(next);
10363 let Some(val) = res else { break };
10364 val
10365 }),
10366 73u16 => DlResource::ResourceUnit({
10367 let res = parse_u8(next);
10368 let Some(val) = res else { break };
10369 val
10370 }),
10371 74u16 => DlResource::ResourceOcc({
10372 let res = parse_u64(next);
10373 let Some(val) = res else { break };
10374 val
10375 }),
10376 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
10377 n => continue,
10378 };
10379 return Some(Ok(res));
10380 }
10381 Some(Err(ErrorContext::new(
10382 "DlResource",
10383 r#type.and_then(|t| DlResource::attr_from_type(t)),
10384 self.orig_loc,
10385 self.buf.as_ptr().wrapping_add(pos) as usize,
10386 )))
10387 }
10388}
10389impl<'a> std::fmt::Debug for IterableDlResource<'_> {
10390 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10391 let mut fmt = f.debug_struct("DlResource");
10392 for attr in self.clone() {
10393 let attr = match attr {
10394 Ok(a) => a,
10395 Err(err) => {
10396 fmt.finish()?;
10397 f.write_str("Err(")?;
10398 err.fmt(f)?;
10399 return f.write_str(")");
10400 }
10401 };
10402 match attr {
10403 DlResource::ResourceName(val) => fmt.field("ResourceName", &val),
10404 DlResource::ResourceId(val) => fmt.field("ResourceId", &val),
10405 DlResource::ResourceSize(val) => fmt.field("ResourceSize", &val),
10406 DlResource::ResourceSizeNew(val) => fmt.field("ResourceSizeNew", &val),
10407 DlResource::ResourceSizeValid(val) => fmt.field("ResourceSizeValid", &val),
10408 DlResource::ResourceSizeMin(val) => fmt.field("ResourceSizeMin", &val),
10409 DlResource::ResourceSizeMax(val) => fmt.field("ResourceSizeMax", &val),
10410 DlResource::ResourceSizeGran(val) => fmt.field("ResourceSizeGran", &val),
10411 DlResource::ResourceUnit(val) => fmt.field(
10412 "ResourceUnit",
10413 &FormatEnum(val.into(), ResourceUnit::from_value),
10414 ),
10415 DlResource::ResourceOcc(val) => fmt.field("ResourceOcc", &val),
10416 };
10417 }
10418 fmt.finish()
10419 }
10420}
10421impl IterableDlResource<'_> {
10422 pub fn lookup_attr(
10423 &self,
10424 offset: usize,
10425 missing_type: Option<u16>,
10426 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
10427 let mut stack = Vec::new();
10428 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
10429 if missing_type.is_some() && cur == offset {
10430 stack.push(("DlResource", offset));
10431 return (
10432 stack,
10433 missing_type.and_then(|t| DlResource::attr_from_type(t)),
10434 );
10435 }
10436 if cur > offset || cur + self.buf.len() < offset {
10437 return (stack, None);
10438 }
10439 let mut attrs = self.clone();
10440 let mut last_off = cur + attrs.pos;
10441 while let Some(attr) = attrs.next() {
10442 let Ok(attr) = attr else { break };
10443 match attr {
10444 DlResource::ResourceName(val) => {
10445 if last_off == offset {
10446 stack.push(("ResourceName", last_off));
10447 break;
10448 }
10449 }
10450 DlResource::ResourceId(val) => {
10451 if last_off == offset {
10452 stack.push(("ResourceId", last_off));
10453 break;
10454 }
10455 }
10456 DlResource::ResourceSize(val) => {
10457 if last_off == offset {
10458 stack.push(("ResourceSize", last_off));
10459 break;
10460 }
10461 }
10462 DlResource::ResourceSizeNew(val) => {
10463 if last_off == offset {
10464 stack.push(("ResourceSizeNew", last_off));
10465 break;
10466 }
10467 }
10468 DlResource::ResourceSizeValid(val) => {
10469 if last_off == offset {
10470 stack.push(("ResourceSizeValid", last_off));
10471 break;
10472 }
10473 }
10474 DlResource::ResourceSizeMin(val) => {
10475 if last_off == offset {
10476 stack.push(("ResourceSizeMin", last_off));
10477 break;
10478 }
10479 }
10480 DlResource::ResourceSizeMax(val) => {
10481 if last_off == offset {
10482 stack.push(("ResourceSizeMax", last_off));
10483 break;
10484 }
10485 }
10486 DlResource::ResourceSizeGran(val) => {
10487 if last_off == offset {
10488 stack.push(("ResourceSizeGran", last_off));
10489 break;
10490 }
10491 }
10492 DlResource::ResourceUnit(val) => {
10493 if last_off == offset {
10494 stack.push(("ResourceUnit", last_off));
10495 break;
10496 }
10497 }
10498 DlResource::ResourceOcc(val) => {
10499 if last_off == offset {
10500 stack.push(("ResourceOcc", last_off));
10501 break;
10502 }
10503 }
10504 _ => {}
10505 };
10506 last_off = cur + attrs.pos;
10507 }
10508 if !stack.is_empty() {
10509 stack.push(("DlResource", cur));
10510 }
10511 (stack, None)
10512 }
10513}
10514#[derive(Clone)]
10515pub enum DlResourceList<'a> {
10516 #[doc = "Attribute may repeat multiple times (treat it as array)"]
10517 Resource(IterableDlResource<'a>),
10518}
10519impl<'a> IterableDlResourceList<'a> {
10520 #[doc = "Attribute may repeat multiple times (treat it as array)"]
10521 pub fn get_resource(
10522 &self,
10523 ) -> MultiAttrIterable<Self, DlResourceList<'a>, IterableDlResource<'a>> {
10524 MultiAttrIterable::new(self.clone(), |variant| {
10525 if let DlResourceList::Resource(val) = variant {
10526 Some(val)
10527 } else {
10528 None
10529 }
10530 })
10531 }
10532}
10533impl DlResourceList<'_> {
10534 pub fn new<'a>(buf: &'a [u8]) -> IterableDlResourceList<'a> {
10535 IterableDlResourceList::with_loc(buf, buf.as_ptr() as usize)
10536 }
10537 fn attr_from_type(r#type: u16) -> Option<&'static str> {
10538 Devlink::attr_from_type(r#type)
10539 }
10540}
10541#[derive(Clone, Copy, Default)]
10542pub struct IterableDlResourceList<'a> {
10543 buf: &'a [u8],
10544 pos: usize,
10545 orig_loc: usize,
10546}
10547impl<'a> IterableDlResourceList<'a> {
10548 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
10549 Self {
10550 buf,
10551 pos: 0,
10552 orig_loc,
10553 }
10554 }
10555 pub fn get_buf(&self) -> &'a [u8] {
10556 self.buf
10557 }
10558}
10559impl<'a> Iterator for IterableDlResourceList<'a> {
10560 type Item = Result<DlResourceList<'a>, ErrorContext>;
10561 fn next(&mut self) -> Option<Self::Item> {
10562 let mut pos;
10563 let mut r#type;
10564 loop {
10565 pos = self.pos;
10566 r#type = None;
10567 if self.buf.len() == self.pos {
10568 return None;
10569 }
10570 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
10571 self.pos = self.buf.len();
10572 break;
10573 };
10574 r#type = Some(header.r#type);
10575 let res = match header.r#type {
10576 64u16 => DlResourceList::Resource({
10577 let res = Some(IterableDlResource::with_loc(next, self.orig_loc));
10578 let Some(val) = res else { break };
10579 val
10580 }),
10581 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
10582 n => continue,
10583 };
10584 return Some(Ok(res));
10585 }
10586 Some(Err(ErrorContext::new(
10587 "DlResourceList",
10588 r#type.and_then(|t| DlResourceList::attr_from_type(t)),
10589 self.orig_loc,
10590 self.buf.as_ptr().wrapping_add(pos) as usize,
10591 )))
10592 }
10593}
10594impl<'a> std::fmt::Debug for IterableDlResourceList<'_> {
10595 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10596 let mut fmt = f.debug_struct("DlResourceList");
10597 for attr in self.clone() {
10598 let attr = match attr {
10599 Ok(a) => a,
10600 Err(err) => {
10601 fmt.finish()?;
10602 f.write_str("Err(")?;
10603 err.fmt(f)?;
10604 return f.write_str(")");
10605 }
10606 };
10607 match attr {
10608 DlResourceList::Resource(val) => fmt.field("Resource", &val),
10609 };
10610 }
10611 fmt.finish()
10612 }
10613}
10614impl IterableDlResourceList<'_> {
10615 pub fn lookup_attr(
10616 &self,
10617 offset: usize,
10618 missing_type: Option<u16>,
10619 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
10620 let mut stack = Vec::new();
10621 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
10622 if missing_type.is_some() && cur == offset {
10623 stack.push(("DlResourceList", offset));
10624 return (
10625 stack,
10626 missing_type.and_then(|t| DlResourceList::attr_from_type(t)),
10627 );
10628 }
10629 if cur > offset || cur + self.buf.len() < offset {
10630 return (stack, None);
10631 }
10632 let mut attrs = self.clone();
10633 let mut last_off = cur + attrs.pos;
10634 let mut missing = None;
10635 while let Some(attr) = attrs.next() {
10636 let Ok(attr) = attr else { break };
10637 match attr {
10638 DlResourceList::Resource(val) => {
10639 (stack, missing) = val.lookup_attr(offset, missing_type);
10640 if !stack.is_empty() {
10641 break;
10642 }
10643 }
10644 _ => {}
10645 };
10646 last_off = cur + attrs.pos;
10647 }
10648 if !stack.is_empty() {
10649 stack.push(("DlResourceList", cur));
10650 }
10651 (stack, missing)
10652 }
10653}
10654#[derive(Clone)]
10655pub enum DlParam<'a> {
10656 ParamName(&'a CStr),
10657 ParamGeneric(()),
10658 #[doc = "Associated type: [`VarAttrType`] (enum)"]
10659 ParamType(u8),
10660}
10661impl<'a> IterableDlParam<'a> {
10662 pub fn get_param_name(&self) -> Result<&'a CStr, ErrorContext> {
10663 let mut iter = self.clone();
10664 iter.pos = 0;
10665 for attr in iter {
10666 if let Ok(DlParam::ParamName(val)) = attr {
10667 return Ok(val);
10668 }
10669 }
10670 Err(ErrorContext::new_missing(
10671 "DlParam",
10672 "ParamName",
10673 self.orig_loc,
10674 self.buf.as_ptr() as usize,
10675 ))
10676 }
10677 pub fn get_param_generic(&self) -> Result<(), ErrorContext> {
10678 let mut iter = self.clone();
10679 iter.pos = 0;
10680 for attr in iter {
10681 if let Ok(DlParam::ParamGeneric(val)) = attr {
10682 return Ok(val);
10683 }
10684 }
10685 Err(ErrorContext::new_missing(
10686 "DlParam",
10687 "ParamGeneric",
10688 self.orig_loc,
10689 self.buf.as_ptr() as usize,
10690 ))
10691 }
10692 #[doc = "Associated type: [`VarAttrType`] (enum)"]
10693 pub fn get_param_type(&self) -> Result<u8, ErrorContext> {
10694 let mut iter = self.clone();
10695 iter.pos = 0;
10696 for attr in iter {
10697 if let Ok(DlParam::ParamType(val)) = attr {
10698 return Ok(val);
10699 }
10700 }
10701 Err(ErrorContext::new_missing(
10702 "DlParam",
10703 "ParamType",
10704 self.orig_loc,
10705 self.buf.as_ptr() as usize,
10706 ))
10707 }
10708}
10709impl DlParam<'_> {
10710 pub fn new<'a>(buf: &'a [u8]) -> IterableDlParam<'a> {
10711 IterableDlParam::with_loc(buf, buf.as_ptr() as usize)
10712 }
10713 fn attr_from_type(r#type: u16) -> Option<&'static str> {
10714 Devlink::attr_from_type(r#type)
10715 }
10716}
10717#[derive(Clone, Copy, Default)]
10718pub struct IterableDlParam<'a> {
10719 buf: &'a [u8],
10720 pos: usize,
10721 orig_loc: usize,
10722}
10723impl<'a> IterableDlParam<'a> {
10724 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
10725 Self {
10726 buf,
10727 pos: 0,
10728 orig_loc,
10729 }
10730 }
10731 pub fn get_buf(&self) -> &'a [u8] {
10732 self.buf
10733 }
10734}
10735impl<'a> Iterator for IterableDlParam<'a> {
10736 type Item = Result<DlParam<'a>, ErrorContext>;
10737 fn next(&mut self) -> Option<Self::Item> {
10738 let mut pos;
10739 let mut r#type;
10740 loop {
10741 pos = self.pos;
10742 r#type = None;
10743 if self.buf.len() == self.pos {
10744 return None;
10745 }
10746 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
10747 self.pos = self.buf.len();
10748 break;
10749 };
10750 r#type = Some(header.r#type);
10751 let res = match header.r#type {
10752 81u16 => DlParam::ParamName({
10753 let res = CStr::from_bytes_with_nul(next).ok();
10754 let Some(val) = res else { break };
10755 val
10756 }),
10757 82u16 => DlParam::ParamGeneric(()),
10758 83u16 => DlParam::ParamType({
10759 let res = parse_u8(next);
10760 let Some(val) = res else { break };
10761 val
10762 }),
10763 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
10764 n => continue,
10765 };
10766 return Some(Ok(res));
10767 }
10768 Some(Err(ErrorContext::new(
10769 "DlParam",
10770 r#type.and_then(|t| DlParam::attr_from_type(t)),
10771 self.orig_loc,
10772 self.buf.as_ptr().wrapping_add(pos) as usize,
10773 )))
10774 }
10775}
10776impl<'a> std::fmt::Debug for IterableDlParam<'_> {
10777 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10778 let mut fmt = f.debug_struct("DlParam");
10779 for attr in self.clone() {
10780 let attr = match attr {
10781 Ok(a) => a,
10782 Err(err) => {
10783 fmt.finish()?;
10784 f.write_str("Err(")?;
10785 err.fmt(f)?;
10786 return f.write_str(")");
10787 }
10788 };
10789 match attr {
10790 DlParam::ParamName(val) => fmt.field("ParamName", &val),
10791 DlParam::ParamGeneric(val) => fmt.field("ParamGeneric", &val),
10792 DlParam::ParamType(val) => fmt.field(
10793 "ParamType",
10794 &FormatEnum(val.into(), VarAttrType::from_value),
10795 ),
10796 };
10797 }
10798 fmt.finish()
10799 }
10800}
10801impl IterableDlParam<'_> {
10802 pub fn lookup_attr(
10803 &self,
10804 offset: usize,
10805 missing_type: Option<u16>,
10806 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
10807 let mut stack = Vec::new();
10808 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
10809 if missing_type.is_some() && cur == offset {
10810 stack.push(("DlParam", offset));
10811 return (stack, missing_type.and_then(|t| DlParam::attr_from_type(t)));
10812 }
10813 if cur > offset || cur + self.buf.len() < offset {
10814 return (stack, None);
10815 }
10816 let mut attrs = self.clone();
10817 let mut last_off = cur + attrs.pos;
10818 while let Some(attr) = attrs.next() {
10819 let Ok(attr) = attr else { break };
10820 match attr {
10821 DlParam::ParamName(val) => {
10822 if last_off == offset {
10823 stack.push(("ParamName", last_off));
10824 break;
10825 }
10826 }
10827 DlParam::ParamGeneric(val) => {
10828 if last_off == offset {
10829 stack.push(("ParamGeneric", last_off));
10830 break;
10831 }
10832 }
10833 DlParam::ParamType(val) => {
10834 if last_off == offset {
10835 stack.push(("ParamType", last_off));
10836 break;
10837 }
10838 }
10839 _ => {}
10840 };
10841 last_off = cur + attrs.pos;
10842 }
10843 if !stack.is_empty() {
10844 stack.push(("DlParam", cur));
10845 }
10846 (stack, None)
10847 }
10848}
10849#[derive(Clone)]
10850pub enum DlRegionSnapshots<'a> {
10851 RegionSnapshot(IterableDlRegionSnapshot<'a>),
10852}
10853impl<'a> IterableDlRegionSnapshots<'a> {
10854 pub fn get_region_snapshot(&self) -> Result<IterableDlRegionSnapshot<'a>, ErrorContext> {
10855 let mut iter = self.clone();
10856 iter.pos = 0;
10857 for attr in iter {
10858 if let Ok(DlRegionSnapshots::RegionSnapshot(val)) = attr {
10859 return Ok(val);
10860 }
10861 }
10862 Err(ErrorContext::new_missing(
10863 "DlRegionSnapshots",
10864 "RegionSnapshot",
10865 self.orig_loc,
10866 self.buf.as_ptr() as usize,
10867 ))
10868 }
10869}
10870impl DlRegionSnapshots<'_> {
10871 pub fn new<'a>(buf: &'a [u8]) -> IterableDlRegionSnapshots<'a> {
10872 IterableDlRegionSnapshots::with_loc(buf, buf.as_ptr() as usize)
10873 }
10874 fn attr_from_type(r#type: u16) -> Option<&'static str> {
10875 Devlink::attr_from_type(r#type)
10876 }
10877}
10878#[derive(Clone, Copy, Default)]
10879pub struct IterableDlRegionSnapshots<'a> {
10880 buf: &'a [u8],
10881 pos: usize,
10882 orig_loc: usize,
10883}
10884impl<'a> IterableDlRegionSnapshots<'a> {
10885 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
10886 Self {
10887 buf,
10888 pos: 0,
10889 orig_loc,
10890 }
10891 }
10892 pub fn get_buf(&self) -> &'a [u8] {
10893 self.buf
10894 }
10895}
10896impl<'a> Iterator for IterableDlRegionSnapshots<'a> {
10897 type Item = Result<DlRegionSnapshots<'a>, ErrorContext>;
10898 fn next(&mut self) -> Option<Self::Item> {
10899 let mut pos;
10900 let mut r#type;
10901 loop {
10902 pos = self.pos;
10903 r#type = None;
10904 if self.buf.len() == self.pos {
10905 return None;
10906 }
10907 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
10908 self.pos = self.buf.len();
10909 break;
10910 };
10911 r#type = Some(header.r#type);
10912 let res = match header.r#type {
10913 91u16 => DlRegionSnapshots::RegionSnapshot({
10914 let res = Some(IterableDlRegionSnapshot::with_loc(next, self.orig_loc));
10915 let Some(val) = res else { break };
10916 val
10917 }),
10918 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
10919 n => continue,
10920 };
10921 return Some(Ok(res));
10922 }
10923 Some(Err(ErrorContext::new(
10924 "DlRegionSnapshots",
10925 r#type.and_then(|t| DlRegionSnapshots::attr_from_type(t)),
10926 self.orig_loc,
10927 self.buf.as_ptr().wrapping_add(pos) as usize,
10928 )))
10929 }
10930}
10931impl<'a> std::fmt::Debug for IterableDlRegionSnapshots<'_> {
10932 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10933 let mut fmt = f.debug_struct("DlRegionSnapshots");
10934 for attr in self.clone() {
10935 let attr = match attr {
10936 Ok(a) => a,
10937 Err(err) => {
10938 fmt.finish()?;
10939 f.write_str("Err(")?;
10940 err.fmt(f)?;
10941 return f.write_str(")");
10942 }
10943 };
10944 match attr {
10945 DlRegionSnapshots::RegionSnapshot(val) => fmt.field("RegionSnapshot", &val),
10946 };
10947 }
10948 fmt.finish()
10949 }
10950}
10951impl IterableDlRegionSnapshots<'_> {
10952 pub fn lookup_attr(
10953 &self,
10954 offset: usize,
10955 missing_type: Option<u16>,
10956 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
10957 let mut stack = Vec::new();
10958 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
10959 if missing_type.is_some() && cur == offset {
10960 stack.push(("DlRegionSnapshots", offset));
10961 return (
10962 stack,
10963 missing_type.and_then(|t| DlRegionSnapshots::attr_from_type(t)),
10964 );
10965 }
10966 if cur > offset || cur + self.buf.len() < offset {
10967 return (stack, None);
10968 }
10969 let mut attrs = self.clone();
10970 let mut last_off = cur + attrs.pos;
10971 let mut missing = None;
10972 while let Some(attr) = attrs.next() {
10973 let Ok(attr) = attr else { break };
10974 match attr {
10975 DlRegionSnapshots::RegionSnapshot(val) => {
10976 (stack, missing) = val.lookup_attr(offset, missing_type);
10977 if !stack.is_empty() {
10978 break;
10979 }
10980 }
10981 _ => {}
10982 };
10983 last_off = cur + attrs.pos;
10984 }
10985 if !stack.is_empty() {
10986 stack.push(("DlRegionSnapshots", cur));
10987 }
10988 (stack, missing)
10989 }
10990}
10991#[derive(Clone)]
10992pub enum DlRegionSnapshot {
10993 RegionSnapshotId(u32),
10994}
10995impl<'a> IterableDlRegionSnapshot<'a> {
10996 pub fn get_region_snapshot_id(&self) -> Result<u32, ErrorContext> {
10997 let mut iter = self.clone();
10998 iter.pos = 0;
10999 for attr in iter {
11000 if let Ok(DlRegionSnapshot::RegionSnapshotId(val)) = attr {
11001 return Ok(val);
11002 }
11003 }
11004 Err(ErrorContext::new_missing(
11005 "DlRegionSnapshot",
11006 "RegionSnapshotId",
11007 self.orig_loc,
11008 self.buf.as_ptr() as usize,
11009 ))
11010 }
11011}
11012impl DlRegionSnapshot {
11013 pub fn new<'a>(buf: &'a [u8]) -> IterableDlRegionSnapshot<'a> {
11014 IterableDlRegionSnapshot::with_loc(buf, buf.as_ptr() as usize)
11015 }
11016 fn attr_from_type(r#type: u16) -> Option<&'static str> {
11017 Devlink::attr_from_type(r#type)
11018 }
11019}
11020#[derive(Clone, Copy, Default)]
11021pub struct IterableDlRegionSnapshot<'a> {
11022 buf: &'a [u8],
11023 pos: usize,
11024 orig_loc: usize,
11025}
11026impl<'a> IterableDlRegionSnapshot<'a> {
11027 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
11028 Self {
11029 buf,
11030 pos: 0,
11031 orig_loc,
11032 }
11033 }
11034 pub fn get_buf(&self) -> &'a [u8] {
11035 self.buf
11036 }
11037}
11038impl<'a> Iterator for IterableDlRegionSnapshot<'a> {
11039 type Item = Result<DlRegionSnapshot, ErrorContext>;
11040 fn next(&mut self) -> Option<Self::Item> {
11041 let mut pos;
11042 let mut r#type;
11043 loop {
11044 pos = self.pos;
11045 r#type = None;
11046 if self.buf.len() == self.pos {
11047 return None;
11048 }
11049 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
11050 self.pos = self.buf.len();
11051 break;
11052 };
11053 r#type = Some(header.r#type);
11054 let res = match header.r#type {
11055 92u16 => DlRegionSnapshot::RegionSnapshotId({
11056 let res = parse_u32(next);
11057 let Some(val) = res else { break };
11058 val
11059 }),
11060 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
11061 n => continue,
11062 };
11063 return Some(Ok(res));
11064 }
11065 Some(Err(ErrorContext::new(
11066 "DlRegionSnapshot",
11067 r#type.and_then(|t| DlRegionSnapshot::attr_from_type(t)),
11068 self.orig_loc,
11069 self.buf.as_ptr().wrapping_add(pos) as usize,
11070 )))
11071 }
11072}
11073impl std::fmt::Debug for IterableDlRegionSnapshot<'_> {
11074 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11075 let mut fmt = f.debug_struct("DlRegionSnapshot");
11076 for attr in self.clone() {
11077 let attr = match attr {
11078 Ok(a) => a,
11079 Err(err) => {
11080 fmt.finish()?;
11081 f.write_str("Err(")?;
11082 err.fmt(f)?;
11083 return f.write_str(")");
11084 }
11085 };
11086 match attr {
11087 DlRegionSnapshot::RegionSnapshotId(val) => fmt.field("RegionSnapshotId", &val),
11088 };
11089 }
11090 fmt.finish()
11091 }
11092}
11093impl IterableDlRegionSnapshot<'_> {
11094 pub fn lookup_attr(
11095 &self,
11096 offset: usize,
11097 missing_type: Option<u16>,
11098 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
11099 let mut stack = Vec::new();
11100 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
11101 if missing_type.is_some() && cur == offset {
11102 stack.push(("DlRegionSnapshot", offset));
11103 return (
11104 stack,
11105 missing_type.and_then(|t| DlRegionSnapshot::attr_from_type(t)),
11106 );
11107 }
11108 if cur > offset || cur + self.buf.len() < offset {
11109 return (stack, None);
11110 }
11111 let mut attrs = self.clone();
11112 let mut last_off = cur + attrs.pos;
11113 while let Some(attr) = attrs.next() {
11114 let Ok(attr) = attr else { break };
11115 match attr {
11116 DlRegionSnapshot::RegionSnapshotId(val) => {
11117 if last_off == offset {
11118 stack.push(("RegionSnapshotId", last_off));
11119 break;
11120 }
11121 }
11122 _ => {}
11123 };
11124 last_off = cur + attrs.pos;
11125 }
11126 if !stack.is_empty() {
11127 stack.push(("DlRegionSnapshot", cur));
11128 }
11129 (stack, None)
11130 }
11131}
11132#[derive(Clone)]
11133pub enum DlRegionChunks<'a> {
11134 RegionChunk(IterableDlRegionChunk<'a>),
11135}
11136impl<'a> IterableDlRegionChunks<'a> {
11137 pub fn get_region_chunk(&self) -> Result<IterableDlRegionChunk<'a>, ErrorContext> {
11138 let mut iter = self.clone();
11139 iter.pos = 0;
11140 for attr in iter {
11141 if let Ok(DlRegionChunks::RegionChunk(val)) = attr {
11142 return Ok(val);
11143 }
11144 }
11145 Err(ErrorContext::new_missing(
11146 "DlRegionChunks",
11147 "RegionChunk",
11148 self.orig_loc,
11149 self.buf.as_ptr() as usize,
11150 ))
11151 }
11152}
11153impl DlRegionChunks<'_> {
11154 pub fn new<'a>(buf: &'a [u8]) -> IterableDlRegionChunks<'a> {
11155 IterableDlRegionChunks::with_loc(buf, buf.as_ptr() as usize)
11156 }
11157 fn attr_from_type(r#type: u16) -> Option<&'static str> {
11158 Devlink::attr_from_type(r#type)
11159 }
11160}
11161#[derive(Clone, Copy, Default)]
11162pub struct IterableDlRegionChunks<'a> {
11163 buf: &'a [u8],
11164 pos: usize,
11165 orig_loc: usize,
11166}
11167impl<'a> IterableDlRegionChunks<'a> {
11168 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
11169 Self {
11170 buf,
11171 pos: 0,
11172 orig_loc,
11173 }
11174 }
11175 pub fn get_buf(&self) -> &'a [u8] {
11176 self.buf
11177 }
11178}
11179impl<'a> Iterator for IterableDlRegionChunks<'a> {
11180 type Item = Result<DlRegionChunks<'a>, ErrorContext>;
11181 fn next(&mut self) -> Option<Self::Item> {
11182 let mut pos;
11183 let mut r#type;
11184 loop {
11185 pos = self.pos;
11186 r#type = None;
11187 if self.buf.len() == self.pos {
11188 return None;
11189 }
11190 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
11191 self.pos = self.buf.len();
11192 break;
11193 };
11194 r#type = Some(header.r#type);
11195 let res = match header.r#type {
11196 94u16 => DlRegionChunks::RegionChunk({
11197 let res = Some(IterableDlRegionChunk::with_loc(next, self.orig_loc));
11198 let Some(val) = res else { break };
11199 val
11200 }),
11201 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
11202 n => continue,
11203 };
11204 return Some(Ok(res));
11205 }
11206 Some(Err(ErrorContext::new(
11207 "DlRegionChunks",
11208 r#type.and_then(|t| DlRegionChunks::attr_from_type(t)),
11209 self.orig_loc,
11210 self.buf.as_ptr().wrapping_add(pos) as usize,
11211 )))
11212 }
11213}
11214impl<'a> std::fmt::Debug for IterableDlRegionChunks<'_> {
11215 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11216 let mut fmt = f.debug_struct("DlRegionChunks");
11217 for attr in self.clone() {
11218 let attr = match attr {
11219 Ok(a) => a,
11220 Err(err) => {
11221 fmt.finish()?;
11222 f.write_str("Err(")?;
11223 err.fmt(f)?;
11224 return f.write_str(")");
11225 }
11226 };
11227 match attr {
11228 DlRegionChunks::RegionChunk(val) => fmt.field("RegionChunk", &val),
11229 };
11230 }
11231 fmt.finish()
11232 }
11233}
11234impl IterableDlRegionChunks<'_> {
11235 pub fn lookup_attr(
11236 &self,
11237 offset: usize,
11238 missing_type: Option<u16>,
11239 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
11240 let mut stack = Vec::new();
11241 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
11242 if missing_type.is_some() && cur == offset {
11243 stack.push(("DlRegionChunks", offset));
11244 return (
11245 stack,
11246 missing_type.and_then(|t| DlRegionChunks::attr_from_type(t)),
11247 );
11248 }
11249 if cur > offset || cur + self.buf.len() < offset {
11250 return (stack, None);
11251 }
11252 let mut attrs = self.clone();
11253 let mut last_off = cur + attrs.pos;
11254 let mut missing = None;
11255 while let Some(attr) = attrs.next() {
11256 let Ok(attr) = attr else { break };
11257 match attr {
11258 DlRegionChunks::RegionChunk(val) => {
11259 (stack, missing) = val.lookup_attr(offset, missing_type);
11260 if !stack.is_empty() {
11261 break;
11262 }
11263 }
11264 _ => {}
11265 };
11266 last_off = cur + attrs.pos;
11267 }
11268 if !stack.is_empty() {
11269 stack.push(("DlRegionChunks", cur));
11270 }
11271 (stack, missing)
11272 }
11273}
11274#[derive(Clone)]
11275pub enum DlRegionChunk<'a> {
11276 RegionChunkData(&'a [u8]),
11277 RegionChunkAddr(u64),
11278}
11279impl<'a> IterableDlRegionChunk<'a> {
11280 pub fn get_region_chunk_data(&self) -> Result<&'a [u8], ErrorContext> {
11281 let mut iter = self.clone();
11282 iter.pos = 0;
11283 for attr in iter {
11284 if let Ok(DlRegionChunk::RegionChunkData(val)) = attr {
11285 return Ok(val);
11286 }
11287 }
11288 Err(ErrorContext::new_missing(
11289 "DlRegionChunk",
11290 "RegionChunkData",
11291 self.orig_loc,
11292 self.buf.as_ptr() as usize,
11293 ))
11294 }
11295 pub fn get_region_chunk_addr(&self) -> Result<u64, ErrorContext> {
11296 let mut iter = self.clone();
11297 iter.pos = 0;
11298 for attr in iter {
11299 if let Ok(DlRegionChunk::RegionChunkAddr(val)) = attr {
11300 return Ok(val);
11301 }
11302 }
11303 Err(ErrorContext::new_missing(
11304 "DlRegionChunk",
11305 "RegionChunkAddr",
11306 self.orig_loc,
11307 self.buf.as_ptr() as usize,
11308 ))
11309 }
11310}
11311impl DlRegionChunk<'_> {
11312 pub fn new<'a>(buf: &'a [u8]) -> IterableDlRegionChunk<'a> {
11313 IterableDlRegionChunk::with_loc(buf, buf.as_ptr() as usize)
11314 }
11315 fn attr_from_type(r#type: u16) -> Option<&'static str> {
11316 Devlink::attr_from_type(r#type)
11317 }
11318}
11319#[derive(Clone, Copy, Default)]
11320pub struct IterableDlRegionChunk<'a> {
11321 buf: &'a [u8],
11322 pos: usize,
11323 orig_loc: usize,
11324}
11325impl<'a> IterableDlRegionChunk<'a> {
11326 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
11327 Self {
11328 buf,
11329 pos: 0,
11330 orig_loc,
11331 }
11332 }
11333 pub fn get_buf(&self) -> &'a [u8] {
11334 self.buf
11335 }
11336}
11337impl<'a> Iterator for IterableDlRegionChunk<'a> {
11338 type Item = Result<DlRegionChunk<'a>, ErrorContext>;
11339 fn next(&mut self) -> Option<Self::Item> {
11340 let mut pos;
11341 let mut r#type;
11342 loop {
11343 pos = self.pos;
11344 r#type = None;
11345 if self.buf.len() == self.pos {
11346 return None;
11347 }
11348 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
11349 self.pos = self.buf.len();
11350 break;
11351 };
11352 r#type = Some(header.r#type);
11353 let res = match header.r#type {
11354 95u16 => DlRegionChunk::RegionChunkData({
11355 let res = Some(next);
11356 let Some(val) = res else { break };
11357 val
11358 }),
11359 96u16 => DlRegionChunk::RegionChunkAddr({
11360 let res = parse_u64(next);
11361 let Some(val) = res else { break };
11362 val
11363 }),
11364 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
11365 n => continue,
11366 };
11367 return Some(Ok(res));
11368 }
11369 Some(Err(ErrorContext::new(
11370 "DlRegionChunk",
11371 r#type.and_then(|t| DlRegionChunk::attr_from_type(t)),
11372 self.orig_loc,
11373 self.buf.as_ptr().wrapping_add(pos) as usize,
11374 )))
11375 }
11376}
11377impl<'a> std::fmt::Debug for IterableDlRegionChunk<'_> {
11378 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11379 let mut fmt = f.debug_struct("DlRegionChunk");
11380 for attr in self.clone() {
11381 let attr = match attr {
11382 Ok(a) => a,
11383 Err(err) => {
11384 fmt.finish()?;
11385 f.write_str("Err(")?;
11386 err.fmt(f)?;
11387 return f.write_str(")");
11388 }
11389 };
11390 match attr {
11391 DlRegionChunk::RegionChunkData(val) => fmt.field("RegionChunkData", &val),
11392 DlRegionChunk::RegionChunkAddr(val) => fmt.field("RegionChunkAddr", &val),
11393 };
11394 }
11395 fmt.finish()
11396 }
11397}
11398impl IterableDlRegionChunk<'_> {
11399 pub fn lookup_attr(
11400 &self,
11401 offset: usize,
11402 missing_type: Option<u16>,
11403 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
11404 let mut stack = Vec::new();
11405 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
11406 if missing_type.is_some() && cur == offset {
11407 stack.push(("DlRegionChunk", offset));
11408 return (
11409 stack,
11410 missing_type.and_then(|t| DlRegionChunk::attr_from_type(t)),
11411 );
11412 }
11413 if cur > offset || cur + self.buf.len() < offset {
11414 return (stack, None);
11415 }
11416 let mut attrs = self.clone();
11417 let mut last_off = cur + attrs.pos;
11418 while let Some(attr) = attrs.next() {
11419 let Ok(attr) = attr else { break };
11420 match attr {
11421 DlRegionChunk::RegionChunkData(val) => {
11422 if last_off == offset {
11423 stack.push(("RegionChunkData", last_off));
11424 break;
11425 }
11426 }
11427 DlRegionChunk::RegionChunkAddr(val) => {
11428 if last_off == offset {
11429 stack.push(("RegionChunkAddr", last_off));
11430 break;
11431 }
11432 }
11433 _ => {}
11434 };
11435 last_off = cur + attrs.pos;
11436 }
11437 if !stack.is_empty() {
11438 stack.push(("DlRegionChunk", cur));
11439 }
11440 (stack, None)
11441 }
11442}
11443#[derive(Clone)]
11444pub enum DlFmsg<'a> {
11445 FmsgObjNestStart(()),
11446 FmsgPairNestStart(()),
11447 FmsgArrNestStart(()),
11448 FmsgNestEnd(()),
11449 FmsgObjName(&'a CStr),
11450}
11451impl<'a> IterableDlFmsg<'a> {
11452 pub fn get_fmsg_obj_nest_start(&self) -> Result<(), ErrorContext> {
11453 let mut iter = self.clone();
11454 iter.pos = 0;
11455 for attr in iter {
11456 if let Ok(DlFmsg::FmsgObjNestStart(val)) = attr {
11457 return Ok(val);
11458 }
11459 }
11460 Err(ErrorContext::new_missing(
11461 "DlFmsg",
11462 "FmsgObjNestStart",
11463 self.orig_loc,
11464 self.buf.as_ptr() as usize,
11465 ))
11466 }
11467 pub fn get_fmsg_pair_nest_start(&self) -> Result<(), ErrorContext> {
11468 let mut iter = self.clone();
11469 iter.pos = 0;
11470 for attr in iter {
11471 if let Ok(DlFmsg::FmsgPairNestStart(val)) = attr {
11472 return Ok(val);
11473 }
11474 }
11475 Err(ErrorContext::new_missing(
11476 "DlFmsg",
11477 "FmsgPairNestStart",
11478 self.orig_loc,
11479 self.buf.as_ptr() as usize,
11480 ))
11481 }
11482 pub fn get_fmsg_arr_nest_start(&self) -> Result<(), ErrorContext> {
11483 let mut iter = self.clone();
11484 iter.pos = 0;
11485 for attr in iter {
11486 if let Ok(DlFmsg::FmsgArrNestStart(val)) = attr {
11487 return Ok(val);
11488 }
11489 }
11490 Err(ErrorContext::new_missing(
11491 "DlFmsg",
11492 "FmsgArrNestStart",
11493 self.orig_loc,
11494 self.buf.as_ptr() as usize,
11495 ))
11496 }
11497 pub fn get_fmsg_nest_end(&self) -> Result<(), ErrorContext> {
11498 let mut iter = self.clone();
11499 iter.pos = 0;
11500 for attr in iter {
11501 if let Ok(DlFmsg::FmsgNestEnd(val)) = attr {
11502 return Ok(val);
11503 }
11504 }
11505 Err(ErrorContext::new_missing(
11506 "DlFmsg",
11507 "FmsgNestEnd",
11508 self.orig_loc,
11509 self.buf.as_ptr() as usize,
11510 ))
11511 }
11512 pub fn get_fmsg_obj_name(&self) -> Result<&'a CStr, ErrorContext> {
11513 let mut iter = self.clone();
11514 iter.pos = 0;
11515 for attr in iter {
11516 if let Ok(DlFmsg::FmsgObjName(val)) = attr {
11517 return Ok(val);
11518 }
11519 }
11520 Err(ErrorContext::new_missing(
11521 "DlFmsg",
11522 "FmsgObjName",
11523 self.orig_loc,
11524 self.buf.as_ptr() as usize,
11525 ))
11526 }
11527}
11528impl DlFmsg<'_> {
11529 pub fn new<'a>(buf: &'a [u8]) -> IterableDlFmsg<'a> {
11530 IterableDlFmsg::with_loc(buf, buf.as_ptr() as usize)
11531 }
11532 fn attr_from_type(r#type: u16) -> Option<&'static str> {
11533 Devlink::attr_from_type(r#type)
11534 }
11535}
11536#[derive(Clone, Copy, Default)]
11537pub struct IterableDlFmsg<'a> {
11538 buf: &'a [u8],
11539 pos: usize,
11540 orig_loc: usize,
11541}
11542impl<'a> IterableDlFmsg<'a> {
11543 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
11544 Self {
11545 buf,
11546 pos: 0,
11547 orig_loc,
11548 }
11549 }
11550 pub fn get_buf(&self) -> &'a [u8] {
11551 self.buf
11552 }
11553}
11554impl<'a> Iterator for IterableDlFmsg<'a> {
11555 type Item = Result<DlFmsg<'a>, ErrorContext>;
11556 fn next(&mut self) -> Option<Self::Item> {
11557 let mut pos;
11558 let mut r#type;
11559 loop {
11560 pos = self.pos;
11561 r#type = None;
11562 if self.buf.len() == self.pos {
11563 return None;
11564 }
11565 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
11566 self.pos = self.buf.len();
11567 break;
11568 };
11569 r#type = Some(header.r#type);
11570 let res = match header.r#type {
11571 107u16 => DlFmsg::FmsgObjNestStart(()),
11572 108u16 => DlFmsg::FmsgPairNestStart(()),
11573 109u16 => DlFmsg::FmsgArrNestStart(()),
11574 110u16 => DlFmsg::FmsgNestEnd(()),
11575 111u16 => DlFmsg::FmsgObjName({
11576 let res = CStr::from_bytes_with_nul(next).ok();
11577 let Some(val) = res else { break };
11578 val
11579 }),
11580 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
11581 n => continue,
11582 };
11583 return Some(Ok(res));
11584 }
11585 Some(Err(ErrorContext::new(
11586 "DlFmsg",
11587 r#type.and_then(|t| DlFmsg::attr_from_type(t)),
11588 self.orig_loc,
11589 self.buf.as_ptr().wrapping_add(pos) as usize,
11590 )))
11591 }
11592}
11593impl<'a> std::fmt::Debug for IterableDlFmsg<'_> {
11594 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11595 let mut fmt = f.debug_struct("DlFmsg");
11596 for attr in self.clone() {
11597 let attr = match attr {
11598 Ok(a) => a,
11599 Err(err) => {
11600 fmt.finish()?;
11601 f.write_str("Err(")?;
11602 err.fmt(f)?;
11603 return f.write_str(")");
11604 }
11605 };
11606 match attr {
11607 DlFmsg::FmsgObjNestStart(val) => fmt.field("FmsgObjNestStart", &val),
11608 DlFmsg::FmsgPairNestStart(val) => fmt.field("FmsgPairNestStart", &val),
11609 DlFmsg::FmsgArrNestStart(val) => fmt.field("FmsgArrNestStart", &val),
11610 DlFmsg::FmsgNestEnd(val) => fmt.field("FmsgNestEnd", &val),
11611 DlFmsg::FmsgObjName(val) => fmt.field("FmsgObjName", &val),
11612 };
11613 }
11614 fmt.finish()
11615 }
11616}
11617impl IterableDlFmsg<'_> {
11618 pub fn lookup_attr(
11619 &self,
11620 offset: usize,
11621 missing_type: Option<u16>,
11622 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
11623 let mut stack = Vec::new();
11624 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
11625 if missing_type.is_some() && cur == offset {
11626 stack.push(("DlFmsg", offset));
11627 return (stack, missing_type.and_then(|t| DlFmsg::attr_from_type(t)));
11628 }
11629 if cur > offset || cur + self.buf.len() < offset {
11630 return (stack, None);
11631 }
11632 let mut attrs = self.clone();
11633 let mut last_off = cur + attrs.pos;
11634 while let Some(attr) = attrs.next() {
11635 let Ok(attr) = attr else { break };
11636 match attr {
11637 DlFmsg::FmsgObjNestStart(val) => {
11638 if last_off == offset {
11639 stack.push(("FmsgObjNestStart", last_off));
11640 break;
11641 }
11642 }
11643 DlFmsg::FmsgPairNestStart(val) => {
11644 if last_off == offset {
11645 stack.push(("FmsgPairNestStart", last_off));
11646 break;
11647 }
11648 }
11649 DlFmsg::FmsgArrNestStart(val) => {
11650 if last_off == offset {
11651 stack.push(("FmsgArrNestStart", last_off));
11652 break;
11653 }
11654 }
11655 DlFmsg::FmsgNestEnd(val) => {
11656 if last_off == offset {
11657 stack.push(("FmsgNestEnd", last_off));
11658 break;
11659 }
11660 }
11661 DlFmsg::FmsgObjName(val) => {
11662 if last_off == offset {
11663 stack.push(("FmsgObjName", last_off));
11664 break;
11665 }
11666 }
11667 _ => {}
11668 };
11669 last_off = cur + attrs.pos;
11670 }
11671 if !stack.is_empty() {
11672 stack.push(("DlFmsg", cur));
11673 }
11674 (stack, None)
11675 }
11676}
11677#[derive(Clone)]
11678pub enum DlHealthReporter<'a> {
11679 HealthReporterName(&'a CStr),
11680 HealthReporterState(u8),
11681 HealthReporterErrCount(u64),
11682 HealthReporterRecoverCount(u64),
11683 HealthReporterDumpTs(u64),
11684 HealthReporterGracefulPeriod(u64),
11685 HealthReporterAutoRecover(u8),
11686 HealthReporterDumpTsNs(u64),
11687 HealthReporterAutoDump(u8),
11688 #[doc = "Time (in msec) for recoveries before starting the grace period.\n"]
11689 HealthReporterBurstPeriod(u64),
11690}
11691impl<'a> IterableDlHealthReporter<'a> {
11692 pub fn get_health_reporter_name(&self) -> Result<&'a CStr, ErrorContext> {
11693 let mut iter = self.clone();
11694 iter.pos = 0;
11695 for attr in iter {
11696 if let Ok(DlHealthReporter::HealthReporterName(val)) = attr {
11697 return Ok(val);
11698 }
11699 }
11700 Err(ErrorContext::new_missing(
11701 "DlHealthReporter",
11702 "HealthReporterName",
11703 self.orig_loc,
11704 self.buf.as_ptr() as usize,
11705 ))
11706 }
11707 pub fn get_health_reporter_state(&self) -> Result<u8, ErrorContext> {
11708 let mut iter = self.clone();
11709 iter.pos = 0;
11710 for attr in iter {
11711 if let Ok(DlHealthReporter::HealthReporterState(val)) = attr {
11712 return Ok(val);
11713 }
11714 }
11715 Err(ErrorContext::new_missing(
11716 "DlHealthReporter",
11717 "HealthReporterState",
11718 self.orig_loc,
11719 self.buf.as_ptr() as usize,
11720 ))
11721 }
11722 pub fn get_health_reporter_err_count(&self) -> Result<u64, ErrorContext> {
11723 let mut iter = self.clone();
11724 iter.pos = 0;
11725 for attr in iter {
11726 if let Ok(DlHealthReporter::HealthReporterErrCount(val)) = attr {
11727 return Ok(val);
11728 }
11729 }
11730 Err(ErrorContext::new_missing(
11731 "DlHealthReporter",
11732 "HealthReporterErrCount",
11733 self.orig_loc,
11734 self.buf.as_ptr() as usize,
11735 ))
11736 }
11737 pub fn get_health_reporter_recover_count(&self) -> Result<u64, ErrorContext> {
11738 let mut iter = self.clone();
11739 iter.pos = 0;
11740 for attr in iter {
11741 if let Ok(DlHealthReporter::HealthReporterRecoverCount(val)) = attr {
11742 return Ok(val);
11743 }
11744 }
11745 Err(ErrorContext::new_missing(
11746 "DlHealthReporter",
11747 "HealthReporterRecoverCount",
11748 self.orig_loc,
11749 self.buf.as_ptr() as usize,
11750 ))
11751 }
11752 pub fn get_health_reporter_dump_ts(&self) -> Result<u64, ErrorContext> {
11753 let mut iter = self.clone();
11754 iter.pos = 0;
11755 for attr in iter {
11756 if let Ok(DlHealthReporter::HealthReporterDumpTs(val)) = attr {
11757 return Ok(val);
11758 }
11759 }
11760 Err(ErrorContext::new_missing(
11761 "DlHealthReporter",
11762 "HealthReporterDumpTs",
11763 self.orig_loc,
11764 self.buf.as_ptr() as usize,
11765 ))
11766 }
11767 pub fn get_health_reporter_graceful_period(&self) -> Result<u64, ErrorContext> {
11768 let mut iter = self.clone();
11769 iter.pos = 0;
11770 for attr in iter {
11771 if let Ok(DlHealthReporter::HealthReporterGracefulPeriod(val)) = attr {
11772 return Ok(val);
11773 }
11774 }
11775 Err(ErrorContext::new_missing(
11776 "DlHealthReporter",
11777 "HealthReporterGracefulPeriod",
11778 self.orig_loc,
11779 self.buf.as_ptr() as usize,
11780 ))
11781 }
11782 pub fn get_health_reporter_auto_recover(&self) -> Result<u8, ErrorContext> {
11783 let mut iter = self.clone();
11784 iter.pos = 0;
11785 for attr in iter {
11786 if let Ok(DlHealthReporter::HealthReporterAutoRecover(val)) = attr {
11787 return Ok(val);
11788 }
11789 }
11790 Err(ErrorContext::new_missing(
11791 "DlHealthReporter",
11792 "HealthReporterAutoRecover",
11793 self.orig_loc,
11794 self.buf.as_ptr() as usize,
11795 ))
11796 }
11797 pub fn get_health_reporter_dump_ts_ns(&self) -> Result<u64, ErrorContext> {
11798 let mut iter = self.clone();
11799 iter.pos = 0;
11800 for attr in iter {
11801 if let Ok(DlHealthReporter::HealthReporterDumpTsNs(val)) = attr {
11802 return Ok(val);
11803 }
11804 }
11805 Err(ErrorContext::new_missing(
11806 "DlHealthReporter",
11807 "HealthReporterDumpTsNs",
11808 self.orig_loc,
11809 self.buf.as_ptr() as usize,
11810 ))
11811 }
11812 pub fn get_health_reporter_auto_dump(&self) -> Result<u8, ErrorContext> {
11813 let mut iter = self.clone();
11814 iter.pos = 0;
11815 for attr in iter {
11816 if let Ok(DlHealthReporter::HealthReporterAutoDump(val)) = attr {
11817 return Ok(val);
11818 }
11819 }
11820 Err(ErrorContext::new_missing(
11821 "DlHealthReporter",
11822 "HealthReporterAutoDump",
11823 self.orig_loc,
11824 self.buf.as_ptr() as usize,
11825 ))
11826 }
11827 #[doc = "Time (in msec) for recoveries before starting the grace period.\n"]
11828 pub fn get_health_reporter_burst_period(&self) -> Result<u64, ErrorContext> {
11829 let mut iter = self.clone();
11830 iter.pos = 0;
11831 for attr in iter {
11832 if let Ok(DlHealthReporter::HealthReporterBurstPeriod(val)) = attr {
11833 return Ok(val);
11834 }
11835 }
11836 Err(ErrorContext::new_missing(
11837 "DlHealthReporter",
11838 "HealthReporterBurstPeriod",
11839 self.orig_loc,
11840 self.buf.as_ptr() as usize,
11841 ))
11842 }
11843}
11844impl DlHealthReporter<'_> {
11845 pub fn new<'a>(buf: &'a [u8]) -> IterableDlHealthReporter<'a> {
11846 IterableDlHealthReporter::with_loc(buf, buf.as_ptr() as usize)
11847 }
11848 fn attr_from_type(r#type: u16) -> Option<&'static str> {
11849 Devlink::attr_from_type(r#type)
11850 }
11851}
11852#[derive(Clone, Copy, Default)]
11853pub struct IterableDlHealthReporter<'a> {
11854 buf: &'a [u8],
11855 pos: usize,
11856 orig_loc: usize,
11857}
11858impl<'a> IterableDlHealthReporter<'a> {
11859 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
11860 Self {
11861 buf,
11862 pos: 0,
11863 orig_loc,
11864 }
11865 }
11866 pub fn get_buf(&self) -> &'a [u8] {
11867 self.buf
11868 }
11869}
11870impl<'a> Iterator for IterableDlHealthReporter<'a> {
11871 type Item = Result<DlHealthReporter<'a>, ErrorContext>;
11872 fn next(&mut self) -> Option<Self::Item> {
11873 let mut pos;
11874 let mut r#type;
11875 loop {
11876 pos = self.pos;
11877 r#type = None;
11878 if self.buf.len() == self.pos {
11879 return None;
11880 }
11881 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
11882 self.pos = self.buf.len();
11883 break;
11884 };
11885 r#type = Some(header.r#type);
11886 let res = match header.r#type {
11887 115u16 => DlHealthReporter::HealthReporterName({
11888 let res = CStr::from_bytes_with_nul(next).ok();
11889 let Some(val) = res else { break };
11890 val
11891 }),
11892 116u16 => DlHealthReporter::HealthReporterState({
11893 let res = parse_u8(next);
11894 let Some(val) = res else { break };
11895 val
11896 }),
11897 117u16 => DlHealthReporter::HealthReporterErrCount({
11898 let res = parse_u64(next);
11899 let Some(val) = res else { break };
11900 val
11901 }),
11902 118u16 => DlHealthReporter::HealthReporterRecoverCount({
11903 let res = parse_u64(next);
11904 let Some(val) = res else { break };
11905 val
11906 }),
11907 119u16 => DlHealthReporter::HealthReporterDumpTs({
11908 let res = parse_u64(next);
11909 let Some(val) = res else { break };
11910 val
11911 }),
11912 120u16 => DlHealthReporter::HealthReporterGracefulPeriod({
11913 let res = parse_u64(next);
11914 let Some(val) = res else { break };
11915 val
11916 }),
11917 121u16 => DlHealthReporter::HealthReporterAutoRecover({
11918 let res = parse_u8(next);
11919 let Some(val) = res else { break };
11920 val
11921 }),
11922 137u16 => DlHealthReporter::HealthReporterDumpTsNs({
11923 let res = parse_u64(next);
11924 let Some(val) = res else { break };
11925 val
11926 }),
11927 141u16 => DlHealthReporter::HealthReporterAutoDump({
11928 let res = parse_u8(next);
11929 let Some(val) = res else { break };
11930 val
11931 }),
11932 181u16 => DlHealthReporter::HealthReporterBurstPeriod({
11933 let res = parse_u64(next);
11934 let Some(val) = res else { break };
11935 val
11936 }),
11937 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
11938 n => continue,
11939 };
11940 return Some(Ok(res));
11941 }
11942 Some(Err(ErrorContext::new(
11943 "DlHealthReporter",
11944 r#type.and_then(|t| DlHealthReporter::attr_from_type(t)),
11945 self.orig_loc,
11946 self.buf.as_ptr().wrapping_add(pos) as usize,
11947 )))
11948 }
11949}
11950impl<'a> std::fmt::Debug for IterableDlHealthReporter<'_> {
11951 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11952 let mut fmt = f.debug_struct("DlHealthReporter");
11953 for attr in self.clone() {
11954 let attr = match attr {
11955 Ok(a) => a,
11956 Err(err) => {
11957 fmt.finish()?;
11958 f.write_str("Err(")?;
11959 err.fmt(f)?;
11960 return f.write_str(")");
11961 }
11962 };
11963 match attr {
11964 DlHealthReporter::HealthReporterName(val) => fmt.field("HealthReporterName", &val),
11965 DlHealthReporter::HealthReporterState(val) => {
11966 fmt.field("HealthReporterState", &val)
11967 }
11968 DlHealthReporter::HealthReporterErrCount(val) => {
11969 fmt.field("HealthReporterErrCount", &val)
11970 }
11971 DlHealthReporter::HealthReporterRecoverCount(val) => {
11972 fmt.field("HealthReporterRecoverCount", &val)
11973 }
11974 DlHealthReporter::HealthReporterDumpTs(val) => {
11975 fmt.field("HealthReporterDumpTs", &val)
11976 }
11977 DlHealthReporter::HealthReporterGracefulPeriod(val) => {
11978 fmt.field("HealthReporterGracefulPeriod", &val)
11979 }
11980 DlHealthReporter::HealthReporterAutoRecover(val) => {
11981 fmt.field("HealthReporterAutoRecover", &val)
11982 }
11983 DlHealthReporter::HealthReporterDumpTsNs(val) => {
11984 fmt.field("HealthReporterDumpTsNs", &val)
11985 }
11986 DlHealthReporter::HealthReporterAutoDump(val) => {
11987 fmt.field("HealthReporterAutoDump", &val)
11988 }
11989 DlHealthReporter::HealthReporterBurstPeriod(val) => {
11990 fmt.field("HealthReporterBurstPeriod", &val)
11991 }
11992 };
11993 }
11994 fmt.finish()
11995 }
11996}
11997impl IterableDlHealthReporter<'_> {
11998 pub fn lookup_attr(
11999 &self,
12000 offset: usize,
12001 missing_type: Option<u16>,
12002 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
12003 let mut stack = Vec::new();
12004 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
12005 if missing_type.is_some() && cur == offset {
12006 stack.push(("DlHealthReporter", offset));
12007 return (
12008 stack,
12009 missing_type.and_then(|t| DlHealthReporter::attr_from_type(t)),
12010 );
12011 }
12012 if cur > offset || cur + self.buf.len() < offset {
12013 return (stack, None);
12014 }
12015 let mut attrs = self.clone();
12016 let mut last_off = cur + attrs.pos;
12017 while let Some(attr) = attrs.next() {
12018 let Ok(attr) = attr else { break };
12019 match attr {
12020 DlHealthReporter::HealthReporterName(val) => {
12021 if last_off == offset {
12022 stack.push(("HealthReporterName", last_off));
12023 break;
12024 }
12025 }
12026 DlHealthReporter::HealthReporterState(val) => {
12027 if last_off == offset {
12028 stack.push(("HealthReporterState", last_off));
12029 break;
12030 }
12031 }
12032 DlHealthReporter::HealthReporterErrCount(val) => {
12033 if last_off == offset {
12034 stack.push(("HealthReporterErrCount", last_off));
12035 break;
12036 }
12037 }
12038 DlHealthReporter::HealthReporterRecoverCount(val) => {
12039 if last_off == offset {
12040 stack.push(("HealthReporterRecoverCount", last_off));
12041 break;
12042 }
12043 }
12044 DlHealthReporter::HealthReporterDumpTs(val) => {
12045 if last_off == offset {
12046 stack.push(("HealthReporterDumpTs", last_off));
12047 break;
12048 }
12049 }
12050 DlHealthReporter::HealthReporterGracefulPeriod(val) => {
12051 if last_off == offset {
12052 stack.push(("HealthReporterGracefulPeriod", last_off));
12053 break;
12054 }
12055 }
12056 DlHealthReporter::HealthReporterAutoRecover(val) => {
12057 if last_off == offset {
12058 stack.push(("HealthReporterAutoRecover", last_off));
12059 break;
12060 }
12061 }
12062 DlHealthReporter::HealthReporterDumpTsNs(val) => {
12063 if last_off == offset {
12064 stack.push(("HealthReporterDumpTsNs", last_off));
12065 break;
12066 }
12067 }
12068 DlHealthReporter::HealthReporterAutoDump(val) => {
12069 if last_off == offset {
12070 stack.push(("HealthReporterAutoDump", last_off));
12071 break;
12072 }
12073 }
12074 DlHealthReporter::HealthReporterBurstPeriod(val) => {
12075 if last_off == offset {
12076 stack.push(("HealthReporterBurstPeriod", last_off));
12077 break;
12078 }
12079 }
12080 _ => {}
12081 };
12082 last_off = cur + attrs.pos;
12083 }
12084 if !stack.is_empty() {
12085 stack.push(("DlHealthReporter", cur));
12086 }
12087 (stack, None)
12088 }
12089}
12090#[derive(Clone)]
12091pub enum DlAttrStats {
12092 StatsRxPackets(u64),
12093 StatsRxBytes(u64),
12094 StatsRxDropped(u64),
12095}
12096impl<'a> IterableDlAttrStats<'a> {
12097 pub fn get_stats_rx_packets(&self) -> Result<u64, ErrorContext> {
12098 let mut iter = self.clone();
12099 iter.pos = 0;
12100 for attr in iter {
12101 if let Ok(DlAttrStats::StatsRxPackets(val)) = attr {
12102 return Ok(val);
12103 }
12104 }
12105 Err(ErrorContext::new_missing(
12106 "DlAttrStats",
12107 "StatsRxPackets",
12108 self.orig_loc,
12109 self.buf.as_ptr() as usize,
12110 ))
12111 }
12112 pub fn get_stats_rx_bytes(&self) -> Result<u64, ErrorContext> {
12113 let mut iter = self.clone();
12114 iter.pos = 0;
12115 for attr in iter {
12116 if let Ok(DlAttrStats::StatsRxBytes(val)) = attr {
12117 return Ok(val);
12118 }
12119 }
12120 Err(ErrorContext::new_missing(
12121 "DlAttrStats",
12122 "StatsRxBytes",
12123 self.orig_loc,
12124 self.buf.as_ptr() as usize,
12125 ))
12126 }
12127 pub fn get_stats_rx_dropped(&self) -> Result<u64, ErrorContext> {
12128 let mut iter = self.clone();
12129 iter.pos = 0;
12130 for attr in iter {
12131 if let Ok(DlAttrStats::StatsRxDropped(val)) = attr {
12132 return Ok(val);
12133 }
12134 }
12135 Err(ErrorContext::new_missing(
12136 "DlAttrStats",
12137 "StatsRxDropped",
12138 self.orig_loc,
12139 self.buf.as_ptr() as usize,
12140 ))
12141 }
12142}
12143impl DlAttrStats {
12144 pub fn new<'a>(buf: &'a [u8]) -> IterableDlAttrStats<'a> {
12145 IterableDlAttrStats::with_loc(buf, buf.as_ptr() as usize)
12146 }
12147 fn attr_from_type(r#type: u16) -> Option<&'static str> {
12148 let res = match r#type {
12149 0u16 => "StatsRxPackets",
12150 1u16 => "StatsRxBytes",
12151 2u16 => "StatsRxDropped",
12152 _ => return None,
12153 };
12154 Some(res)
12155 }
12156}
12157#[derive(Clone, Copy, Default)]
12158pub struct IterableDlAttrStats<'a> {
12159 buf: &'a [u8],
12160 pos: usize,
12161 orig_loc: usize,
12162}
12163impl<'a> IterableDlAttrStats<'a> {
12164 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
12165 Self {
12166 buf,
12167 pos: 0,
12168 orig_loc,
12169 }
12170 }
12171 pub fn get_buf(&self) -> &'a [u8] {
12172 self.buf
12173 }
12174}
12175impl<'a> Iterator for IterableDlAttrStats<'a> {
12176 type Item = Result<DlAttrStats, ErrorContext>;
12177 fn next(&mut self) -> Option<Self::Item> {
12178 let mut pos;
12179 let mut r#type;
12180 loop {
12181 pos = self.pos;
12182 r#type = None;
12183 if self.buf.len() == self.pos {
12184 return None;
12185 }
12186 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
12187 self.pos = self.buf.len();
12188 break;
12189 };
12190 r#type = Some(header.r#type);
12191 let res = match header.r#type {
12192 0u16 => DlAttrStats::StatsRxPackets({
12193 let res = parse_u64(next);
12194 let Some(val) = res else { break };
12195 val
12196 }),
12197 1u16 => DlAttrStats::StatsRxBytes({
12198 let res = parse_u64(next);
12199 let Some(val) = res else { break };
12200 val
12201 }),
12202 2u16 => DlAttrStats::StatsRxDropped({
12203 let res = parse_u64(next);
12204 let Some(val) = res else { break };
12205 val
12206 }),
12207 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
12208 n => continue,
12209 };
12210 return Some(Ok(res));
12211 }
12212 Some(Err(ErrorContext::new(
12213 "DlAttrStats",
12214 r#type.and_then(|t| DlAttrStats::attr_from_type(t)),
12215 self.orig_loc,
12216 self.buf.as_ptr().wrapping_add(pos) as usize,
12217 )))
12218 }
12219}
12220impl std::fmt::Debug for IterableDlAttrStats<'_> {
12221 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12222 let mut fmt = f.debug_struct("DlAttrStats");
12223 for attr in self.clone() {
12224 let attr = match attr {
12225 Ok(a) => a,
12226 Err(err) => {
12227 fmt.finish()?;
12228 f.write_str("Err(")?;
12229 err.fmt(f)?;
12230 return f.write_str(")");
12231 }
12232 };
12233 match attr {
12234 DlAttrStats::StatsRxPackets(val) => fmt.field("StatsRxPackets", &val),
12235 DlAttrStats::StatsRxBytes(val) => fmt.field("StatsRxBytes", &val),
12236 DlAttrStats::StatsRxDropped(val) => fmt.field("StatsRxDropped", &val),
12237 };
12238 }
12239 fmt.finish()
12240 }
12241}
12242impl IterableDlAttrStats<'_> {
12243 pub fn lookup_attr(
12244 &self,
12245 offset: usize,
12246 missing_type: Option<u16>,
12247 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
12248 let mut stack = Vec::new();
12249 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
12250 if missing_type.is_some() && cur == offset {
12251 stack.push(("DlAttrStats", offset));
12252 return (
12253 stack,
12254 missing_type.and_then(|t| DlAttrStats::attr_from_type(t)),
12255 );
12256 }
12257 if cur > offset || cur + self.buf.len() < offset {
12258 return (stack, None);
12259 }
12260 let mut attrs = self.clone();
12261 let mut last_off = cur + attrs.pos;
12262 while let Some(attr) = attrs.next() {
12263 let Ok(attr) = attr else { break };
12264 match attr {
12265 DlAttrStats::StatsRxPackets(val) => {
12266 if last_off == offset {
12267 stack.push(("StatsRxPackets", last_off));
12268 break;
12269 }
12270 }
12271 DlAttrStats::StatsRxBytes(val) => {
12272 if last_off == offset {
12273 stack.push(("StatsRxBytes", last_off));
12274 break;
12275 }
12276 }
12277 DlAttrStats::StatsRxDropped(val) => {
12278 if last_off == offset {
12279 stack.push(("StatsRxDropped", last_off));
12280 break;
12281 }
12282 }
12283 _ => {}
12284 };
12285 last_off = cur + attrs.pos;
12286 }
12287 if !stack.is_empty() {
12288 stack.push(("DlAttrStats", cur));
12289 }
12290 (stack, None)
12291 }
12292}
12293#[derive(Clone)]
12294pub enum DlTrapMetadata {
12295 TrapMetadataTypeInPort(()),
12296 TrapMetadataTypeFaCookie(()),
12297}
12298impl<'a> IterableDlTrapMetadata<'a> {
12299 pub fn get_trap_metadata_type_in_port(&self) -> Result<(), ErrorContext> {
12300 let mut iter = self.clone();
12301 iter.pos = 0;
12302 for attr in iter {
12303 if let Ok(DlTrapMetadata::TrapMetadataTypeInPort(val)) = attr {
12304 return Ok(val);
12305 }
12306 }
12307 Err(ErrorContext::new_missing(
12308 "DlTrapMetadata",
12309 "TrapMetadataTypeInPort",
12310 self.orig_loc,
12311 self.buf.as_ptr() as usize,
12312 ))
12313 }
12314 pub fn get_trap_metadata_type_fa_cookie(&self) -> Result<(), ErrorContext> {
12315 let mut iter = self.clone();
12316 iter.pos = 0;
12317 for attr in iter {
12318 if let Ok(DlTrapMetadata::TrapMetadataTypeFaCookie(val)) = attr {
12319 return Ok(val);
12320 }
12321 }
12322 Err(ErrorContext::new_missing(
12323 "DlTrapMetadata",
12324 "TrapMetadataTypeFaCookie",
12325 self.orig_loc,
12326 self.buf.as_ptr() as usize,
12327 ))
12328 }
12329}
12330impl DlTrapMetadata {
12331 pub fn new<'a>(buf: &'a [u8]) -> IterableDlTrapMetadata<'a> {
12332 IterableDlTrapMetadata::with_loc(buf, buf.as_ptr() as usize)
12333 }
12334 fn attr_from_type(r#type: u16) -> Option<&'static str> {
12335 let res = match r#type {
12336 0u16 => "TrapMetadataTypeInPort",
12337 1u16 => "TrapMetadataTypeFaCookie",
12338 _ => return None,
12339 };
12340 Some(res)
12341 }
12342}
12343#[derive(Clone, Copy, Default)]
12344pub struct IterableDlTrapMetadata<'a> {
12345 buf: &'a [u8],
12346 pos: usize,
12347 orig_loc: usize,
12348}
12349impl<'a> IterableDlTrapMetadata<'a> {
12350 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
12351 Self {
12352 buf,
12353 pos: 0,
12354 orig_loc,
12355 }
12356 }
12357 pub fn get_buf(&self) -> &'a [u8] {
12358 self.buf
12359 }
12360}
12361impl<'a> Iterator for IterableDlTrapMetadata<'a> {
12362 type Item = Result<DlTrapMetadata, ErrorContext>;
12363 fn next(&mut self) -> Option<Self::Item> {
12364 let mut pos;
12365 let mut r#type;
12366 loop {
12367 pos = self.pos;
12368 r#type = None;
12369 if self.buf.len() == self.pos {
12370 return None;
12371 }
12372 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
12373 self.pos = self.buf.len();
12374 break;
12375 };
12376 r#type = Some(header.r#type);
12377 let res = match header.r#type {
12378 0u16 => DlTrapMetadata::TrapMetadataTypeInPort(()),
12379 1u16 => DlTrapMetadata::TrapMetadataTypeFaCookie(()),
12380 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
12381 n => continue,
12382 };
12383 return Some(Ok(res));
12384 }
12385 Some(Err(ErrorContext::new(
12386 "DlTrapMetadata",
12387 r#type.and_then(|t| DlTrapMetadata::attr_from_type(t)),
12388 self.orig_loc,
12389 self.buf.as_ptr().wrapping_add(pos) as usize,
12390 )))
12391 }
12392}
12393impl std::fmt::Debug for IterableDlTrapMetadata<'_> {
12394 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12395 let mut fmt = f.debug_struct("DlTrapMetadata");
12396 for attr in self.clone() {
12397 let attr = match attr {
12398 Ok(a) => a,
12399 Err(err) => {
12400 fmt.finish()?;
12401 f.write_str("Err(")?;
12402 err.fmt(f)?;
12403 return f.write_str(")");
12404 }
12405 };
12406 match attr {
12407 DlTrapMetadata::TrapMetadataTypeInPort(val) => {
12408 fmt.field("TrapMetadataTypeInPort", &val)
12409 }
12410 DlTrapMetadata::TrapMetadataTypeFaCookie(val) => {
12411 fmt.field("TrapMetadataTypeFaCookie", &val)
12412 }
12413 };
12414 }
12415 fmt.finish()
12416 }
12417}
12418impl IterableDlTrapMetadata<'_> {
12419 pub fn lookup_attr(
12420 &self,
12421 offset: usize,
12422 missing_type: Option<u16>,
12423 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
12424 let mut stack = Vec::new();
12425 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
12426 if missing_type.is_some() && cur == offset {
12427 stack.push(("DlTrapMetadata", offset));
12428 return (
12429 stack,
12430 missing_type.and_then(|t| DlTrapMetadata::attr_from_type(t)),
12431 );
12432 }
12433 if cur > offset || cur + self.buf.len() < offset {
12434 return (stack, None);
12435 }
12436 let mut attrs = self.clone();
12437 let mut last_off = cur + attrs.pos;
12438 while let Some(attr) = attrs.next() {
12439 let Ok(attr) = attr else { break };
12440 match attr {
12441 DlTrapMetadata::TrapMetadataTypeInPort(val) => {
12442 if last_off == offset {
12443 stack.push(("TrapMetadataTypeInPort", last_off));
12444 break;
12445 }
12446 }
12447 DlTrapMetadata::TrapMetadataTypeFaCookie(val) => {
12448 if last_off == offset {
12449 stack.push(("TrapMetadataTypeFaCookie", last_off));
12450 break;
12451 }
12452 }
12453 _ => {}
12454 };
12455 last_off = cur + attrs.pos;
12456 }
12457 if !stack.is_empty() {
12458 stack.push(("DlTrapMetadata", cur));
12459 }
12460 (stack, None)
12461 }
12462}
12463#[derive(Clone)]
12464pub enum DlLinecardSupportedTypes<'a> {
12465 LinecardType(&'a CStr),
12466}
12467impl<'a> IterableDlLinecardSupportedTypes<'a> {
12468 pub fn get_linecard_type(&self) -> Result<&'a CStr, ErrorContext> {
12469 let mut iter = self.clone();
12470 iter.pos = 0;
12471 for attr in iter {
12472 if let Ok(DlLinecardSupportedTypes::LinecardType(val)) = attr {
12473 return Ok(val);
12474 }
12475 }
12476 Err(ErrorContext::new_missing(
12477 "DlLinecardSupportedTypes",
12478 "LinecardType",
12479 self.orig_loc,
12480 self.buf.as_ptr() as usize,
12481 ))
12482 }
12483}
12484impl DlLinecardSupportedTypes<'_> {
12485 pub fn new<'a>(buf: &'a [u8]) -> IterableDlLinecardSupportedTypes<'a> {
12486 IterableDlLinecardSupportedTypes::with_loc(buf, buf.as_ptr() as usize)
12487 }
12488 fn attr_from_type(r#type: u16) -> Option<&'static str> {
12489 Devlink::attr_from_type(r#type)
12490 }
12491}
12492#[derive(Clone, Copy, Default)]
12493pub struct IterableDlLinecardSupportedTypes<'a> {
12494 buf: &'a [u8],
12495 pos: usize,
12496 orig_loc: usize,
12497}
12498impl<'a> IterableDlLinecardSupportedTypes<'a> {
12499 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
12500 Self {
12501 buf,
12502 pos: 0,
12503 orig_loc,
12504 }
12505 }
12506 pub fn get_buf(&self) -> &'a [u8] {
12507 self.buf
12508 }
12509}
12510impl<'a> Iterator for IterableDlLinecardSupportedTypes<'a> {
12511 type Item = Result<DlLinecardSupportedTypes<'a>, ErrorContext>;
12512 fn next(&mut self) -> Option<Self::Item> {
12513 let mut pos;
12514 let mut r#type;
12515 loop {
12516 pos = self.pos;
12517 r#type = None;
12518 if self.buf.len() == self.pos {
12519 return None;
12520 }
12521 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
12522 self.pos = self.buf.len();
12523 break;
12524 };
12525 r#type = Some(header.r#type);
12526 let res = match header.r#type {
12527 173u16 => DlLinecardSupportedTypes::LinecardType({
12528 let res = CStr::from_bytes_with_nul(next).ok();
12529 let Some(val) = res else { break };
12530 val
12531 }),
12532 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
12533 n => continue,
12534 };
12535 return Some(Ok(res));
12536 }
12537 Some(Err(ErrorContext::new(
12538 "DlLinecardSupportedTypes",
12539 r#type.and_then(|t| DlLinecardSupportedTypes::attr_from_type(t)),
12540 self.orig_loc,
12541 self.buf.as_ptr().wrapping_add(pos) as usize,
12542 )))
12543 }
12544}
12545impl<'a> std::fmt::Debug for IterableDlLinecardSupportedTypes<'_> {
12546 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12547 let mut fmt = f.debug_struct("DlLinecardSupportedTypes");
12548 for attr in self.clone() {
12549 let attr = match attr {
12550 Ok(a) => a,
12551 Err(err) => {
12552 fmt.finish()?;
12553 f.write_str("Err(")?;
12554 err.fmt(f)?;
12555 return f.write_str(")");
12556 }
12557 };
12558 match attr {
12559 DlLinecardSupportedTypes::LinecardType(val) => fmt.field("LinecardType", &val),
12560 };
12561 }
12562 fmt.finish()
12563 }
12564}
12565impl IterableDlLinecardSupportedTypes<'_> {
12566 pub fn lookup_attr(
12567 &self,
12568 offset: usize,
12569 missing_type: Option<u16>,
12570 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
12571 let mut stack = Vec::new();
12572 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
12573 if missing_type.is_some() && cur == offset {
12574 stack.push(("DlLinecardSupportedTypes", offset));
12575 return (
12576 stack,
12577 missing_type.and_then(|t| DlLinecardSupportedTypes::attr_from_type(t)),
12578 );
12579 }
12580 if cur > offset || cur + self.buf.len() < offset {
12581 return (stack, None);
12582 }
12583 let mut attrs = self.clone();
12584 let mut last_off = cur + attrs.pos;
12585 while let Some(attr) = attrs.next() {
12586 let Ok(attr) = attr else { break };
12587 match attr {
12588 DlLinecardSupportedTypes::LinecardType(val) => {
12589 if last_off == offset {
12590 stack.push(("LinecardType", last_off));
12591 break;
12592 }
12593 }
12594 _ => {}
12595 };
12596 last_off = cur + attrs.pos;
12597 }
12598 if !stack.is_empty() {
12599 stack.push(("DlLinecardSupportedTypes", cur));
12600 }
12601 (stack, None)
12602 }
12603}
12604#[derive(Clone)]
12605pub enum DlSelftestId {
12606 Flash(()),
12607}
12608impl<'a> IterableDlSelftestId<'a> {
12609 pub fn get_flash(&self) -> Result<(), ErrorContext> {
12610 let mut iter = self.clone();
12611 iter.pos = 0;
12612 for attr in iter {
12613 if let Ok(DlSelftestId::Flash(val)) = attr {
12614 return Ok(val);
12615 }
12616 }
12617 Err(ErrorContext::new_missing(
12618 "DlSelftestId",
12619 "Flash",
12620 self.orig_loc,
12621 self.buf.as_ptr() as usize,
12622 ))
12623 }
12624}
12625impl DlSelftestId {
12626 pub fn new<'a>(buf: &'a [u8]) -> IterableDlSelftestId<'a> {
12627 IterableDlSelftestId::with_loc(buf, buf.as_ptr() as usize)
12628 }
12629 fn attr_from_type(r#type: u16) -> Option<&'static str> {
12630 let res = match r#type {
12631 1u16 => "Flash",
12632 _ => return None,
12633 };
12634 Some(res)
12635 }
12636}
12637#[derive(Clone, Copy, Default)]
12638pub struct IterableDlSelftestId<'a> {
12639 buf: &'a [u8],
12640 pos: usize,
12641 orig_loc: usize,
12642}
12643impl<'a> IterableDlSelftestId<'a> {
12644 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
12645 Self {
12646 buf,
12647 pos: 0,
12648 orig_loc,
12649 }
12650 }
12651 pub fn get_buf(&self) -> &'a [u8] {
12652 self.buf
12653 }
12654}
12655impl<'a> Iterator for IterableDlSelftestId<'a> {
12656 type Item = Result<DlSelftestId, ErrorContext>;
12657 fn next(&mut self) -> Option<Self::Item> {
12658 let mut pos;
12659 let mut r#type;
12660 loop {
12661 pos = self.pos;
12662 r#type = None;
12663 if self.buf.len() == self.pos {
12664 return None;
12665 }
12666 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
12667 self.pos = self.buf.len();
12668 break;
12669 };
12670 r#type = Some(header.r#type);
12671 let res = match header.r#type {
12672 1u16 => DlSelftestId::Flash(()),
12673 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
12674 n => continue,
12675 };
12676 return Some(Ok(res));
12677 }
12678 Some(Err(ErrorContext::new(
12679 "DlSelftestId",
12680 r#type.and_then(|t| DlSelftestId::attr_from_type(t)),
12681 self.orig_loc,
12682 self.buf.as_ptr().wrapping_add(pos) as usize,
12683 )))
12684 }
12685}
12686impl std::fmt::Debug for IterableDlSelftestId<'_> {
12687 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12688 let mut fmt = f.debug_struct("DlSelftestId");
12689 for attr in self.clone() {
12690 let attr = match attr {
12691 Ok(a) => a,
12692 Err(err) => {
12693 fmt.finish()?;
12694 f.write_str("Err(")?;
12695 err.fmt(f)?;
12696 return f.write_str(")");
12697 }
12698 };
12699 match attr {
12700 DlSelftestId::Flash(val) => fmt.field("Flash", &val),
12701 };
12702 }
12703 fmt.finish()
12704 }
12705}
12706impl IterableDlSelftestId<'_> {
12707 pub fn lookup_attr(
12708 &self,
12709 offset: usize,
12710 missing_type: Option<u16>,
12711 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
12712 let mut stack = Vec::new();
12713 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
12714 if missing_type.is_some() && cur == offset {
12715 stack.push(("DlSelftestId", offset));
12716 return (
12717 stack,
12718 missing_type.and_then(|t| DlSelftestId::attr_from_type(t)),
12719 );
12720 }
12721 if cur > offset || cur + self.buf.len() < offset {
12722 return (stack, None);
12723 }
12724 let mut attrs = self.clone();
12725 let mut last_off = cur + attrs.pos;
12726 while let Some(attr) = attrs.next() {
12727 let Ok(attr) = attr else { break };
12728 match attr {
12729 DlSelftestId::Flash(val) => {
12730 if last_off == offset {
12731 stack.push(("Flash", last_off));
12732 break;
12733 }
12734 }
12735 _ => {}
12736 };
12737 last_off = cur + attrs.pos;
12738 }
12739 if !stack.is_empty() {
12740 stack.push(("DlSelftestId", cur));
12741 }
12742 (stack, None)
12743 }
12744}
12745#[derive(Clone)]
12746pub enum DlRateTcBws {
12747 Index(u8),
12748 #[doc = "Specifies the bandwidth share assigned to the Traffic Class. The\nbandwidth for the traffic class is determined in proportion to the sum\nof the shares of all configured classes.\n"]
12749 Bw(u32),
12750}
12751impl<'a> IterableDlRateTcBws<'a> {
12752 pub fn get_index(&self) -> Result<u8, ErrorContext> {
12753 let mut iter = self.clone();
12754 iter.pos = 0;
12755 for attr in iter {
12756 if let Ok(DlRateTcBws::Index(val)) = attr {
12757 return Ok(val);
12758 }
12759 }
12760 Err(ErrorContext::new_missing(
12761 "DlRateTcBws",
12762 "Index",
12763 self.orig_loc,
12764 self.buf.as_ptr() as usize,
12765 ))
12766 }
12767 #[doc = "Specifies the bandwidth share assigned to the Traffic Class. The\nbandwidth for the traffic class is determined in proportion to the sum\nof the shares of all configured classes.\n"]
12768 pub fn get_bw(&self) -> Result<u32, ErrorContext> {
12769 let mut iter = self.clone();
12770 iter.pos = 0;
12771 for attr in iter {
12772 if let Ok(DlRateTcBws::Bw(val)) = attr {
12773 return Ok(val);
12774 }
12775 }
12776 Err(ErrorContext::new_missing(
12777 "DlRateTcBws",
12778 "Bw",
12779 self.orig_loc,
12780 self.buf.as_ptr() as usize,
12781 ))
12782 }
12783}
12784impl DlRateTcBws {
12785 pub fn new<'a>(buf: &'a [u8]) -> IterableDlRateTcBws<'a> {
12786 IterableDlRateTcBws::with_loc(buf, buf.as_ptr() as usize)
12787 }
12788 fn attr_from_type(r#type: u16) -> Option<&'static str> {
12789 let res = match r#type {
12790 1u16 => "Index",
12791 2u16 => "Bw",
12792 _ => return None,
12793 };
12794 Some(res)
12795 }
12796}
12797#[derive(Clone, Copy, Default)]
12798pub struct IterableDlRateTcBws<'a> {
12799 buf: &'a [u8],
12800 pos: usize,
12801 orig_loc: usize,
12802}
12803impl<'a> IterableDlRateTcBws<'a> {
12804 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
12805 Self {
12806 buf,
12807 pos: 0,
12808 orig_loc,
12809 }
12810 }
12811 pub fn get_buf(&self) -> &'a [u8] {
12812 self.buf
12813 }
12814}
12815impl<'a> Iterator for IterableDlRateTcBws<'a> {
12816 type Item = Result<DlRateTcBws, ErrorContext>;
12817 fn next(&mut self) -> Option<Self::Item> {
12818 let mut pos;
12819 let mut r#type;
12820 loop {
12821 pos = self.pos;
12822 r#type = None;
12823 if self.buf.len() == self.pos {
12824 return None;
12825 }
12826 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
12827 self.pos = self.buf.len();
12828 break;
12829 };
12830 r#type = Some(header.r#type);
12831 let res = match header.r#type {
12832 1u16 => DlRateTcBws::Index({
12833 let res = parse_u8(next);
12834 let Some(val) = res else { break };
12835 val
12836 }),
12837 2u16 => DlRateTcBws::Bw({
12838 let res = parse_u32(next);
12839 let Some(val) = res else { break };
12840 val
12841 }),
12842 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
12843 n => continue,
12844 };
12845 return Some(Ok(res));
12846 }
12847 Some(Err(ErrorContext::new(
12848 "DlRateTcBws",
12849 r#type.and_then(|t| DlRateTcBws::attr_from_type(t)),
12850 self.orig_loc,
12851 self.buf.as_ptr().wrapping_add(pos) as usize,
12852 )))
12853 }
12854}
12855impl std::fmt::Debug for IterableDlRateTcBws<'_> {
12856 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12857 let mut fmt = f.debug_struct("DlRateTcBws");
12858 for attr in self.clone() {
12859 let attr = match attr {
12860 Ok(a) => a,
12861 Err(err) => {
12862 fmt.finish()?;
12863 f.write_str("Err(")?;
12864 err.fmt(f)?;
12865 return f.write_str(")");
12866 }
12867 };
12868 match attr {
12869 DlRateTcBws::Index(val) => fmt.field("Index", &val),
12870 DlRateTcBws::Bw(val) => fmt.field("Bw", &val),
12871 };
12872 }
12873 fmt.finish()
12874 }
12875}
12876impl IterableDlRateTcBws<'_> {
12877 pub fn lookup_attr(
12878 &self,
12879 offset: usize,
12880 missing_type: Option<u16>,
12881 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
12882 let mut stack = Vec::new();
12883 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
12884 if missing_type.is_some() && cur == offset {
12885 stack.push(("DlRateTcBws", offset));
12886 return (
12887 stack,
12888 missing_type.and_then(|t| DlRateTcBws::attr_from_type(t)),
12889 );
12890 }
12891 if cur > offset || cur + self.buf.len() < offset {
12892 return (stack, None);
12893 }
12894 let mut attrs = self.clone();
12895 let mut last_off = cur + attrs.pos;
12896 while let Some(attr) = attrs.next() {
12897 let Ok(attr) = attr else { break };
12898 match attr {
12899 DlRateTcBws::Index(val) => {
12900 if last_off == offset {
12901 stack.push(("Index", last_off));
12902 break;
12903 }
12904 }
12905 DlRateTcBws::Bw(val) => {
12906 if last_off == offset {
12907 stack.push(("Bw", last_off));
12908 break;
12909 }
12910 }
12911 _ => {}
12912 };
12913 last_off = cur + attrs.pos;
12914 }
12915 if !stack.is_empty() {
12916 stack.push(("DlRateTcBws", cur));
12917 }
12918 (stack, None)
12919 }
12920}
12921pub struct PushDevlink<Prev: Pusher> {
12922 pub(crate) prev: Option<Prev>,
12923 pub(crate) header_offset: Option<usize>,
12924}
12925impl<Prev: Pusher> Pusher for PushDevlink<Prev> {
12926 fn as_vec_mut(&mut self) -> &mut Vec<u8> {
12927 self.prev.as_mut().unwrap().as_vec_mut()
12928 }
12929 fn as_vec(&self) -> &Vec<u8> {
12930 self.prev.as_ref().unwrap().as_vec()
12931 }
12932}
12933impl<Prev: Pusher> PushDevlink<Prev> {
12934 pub fn new(prev: Prev) -> Self {
12935 Self {
12936 prev: Some(prev),
12937 header_offset: None,
12938 }
12939 }
12940 pub fn end_nested(mut self) -> Prev {
12941 let mut prev = self.prev.take().unwrap();
12942 if let Some(header_offset) = &self.header_offset {
12943 finalize_nested_header(prev.as_vec_mut(), *header_offset);
12944 }
12945 prev
12946 }
12947 pub fn push_bus_name(mut self, value: &CStr) -> Self {
12948 push_header(
12949 self.as_vec_mut(),
12950 1u16,
12951 value.to_bytes_with_nul().len() as u16,
12952 );
12953 self.as_vec_mut().extend(value.to_bytes_with_nul());
12954 self
12955 }
12956 pub fn push_bus_name_bytes(mut self, value: &[u8]) -> Self {
12957 push_header(self.as_vec_mut(), 1u16, (value.len() + 1) as u16);
12958 self.as_vec_mut().extend(value);
12959 self.as_vec_mut().push(0);
12960 self
12961 }
12962 pub fn push_dev_name(mut self, value: &CStr) -> Self {
12963 push_header(
12964 self.as_vec_mut(),
12965 2u16,
12966 value.to_bytes_with_nul().len() as u16,
12967 );
12968 self.as_vec_mut().extend(value.to_bytes_with_nul());
12969 self
12970 }
12971 pub fn push_dev_name_bytes(mut self, value: &[u8]) -> Self {
12972 push_header(self.as_vec_mut(), 2u16, (value.len() + 1) as u16);
12973 self.as_vec_mut().extend(value);
12974 self.as_vec_mut().push(0);
12975 self
12976 }
12977 pub fn push_port_index(mut self, value: u32) -> Self {
12978 push_header(self.as_vec_mut(), 3u16, 4 as u16);
12979 self.as_vec_mut().extend(value.to_ne_bytes());
12980 self
12981 }
12982 #[doc = "Associated type: [`PortType`] (enum)"]
12983 pub fn push_port_type(mut self, value: u16) -> Self {
12984 push_header(self.as_vec_mut(), 4u16, 2 as u16);
12985 self.as_vec_mut().extend(value.to_ne_bytes());
12986 self
12987 }
12988 pub fn push_port_desired_type(mut self, value: u16) -> Self {
12989 push_header(self.as_vec_mut(), 5u16, 2 as u16);
12990 self.as_vec_mut().extend(value.to_ne_bytes());
12991 self
12992 }
12993 pub fn push_port_netdev_ifindex(mut self, value: u32) -> Self {
12994 push_header(self.as_vec_mut(), 6u16, 4 as u16);
12995 self.as_vec_mut().extend(value.to_ne_bytes());
12996 self
12997 }
12998 pub fn push_port_netdev_name(mut self, value: &CStr) -> Self {
12999 push_header(
13000 self.as_vec_mut(),
13001 7u16,
13002 value.to_bytes_with_nul().len() as u16,
13003 );
13004 self.as_vec_mut().extend(value.to_bytes_with_nul());
13005 self
13006 }
13007 pub fn push_port_netdev_name_bytes(mut self, value: &[u8]) -> Self {
13008 push_header(self.as_vec_mut(), 7u16, (value.len() + 1) as u16);
13009 self.as_vec_mut().extend(value);
13010 self.as_vec_mut().push(0);
13011 self
13012 }
13013 pub fn push_port_ibdev_name(mut self, value: &CStr) -> Self {
13014 push_header(
13015 self.as_vec_mut(),
13016 8u16,
13017 value.to_bytes_with_nul().len() as u16,
13018 );
13019 self.as_vec_mut().extend(value.to_bytes_with_nul());
13020 self
13021 }
13022 pub fn push_port_ibdev_name_bytes(mut self, value: &[u8]) -> Self {
13023 push_header(self.as_vec_mut(), 8u16, (value.len() + 1) as u16);
13024 self.as_vec_mut().extend(value);
13025 self.as_vec_mut().push(0);
13026 self
13027 }
13028 pub fn push_port_split_count(mut self, value: u32) -> Self {
13029 push_header(self.as_vec_mut(), 9u16, 4 as u16);
13030 self.as_vec_mut().extend(value.to_ne_bytes());
13031 self
13032 }
13033 pub fn push_port_split_group(mut self, value: u32) -> Self {
13034 push_header(self.as_vec_mut(), 10u16, 4 as u16);
13035 self.as_vec_mut().extend(value.to_ne_bytes());
13036 self
13037 }
13038 pub fn push_sb_index(mut self, value: u32) -> Self {
13039 push_header(self.as_vec_mut(), 11u16, 4 as u16);
13040 self.as_vec_mut().extend(value.to_ne_bytes());
13041 self
13042 }
13043 pub fn push_sb_size(mut self, value: u32) -> Self {
13044 push_header(self.as_vec_mut(), 12u16, 4 as u16);
13045 self.as_vec_mut().extend(value.to_ne_bytes());
13046 self
13047 }
13048 pub fn push_sb_ingress_pool_count(mut self, value: u16) -> Self {
13049 push_header(self.as_vec_mut(), 13u16, 2 as u16);
13050 self.as_vec_mut().extend(value.to_ne_bytes());
13051 self
13052 }
13053 pub fn push_sb_egress_pool_count(mut self, value: u16) -> Self {
13054 push_header(self.as_vec_mut(), 14u16, 2 as u16);
13055 self.as_vec_mut().extend(value.to_ne_bytes());
13056 self
13057 }
13058 pub fn push_sb_ingress_tc_count(mut self, value: u16) -> Self {
13059 push_header(self.as_vec_mut(), 15u16, 2 as u16);
13060 self.as_vec_mut().extend(value.to_ne_bytes());
13061 self
13062 }
13063 pub fn push_sb_egress_tc_count(mut self, value: u16) -> Self {
13064 push_header(self.as_vec_mut(), 16u16, 2 as u16);
13065 self.as_vec_mut().extend(value.to_ne_bytes());
13066 self
13067 }
13068 pub fn push_sb_pool_index(mut self, value: u16) -> Self {
13069 push_header(self.as_vec_mut(), 17u16, 2 as u16);
13070 self.as_vec_mut().extend(value.to_ne_bytes());
13071 self
13072 }
13073 #[doc = "Associated type: [`SbPoolType`] (enum)"]
13074 pub fn push_sb_pool_type(mut self, value: u8) -> Self {
13075 push_header(self.as_vec_mut(), 18u16, 1 as u16);
13076 self.as_vec_mut().extend(value.to_ne_bytes());
13077 self
13078 }
13079 pub fn push_sb_pool_size(mut self, value: u32) -> Self {
13080 push_header(self.as_vec_mut(), 19u16, 4 as u16);
13081 self.as_vec_mut().extend(value.to_ne_bytes());
13082 self
13083 }
13084 #[doc = "Associated type: [`SbThresholdType`] (enum)"]
13085 pub fn push_sb_pool_threshold_type(mut self, value: u8) -> Self {
13086 push_header(self.as_vec_mut(), 20u16, 1 as u16);
13087 self.as_vec_mut().extend(value.to_ne_bytes());
13088 self
13089 }
13090 pub fn push_sb_threshold(mut self, value: u32) -> Self {
13091 push_header(self.as_vec_mut(), 21u16, 4 as u16);
13092 self.as_vec_mut().extend(value.to_ne_bytes());
13093 self
13094 }
13095 pub fn push_sb_tc_index(mut self, value: u16) -> Self {
13096 push_header(self.as_vec_mut(), 22u16, 2 as u16);
13097 self.as_vec_mut().extend(value.to_ne_bytes());
13098 self
13099 }
13100 pub fn push_sb_occ_cur(mut self, value: u32) -> Self {
13101 push_header(self.as_vec_mut(), 23u16, 4 as u16);
13102 self.as_vec_mut().extend(value.to_ne_bytes());
13103 self
13104 }
13105 pub fn push_sb_occ_max(mut self, value: u32) -> Self {
13106 push_header(self.as_vec_mut(), 24u16, 4 as u16);
13107 self.as_vec_mut().extend(value.to_ne_bytes());
13108 self
13109 }
13110 #[doc = "Associated type: [`EswitchMode`] (enum)"]
13111 pub fn push_eswitch_mode(mut self, value: u16) -> Self {
13112 push_header(self.as_vec_mut(), 25u16, 2 as u16);
13113 self.as_vec_mut().extend(value.to_ne_bytes());
13114 self
13115 }
13116 #[doc = "Associated type: [`EswitchInlineMode`] (enum)"]
13117 pub fn push_eswitch_inline_mode(mut self, value: u8) -> Self {
13118 push_header(self.as_vec_mut(), 26u16, 1 as u16);
13119 self.as_vec_mut().extend(value.to_ne_bytes());
13120 self
13121 }
13122 pub fn nested_dpipe_tables(mut self) -> PushDlDpipeTables<Self> {
13123 let header_offset = push_nested_header(self.as_vec_mut(), 27u16);
13124 PushDlDpipeTables {
13125 prev: Some(self),
13126 header_offset: Some(header_offset),
13127 }
13128 }
13129 #[doc = "Attribute may repeat multiple times (treat it as array)"]
13130 pub fn nested_dpipe_table(mut self) -> PushDlDpipeTable<Self> {
13131 let header_offset = push_nested_header(self.as_vec_mut(), 28u16);
13132 PushDlDpipeTable {
13133 prev: Some(self),
13134 header_offset: Some(header_offset),
13135 }
13136 }
13137 pub fn push_dpipe_table_name(mut self, value: &CStr) -> Self {
13138 push_header(
13139 self.as_vec_mut(),
13140 29u16,
13141 value.to_bytes_with_nul().len() as u16,
13142 );
13143 self.as_vec_mut().extend(value.to_bytes_with_nul());
13144 self
13145 }
13146 pub fn push_dpipe_table_name_bytes(mut self, value: &[u8]) -> Self {
13147 push_header(self.as_vec_mut(), 29u16, (value.len() + 1) as u16);
13148 self.as_vec_mut().extend(value);
13149 self.as_vec_mut().push(0);
13150 self
13151 }
13152 pub fn push_dpipe_table_size(mut self, value: u64) -> Self {
13153 push_header(self.as_vec_mut(), 30u16, 8 as u16);
13154 self.as_vec_mut().extend(value.to_ne_bytes());
13155 self
13156 }
13157 pub fn nested_dpipe_table_matches(mut self) -> PushDlDpipeTableMatches<Self> {
13158 let header_offset = push_nested_header(self.as_vec_mut(), 31u16);
13159 PushDlDpipeTableMatches {
13160 prev: Some(self),
13161 header_offset: Some(header_offset),
13162 }
13163 }
13164 pub fn nested_dpipe_table_actions(mut self) -> PushDlDpipeTableActions<Self> {
13165 let header_offset = push_nested_header(self.as_vec_mut(), 32u16);
13166 PushDlDpipeTableActions {
13167 prev: Some(self),
13168 header_offset: Some(header_offset),
13169 }
13170 }
13171 pub fn push_dpipe_table_counters_enabled(mut self, value: u8) -> Self {
13172 push_header(self.as_vec_mut(), 33u16, 1 as u16);
13173 self.as_vec_mut().extend(value.to_ne_bytes());
13174 self
13175 }
13176 pub fn nested_dpipe_entries(mut self) -> PushDlDpipeEntries<Self> {
13177 let header_offset = push_nested_header(self.as_vec_mut(), 34u16);
13178 PushDlDpipeEntries {
13179 prev: Some(self),
13180 header_offset: Some(header_offset),
13181 }
13182 }
13183 #[doc = "Attribute may repeat multiple times (treat it as array)"]
13184 pub fn nested_dpipe_entry(mut self) -> PushDlDpipeEntry<Self> {
13185 let header_offset = push_nested_header(self.as_vec_mut(), 35u16);
13186 PushDlDpipeEntry {
13187 prev: Some(self),
13188 header_offset: Some(header_offset),
13189 }
13190 }
13191 pub fn push_dpipe_entry_index(mut self, value: u64) -> Self {
13192 push_header(self.as_vec_mut(), 36u16, 8 as u16);
13193 self.as_vec_mut().extend(value.to_ne_bytes());
13194 self
13195 }
13196 pub fn nested_dpipe_entry_match_values(mut self) -> PushDlDpipeEntryMatchValues<Self> {
13197 let header_offset = push_nested_header(self.as_vec_mut(), 37u16);
13198 PushDlDpipeEntryMatchValues {
13199 prev: Some(self),
13200 header_offset: Some(header_offset),
13201 }
13202 }
13203 pub fn nested_dpipe_entry_action_values(mut self) -> PushDlDpipeEntryActionValues<Self> {
13204 let header_offset = push_nested_header(self.as_vec_mut(), 38u16);
13205 PushDlDpipeEntryActionValues {
13206 prev: Some(self),
13207 header_offset: Some(header_offset),
13208 }
13209 }
13210 pub fn push_dpipe_entry_counter(mut self, value: u64) -> Self {
13211 push_header(self.as_vec_mut(), 39u16, 8 as u16);
13212 self.as_vec_mut().extend(value.to_ne_bytes());
13213 self
13214 }
13215 #[doc = "Attribute may repeat multiple times (treat it as array)"]
13216 pub fn nested_dpipe_match(mut self) -> PushDlDpipeMatch<Self> {
13217 let header_offset = push_nested_header(self.as_vec_mut(), 40u16);
13218 PushDlDpipeMatch {
13219 prev: Some(self),
13220 header_offset: Some(header_offset),
13221 }
13222 }
13223 #[doc = "Attribute may repeat multiple times (treat it as array)"]
13224 pub fn nested_dpipe_match_value(mut self) -> PushDlDpipeMatchValue<Self> {
13225 let header_offset = push_nested_header(self.as_vec_mut(), 41u16);
13226 PushDlDpipeMatchValue {
13227 prev: Some(self),
13228 header_offset: Some(header_offset),
13229 }
13230 }
13231 #[doc = "Associated type: [`DpipeMatchType`] (enum)"]
13232 pub fn push_dpipe_match_type(mut self, value: u32) -> Self {
13233 push_header(self.as_vec_mut(), 42u16, 4 as u16);
13234 self.as_vec_mut().extend(value.to_ne_bytes());
13235 self
13236 }
13237 #[doc = "Attribute may repeat multiple times (treat it as array)"]
13238 pub fn nested_dpipe_action(mut self) -> PushDlDpipeAction<Self> {
13239 let header_offset = push_nested_header(self.as_vec_mut(), 43u16);
13240 PushDlDpipeAction {
13241 prev: Some(self),
13242 header_offset: Some(header_offset),
13243 }
13244 }
13245 #[doc = "Attribute may repeat multiple times (treat it as array)"]
13246 pub fn nested_dpipe_action_value(mut self) -> PushDlDpipeActionValue<Self> {
13247 let header_offset = push_nested_header(self.as_vec_mut(), 44u16);
13248 PushDlDpipeActionValue {
13249 prev: Some(self),
13250 header_offset: Some(header_offset),
13251 }
13252 }
13253 #[doc = "Associated type: [`DpipeActionType`] (enum)"]
13254 pub fn push_dpipe_action_type(mut self, value: u32) -> Self {
13255 push_header(self.as_vec_mut(), 45u16, 4 as u16);
13256 self.as_vec_mut().extend(value.to_ne_bytes());
13257 self
13258 }
13259 pub fn push_dpipe_value(mut self, value: &[u8]) -> Self {
13260 push_header(self.as_vec_mut(), 46u16, value.len() as u16);
13261 self.as_vec_mut().extend(value);
13262 self
13263 }
13264 pub fn push_dpipe_value_mask(mut self, value: &[u8]) -> Self {
13265 push_header(self.as_vec_mut(), 47u16, value.len() as u16);
13266 self.as_vec_mut().extend(value);
13267 self
13268 }
13269 pub fn push_dpipe_value_mapping(mut self, value: u32) -> Self {
13270 push_header(self.as_vec_mut(), 48u16, 4 as u16);
13271 self.as_vec_mut().extend(value.to_ne_bytes());
13272 self
13273 }
13274 pub fn nested_dpipe_headers(mut self) -> PushDlDpipeHeaders<Self> {
13275 let header_offset = push_nested_header(self.as_vec_mut(), 49u16);
13276 PushDlDpipeHeaders {
13277 prev: Some(self),
13278 header_offset: Some(header_offset),
13279 }
13280 }
13281 #[doc = "Attribute may repeat multiple times (treat it as array)"]
13282 pub fn nested_dpipe_header(mut self) -> PushDlDpipeHeader<Self> {
13283 let header_offset = push_nested_header(self.as_vec_mut(), 50u16);
13284 PushDlDpipeHeader {
13285 prev: Some(self),
13286 header_offset: Some(header_offset),
13287 }
13288 }
13289 pub fn push_dpipe_header_name(mut self, value: &CStr) -> Self {
13290 push_header(
13291 self.as_vec_mut(),
13292 51u16,
13293 value.to_bytes_with_nul().len() as u16,
13294 );
13295 self.as_vec_mut().extend(value.to_bytes_with_nul());
13296 self
13297 }
13298 pub fn push_dpipe_header_name_bytes(mut self, value: &[u8]) -> Self {
13299 push_header(self.as_vec_mut(), 51u16, (value.len() + 1) as u16);
13300 self.as_vec_mut().extend(value);
13301 self.as_vec_mut().push(0);
13302 self
13303 }
13304 #[doc = "Associated type: [`DpipeHeaderId`] (enum)"]
13305 pub fn push_dpipe_header_id(mut self, value: u32) -> Self {
13306 push_header(self.as_vec_mut(), 52u16, 4 as u16);
13307 self.as_vec_mut().extend(value.to_ne_bytes());
13308 self
13309 }
13310 pub fn nested_dpipe_header_fields(mut self) -> PushDlDpipeHeaderFields<Self> {
13311 let header_offset = push_nested_header(self.as_vec_mut(), 53u16);
13312 PushDlDpipeHeaderFields {
13313 prev: Some(self),
13314 header_offset: Some(header_offset),
13315 }
13316 }
13317 pub fn push_dpipe_header_global(mut self, value: u8) -> Self {
13318 push_header(self.as_vec_mut(), 54u16, 1 as u16);
13319 self.as_vec_mut().extend(value.to_ne_bytes());
13320 self
13321 }
13322 pub fn push_dpipe_header_index(mut self, value: u32) -> Self {
13323 push_header(self.as_vec_mut(), 55u16, 4 as u16);
13324 self.as_vec_mut().extend(value.to_ne_bytes());
13325 self
13326 }
13327 #[doc = "Attribute may repeat multiple times (treat it as array)"]
13328 pub fn nested_dpipe_field(mut self) -> PushDlDpipeField<Self> {
13329 let header_offset = push_nested_header(self.as_vec_mut(), 56u16);
13330 PushDlDpipeField {
13331 prev: Some(self),
13332 header_offset: Some(header_offset),
13333 }
13334 }
13335 pub fn push_dpipe_field_name(mut self, value: &CStr) -> Self {
13336 push_header(
13337 self.as_vec_mut(),
13338 57u16,
13339 value.to_bytes_with_nul().len() as u16,
13340 );
13341 self.as_vec_mut().extend(value.to_bytes_with_nul());
13342 self
13343 }
13344 pub fn push_dpipe_field_name_bytes(mut self, value: &[u8]) -> Self {
13345 push_header(self.as_vec_mut(), 57u16, (value.len() + 1) as u16);
13346 self.as_vec_mut().extend(value);
13347 self.as_vec_mut().push(0);
13348 self
13349 }
13350 pub fn push_dpipe_field_id(mut self, value: u32) -> Self {
13351 push_header(self.as_vec_mut(), 58u16, 4 as u16);
13352 self.as_vec_mut().extend(value.to_ne_bytes());
13353 self
13354 }
13355 pub fn push_dpipe_field_bitwidth(mut self, value: u32) -> Self {
13356 push_header(self.as_vec_mut(), 59u16, 4 as u16);
13357 self.as_vec_mut().extend(value.to_ne_bytes());
13358 self
13359 }
13360 #[doc = "Associated type: [`DpipeFieldMappingType`] (enum)"]
13361 pub fn push_dpipe_field_mapping_type(mut self, value: u32) -> Self {
13362 push_header(self.as_vec_mut(), 60u16, 4 as u16);
13363 self.as_vec_mut().extend(value.to_ne_bytes());
13364 self
13365 }
13366 pub fn push_pad(mut self, value: &[u8]) -> Self {
13367 push_header(self.as_vec_mut(), 61u16, value.len() as u16);
13368 self.as_vec_mut().extend(value);
13369 self
13370 }
13371 #[doc = "Associated type: [`EswitchEncapMode`] (enum)"]
13372 pub fn push_eswitch_encap_mode(mut self, value: u8) -> Self {
13373 push_header(self.as_vec_mut(), 62u16, 1 as u16);
13374 self.as_vec_mut().extend(value.to_ne_bytes());
13375 self
13376 }
13377 pub fn nested_resource_list(mut self) -> PushDlResourceList<Self> {
13378 let header_offset = push_nested_header(self.as_vec_mut(), 63u16);
13379 PushDlResourceList {
13380 prev: Some(self),
13381 header_offset: Some(header_offset),
13382 }
13383 }
13384 #[doc = "Attribute may repeat multiple times (treat it as array)"]
13385 pub fn nested_resource(mut self) -> PushDlResource<Self> {
13386 let header_offset = push_nested_header(self.as_vec_mut(), 64u16);
13387 PushDlResource {
13388 prev: Some(self),
13389 header_offset: Some(header_offset),
13390 }
13391 }
13392 pub fn push_resource_name(mut self, value: &CStr) -> Self {
13393 push_header(
13394 self.as_vec_mut(),
13395 65u16,
13396 value.to_bytes_with_nul().len() as u16,
13397 );
13398 self.as_vec_mut().extend(value.to_bytes_with_nul());
13399 self
13400 }
13401 pub fn push_resource_name_bytes(mut self, value: &[u8]) -> Self {
13402 push_header(self.as_vec_mut(), 65u16, (value.len() + 1) as u16);
13403 self.as_vec_mut().extend(value);
13404 self.as_vec_mut().push(0);
13405 self
13406 }
13407 pub fn push_resource_id(mut self, value: u64) -> Self {
13408 push_header(self.as_vec_mut(), 66u16, 8 as u16);
13409 self.as_vec_mut().extend(value.to_ne_bytes());
13410 self
13411 }
13412 pub fn push_resource_size(mut self, value: u64) -> Self {
13413 push_header(self.as_vec_mut(), 67u16, 8 as u16);
13414 self.as_vec_mut().extend(value.to_ne_bytes());
13415 self
13416 }
13417 pub fn push_resource_size_new(mut self, value: u64) -> Self {
13418 push_header(self.as_vec_mut(), 68u16, 8 as u16);
13419 self.as_vec_mut().extend(value.to_ne_bytes());
13420 self
13421 }
13422 pub fn push_resource_size_valid(mut self, value: u8) -> Self {
13423 push_header(self.as_vec_mut(), 69u16, 1 as u16);
13424 self.as_vec_mut().extend(value.to_ne_bytes());
13425 self
13426 }
13427 pub fn push_resource_size_min(mut self, value: u64) -> Self {
13428 push_header(self.as_vec_mut(), 70u16, 8 as u16);
13429 self.as_vec_mut().extend(value.to_ne_bytes());
13430 self
13431 }
13432 pub fn push_resource_size_max(mut self, value: u64) -> Self {
13433 push_header(self.as_vec_mut(), 71u16, 8 as u16);
13434 self.as_vec_mut().extend(value.to_ne_bytes());
13435 self
13436 }
13437 pub fn push_resource_size_gran(mut self, value: u64) -> Self {
13438 push_header(self.as_vec_mut(), 72u16, 8 as u16);
13439 self.as_vec_mut().extend(value.to_ne_bytes());
13440 self
13441 }
13442 #[doc = "Associated type: [`ResourceUnit`] (enum)"]
13443 pub fn push_resource_unit(mut self, value: u8) -> Self {
13444 push_header(self.as_vec_mut(), 73u16, 1 as u16);
13445 self.as_vec_mut().extend(value.to_ne_bytes());
13446 self
13447 }
13448 pub fn push_resource_occ(mut self, value: u64) -> Self {
13449 push_header(self.as_vec_mut(), 74u16, 8 as u16);
13450 self.as_vec_mut().extend(value.to_ne_bytes());
13451 self
13452 }
13453 pub fn push_dpipe_table_resource_id(mut self, value: u64) -> Self {
13454 push_header(self.as_vec_mut(), 75u16, 8 as u16);
13455 self.as_vec_mut().extend(value.to_ne_bytes());
13456 self
13457 }
13458 pub fn push_dpipe_table_resource_units(mut self, value: u64) -> Self {
13459 push_header(self.as_vec_mut(), 76u16, 8 as u16);
13460 self.as_vec_mut().extend(value.to_ne_bytes());
13461 self
13462 }
13463 #[doc = "Associated type: [`PortFlavour`] (enum)"]
13464 pub fn push_port_flavour(mut self, value: u16) -> Self {
13465 push_header(self.as_vec_mut(), 77u16, 2 as u16);
13466 self.as_vec_mut().extend(value.to_ne_bytes());
13467 self
13468 }
13469 pub fn push_port_number(mut self, value: u32) -> Self {
13470 push_header(self.as_vec_mut(), 78u16, 4 as u16);
13471 self.as_vec_mut().extend(value.to_ne_bytes());
13472 self
13473 }
13474 pub fn push_port_split_subport_number(mut self, value: u32) -> Self {
13475 push_header(self.as_vec_mut(), 79u16, 4 as u16);
13476 self.as_vec_mut().extend(value.to_ne_bytes());
13477 self
13478 }
13479 pub fn nested_param(mut self) -> PushDlParam<Self> {
13480 let header_offset = push_nested_header(self.as_vec_mut(), 80u16);
13481 PushDlParam {
13482 prev: Some(self),
13483 header_offset: Some(header_offset),
13484 }
13485 }
13486 pub fn push_param_name(mut self, value: &CStr) -> Self {
13487 push_header(
13488 self.as_vec_mut(),
13489 81u16,
13490 value.to_bytes_with_nul().len() as u16,
13491 );
13492 self.as_vec_mut().extend(value.to_bytes_with_nul());
13493 self
13494 }
13495 pub fn push_param_name_bytes(mut self, value: &[u8]) -> Self {
13496 push_header(self.as_vec_mut(), 81u16, (value.len() + 1) as u16);
13497 self.as_vec_mut().extend(value);
13498 self.as_vec_mut().push(0);
13499 self
13500 }
13501 pub fn push_param_generic(mut self, value: ()) -> Self {
13502 push_header(self.as_vec_mut(), 82u16, 0 as u16);
13503 self
13504 }
13505 #[doc = "Associated type: [`VarAttrType`] (enum)"]
13506 pub fn push_param_type(mut self, value: u8) -> Self {
13507 push_header(self.as_vec_mut(), 83u16, 1 as u16);
13508 self.as_vec_mut().extend(value.to_ne_bytes());
13509 self
13510 }
13511 #[doc = "Associated type: [`ParamCmode`] (enum)"]
13512 pub fn push_param_value_cmode(mut self, value: u8) -> Self {
13513 push_header(self.as_vec_mut(), 87u16, 1 as u16);
13514 self.as_vec_mut().extend(value.to_ne_bytes());
13515 self
13516 }
13517 pub fn push_region_name(mut self, value: &CStr) -> Self {
13518 push_header(
13519 self.as_vec_mut(),
13520 88u16,
13521 value.to_bytes_with_nul().len() as u16,
13522 );
13523 self.as_vec_mut().extend(value.to_bytes_with_nul());
13524 self
13525 }
13526 pub fn push_region_name_bytes(mut self, value: &[u8]) -> Self {
13527 push_header(self.as_vec_mut(), 88u16, (value.len() + 1) as u16);
13528 self.as_vec_mut().extend(value);
13529 self.as_vec_mut().push(0);
13530 self
13531 }
13532 pub fn push_region_size(mut self, value: u64) -> Self {
13533 push_header(self.as_vec_mut(), 89u16, 8 as u16);
13534 self.as_vec_mut().extend(value.to_ne_bytes());
13535 self
13536 }
13537 pub fn nested_region_snapshots(mut self) -> PushDlRegionSnapshots<Self> {
13538 let header_offset = push_nested_header(self.as_vec_mut(), 90u16);
13539 PushDlRegionSnapshots {
13540 prev: Some(self),
13541 header_offset: Some(header_offset),
13542 }
13543 }
13544 pub fn nested_region_snapshot(mut self) -> PushDlRegionSnapshot<Self> {
13545 let header_offset = push_nested_header(self.as_vec_mut(), 91u16);
13546 PushDlRegionSnapshot {
13547 prev: Some(self),
13548 header_offset: Some(header_offset),
13549 }
13550 }
13551 pub fn push_region_snapshot_id(mut self, value: u32) -> Self {
13552 push_header(self.as_vec_mut(), 92u16, 4 as u16);
13553 self.as_vec_mut().extend(value.to_ne_bytes());
13554 self
13555 }
13556 pub fn nested_region_chunks(mut self) -> PushDlRegionChunks<Self> {
13557 let header_offset = push_nested_header(self.as_vec_mut(), 93u16);
13558 PushDlRegionChunks {
13559 prev: Some(self),
13560 header_offset: Some(header_offset),
13561 }
13562 }
13563 pub fn nested_region_chunk(mut self) -> PushDlRegionChunk<Self> {
13564 let header_offset = push_nested_header(self.as_vec_mut(), 94u16);
13565 PushDlRegionChunk {
13566 prev: Some(self),
13567 header_offset: Some(header_offset),
13568 }
13569 }
13570 pub fn push_region_chunk_data(mut self, value: &[u8]) -> Self {
13571 push_header(self.as_vec_mut(), 95u16, value.len() as u16);
13572 self.as_vec_mut().extend(value);
13573 self
13574 }
13575 pub fn push_region_chunk_addr(mut self, value: u64) -> Self {
13576 push_header(self.as_vec_mut(), 96u16, 8 as u16);
13577 self.as_vec_mut().extend(value.to_ne_bytes());
13578 self
13579 }
13580 pub fn push_region_chunk_len(mut self, value: u64) -> Self {
13581 push_header(self.as_vec_mut(), 97u16, 8 as u16);
13582 self.as_vec_mut().extend(value.to_ne_bytes());
13583 self
13584 }
13585 pub fn push_info_driver_name(mut self, value: &CStr) -> Self {
13586 push_header(
13587 self.as_vec_mut(),
13588 98u16,
13589 value.to_bytes_with_nul().len() as u16,
13590 );
13591 self.as_vec_mut().extend(value.to_bytes_with_nul());
13592 self
13593 }
13594 pub fn push_info_driver_name_bytes(mut self, value: &[u8]) -> Self {
13595 push_header(self.as_vec_mut(), 98u16, (value.len() + 1) as u16);
13596 self.as_vec_mut().extend(value);
13597 self.as_vec_mut().push(0);
13598 self
13599 }
13600 pub fn push_info_serial_number(mut self, value: &CStr) -> Self {
13601 push_header(
13602 self.as_vec_mut(),
13603 99u16,
13604 value.to_bytes_with_nul().len() as u16,
13605 );
13606 self.as_vec_mut().extend(value.to_bytes_with_nul());
13607 self
13608 }
13609 pub fn push_info_serial_number_bytes(mut self, value: &[u8]) -> Self {
13610 push_header(self.as_vec_mut(), 99u16, (value.len() + 1) as u16);
13611 self.as_vec_mut().extend(value);
13612 self.as_vec_mut().push(0);
13613 self
13614 }
13615 #[doc = "Attribute may repeat multiple times (treat it as array)"]
13616 pub fn nested_info_version_fixed(mut self) -> PushDlInfoVersion<Self> {
13617 let header_offset = push_nested_header(self.as_vec_mut(), 100u16);
13618 PushDlInfoVersion {
13619 prev: Some(self),
13620 header_offset: Some(header_offset),
13621 }
13622 }
13623 #[doc = "Attribute may repeat multiple times (treat it as array)"]
13624 pub fn nested_info_version_running(mut self) -> PushDlInfoVersion<Self> {
13625 let header_offset = push_nested_header(self.as_vec_mut(), 101u16);
13626 PushDlInfoVersion {
13627 prev: Some(self),
13628 header_offset: Some(header_offset),
13629 }
13630 }
13631 #[doc = "Attribute may repeat multiple times (treat it as array)"]
13632 pub fn nested_info_version_stored(mut self) -> PushDlInfoVersion<Self> {
13633 let header_offset = push_nested_header(self.as_vec_mut(), 102u16);
13634 PushDlInfoVersion {
13635 prev: Some(self),
13636 header_offset: Some(header_offset),
13637 }
13638 }
13639 pub fn push_info_version_name(mut self, value: &CStr) -> Self {
13640 push_header(
13641 self.as_vec_mut(),
13642 103u16,
13643 value.to_bytes_with_nul().len() as u16,
13644 );
13645 self.as_vec_mut().extend(value.to_bytes_with_nul());
13646 self
13647 }
13648 pub fn push_info_version_name_bytes(mut self, value: &[u8]) -> Self {
13649 push_header(self.as_vec_mut(), 103u16, (value.len() + 1) as u16);
13650 self.as_vec_mut().extend(value);
13651 self.as_vec_mut().push(0);
13652 self
13653 }
13654 pub fn push_info_version_value(mut self, value: &CStr) -> Self {
13655 push_header(
13656 self.as_vec_mut(),
13657 104u16,
13658 value.to_bytes_with_nul().len() as u16,
13659 );
13660 self.as_vec_mut().extend(value.to_bytes_with_nul());
13661 self
13662 }
13663 pub fn push_info_version_value_bytes(mut self, value: &[u8]) -> Self {
13664 push_header(self.as_vec_mut(), 104u16, (value.len() + 1) as u16);
13665 self.as_vec_mut().extend(value);
13666 self.as_vec_mut().push(0);
13667 self
13668 }
13669 pub fn push_sb_pool_cell_size(mut self, value: u32) -> Self {
13670 push_header(self.as_vec_mut(), 105u16, 4 as u16);
13671 self.as_vec_mut().extend(value.to_ne_bytes());
13672 self
13673 }
13674 pub fn nested_fmsg(mut self) -> PushDlFmsg<Self> {
13675 let header_offset = push_nested_header(self.as_vec_mut(), 106u16);
13676 PushDlFmsg {
13677 prev: Some(self),
13678 header_offset: Some(header_offset),
13679 }
13680 }
13681 pub fn push_fmsg_obj_nest_start(mut self, value: ()) -> Self {
13682 push_header(self.as_vec_mut(), 107u16, 0 as u16);
13683 self
13684 }
13685 pub fn push_fmsg_pair_nest_start(mut self, value: ()) -> Self {
13686 push_header(self.as_vec_mut(), 108u16, 0 as u16);
13687 self
13688 }
13689 pub fn push_fmsg_arr_nest_start(mut self, value: ()) -> Self {
13690 push_header(self.as_vec_mut(), 109u16, 0 as u16);
13691 self
13692 }
13693 pub fn push_fmsg_nest_end(mut self, value: ()) -> Self {
13694 push_header(self.as_vec_mut(), 110u16, 0 as u16);
13695 self
13696 }
13697 pub fn push_fmsg_obj_name(mut self, value: &CStr) -> Self {
13698 push_header(
13699 self.as_vec_mut(),
13700 111u16,
13701 value.to_bytes_with_nul().len() as u16,
13702 );
13703 self.as_vec_mut().extend(value.to_bytes_with_nul());
13704 self
13705 }
13706 pub fn push_fmsg_obj_name_bytes(mut self, value: &[u8]) -> Self {
13707 push_header(self.as_vec_mut(), 111u16, (value.len() + 1) as u16);
13708 self.as_vec_mut().extend(value);
13709 self.as_vec_mut().push(0);
13710 self
13711 }
13712 #[doc = "Associated type: [`VarAttrType`] (enum)"]
13713 pub fn push_fmsg_obj_value_type(mut self, value: u8) -> Self {
13714 push_header(self.as_vec_mut(), 112u16, 1 as u16);
13715 self.as_vec_mut().extend(value.to_ne_bytes());
13716 self
13717 }
13718 pub fn nested_health_reporter(mut self) -> PushDlHealthReporter<Self> {
13719 let header_offset = push_nested_header(self.as_vec_mut(), 114u16);
13720 PushDlHealthReporter {
13721 prev: Some(self),
13722 header_offset: Some(header_offset),
13723 }
13724 }
13725 pub fn push_health_reporter_name(mut self, value: &CStr) -> Self {
13726 push_header(
13727 self.as_vec_mut(),
13728 115u16,
13729 value.to_bytes_with_nul().len() as u16,
13730 );
13731 self.as_vec_mut().extend(value.to_bytes_with_nul());
13732 self
13733 }
13734 pub fn push_health_reporter_name_bytes(mut self, value: &[u8]) -> Self {
13735 push_header(self.as_vec_mut(), 115u16, (value.len() + 1) as u16);
13736 self.as_vec_mut().extend(value);
13737 self.as_vec_mut().push(0);
13738 self
13739 }
13740 pub fn push_health_reporter_state(mut self, value: u8) -> Self {
13741 push_header(self.as_vec_mut(), 116u16, 1 as u16);
13742 self.as_vec_mut().extend(value.to_ne_bytes());
13743 self
13744 }
13745 pub fn push_health_reporter_err_count(mut self, value: u64) -> Self {
13746 push_header(self.as_vec_mut(), 117u16, 8 as u16);
13747 self.as_vec_mut().extend(value.to_ne_bytes());
13748 self
13749 }
13750 pub fn push_health_reporter_recover_count(mut self, value: u64) -> Self {
13751 push_header(self.as_vec_mut(), 118u16, 8 as u16);
13752 self.as_vec_mut().extend(value.to_ne_bytes());
13753 self
13754 }
13755 pub fn push_health_reporter_dump_ts(mut self, value: u64) -> Self {
13756 push_header(self.as_vec_mut(), 119u16, 8 as u16);
13757 self.as_vec_mut().extend(value.to_ne_bytes());
13758 self
13759 }
13760 pub fn push_health_reporter_graceful_period(mut self, value: u64) -> Self {
13761 push_header(self.as_vec_mut(), 120u16, 8 as u16);
13762 self.as_vec_mut().extend(value.to_ne_bytes());
13763 self
13764 }
13765 pub fn push_health_reporter_auto_recover(mut self, value: u8) -> Self {
13766 push_header(self.as_vec_mut(), 121u16, 1 as u16);
13767 self.as_vec_mut().extend(value.to_ne_bytes());
13768 self
13769 }
13770 pub fn push_flash_update_file_name(mut self, value: &CStr) -> Self {
13771 push_header(
13772 self.as_vec_mut(),
13773 122u16,
13774 value.to_bytes_with_nul().len() as u16,
13775 );
13776 self.as_vec_mut().extend(value.to_bytes_with_nul());
13777 self
13778 }
13779 pub fn push_flash_update_file_name_bytes(mut self, value: &[u8]) -> Self {
13780 push_header(self.as_vec_mut(), 122u16, (value.len() + 1) as u16);
13781 self.as_vec_mut().extend(value);
13782 self.as_vec_mut().push(0);
13783 self
13784 }
13785 pub fn push_flash_update_component(mut self, value: &CStr) -> Self {
13786 push_header(
13787 self.as_vec_mut(),
13788 123u16,
13789 value.to_bytes_with_nul().len() as u16,
13790 );
13791 self.as_vec_mut().extend(value.to_bytes_with_nul());
13792 self
13793 }
13794 pub fn push_flash_update_component_bytes(mut self, value: &[u8]) -> Self {
13795 push_header(self.as_vec_mut(), 123u16, (value.len() + 1) as u16);
13796 self.as_vec_mut().extend(value);
13797 self.as_vec_mut().push(0);
13798 self
13799 }
13800 pub fn push_flash_update_status_msg(mut self, value: &CStr) -> Self {
13801 push_header(
13802 self.as_vec_mut(),
13803 124u16,
13804 value.to_bytes_with_nul().len() as u16,
13805 );
13806 self.as_vec_mut().extend(value.to_bytes_with_nul());
13807 self
13808 }
13809 pub fn push_flash_update_status_msg_bytes(mut self, value: &[u8]) -> Self {
13810 push_header(self.as_vec_mut(), 124u16, (value.len() + 1) as u16);
13811 self.as_vec_mut().extend(value);
13812 self.as_vec_mut().push(0);
13813 self
13814 }
13815 pub fn push_flash_update_status_done(mut self, value: u64) -> Self {
13816 push_header(self.as_vec_mut(), 125u16, 8 as u16);
13817 self.as_vec_mut().extend(value.to_ne_bytes());
13818 self
13819 }
13820 pub fn push_flash_update_status_total(mut self, value: u64) -> Self {
13821 push_header(self.as_vec_mut(), 126u16, 8 as u16);
13822 self.as_vec_mut().extend(value.to_ne_bytes());
13823 self
13824 }
13825 pub fn push_port_pci_pf_number(mut self, value: u16) -> Self {
13826 push_header(self.as_vec_mut(), 127u16, 2 as u16);
13827 self.as_vec_mut().extend(value.to_ne_bytes());
13828 self
13829 }
13830 pub fn push_port_pci_vf_number(mut self, value: u16) -> Self {
13831 push_header(self.as_vec_mut(), 128u16, 2 as u16);
13832 self.as_vec_mut().extend(value.to_ne_bytes());
13833 self
13834 }
13835 pub fn nested_stats(mut self) -> PushDlAttrStats<Self> {
13836 let header_offset = push_nested_header(self.as_vec_mut(), 129u16);
13837 PushDlAttrStats {
13838 prev: Some(self),
13839 header_offset: Some(header_offset),
13840 }
13841 }
13842 pub fn push_trap_name(mut self, value: &CStr) -> Self {
13843 push_header(
13844 self.as_vec_mut(),
13845 130u16,
13846 value.to_bytes_with_nul().len() as u16,
13847 );
13848 self.as_vec_mut().extend(value.to_bytes_with_nul());
13849 self
13850 }
13851 pub fn push_trap_name_bytes(mut self, value: &[u8]) -> Self {
13852 push_header(self.as_vec_mut(), 130u16, (value.len() + 1) as u16);
13853 self.as_vec_mut().extend(value);
13854 self.as_vec_mut().push(0);
13855 self
13856 }
13857 #[doc = "Associated type: [`TrapAction`] (enum)"]
13858 pub fn push_trap_action(mut self, value: u8) -> Self {
13859 push_header(self.as_vec_mut(), 131u16, 1 as u16);
13860 self.as_vec_mut().extend(value.to_ne_bytes());
13861 self
13862 }
13863 #[doc = "Associated type: [`TrapType`] (enum)"]
13864 pub fn push_trap_type(mut self, value: u8) -> Self {
13865 push_header(self.as_vec_mut(), 132u16, 1 as u16);
13866 self.as_vec_mut().extend(value.to_ne_bytes());
13867 self
13868 }
13869 pub fn push_trap_generic(mut self, value: ()) -> Self {
13870 push_header(self.as_vec_mut(), 133u16, 0 as u16);
13871 self
13872 }
13873 pub fn nested_trap_metadata(mut self) -> PushDlTrapMetadata<Self> {
13874 let header_offset = push_nested_header(self.as_vec_mut(), 134u16);
13875 PushDlTrapMetadata {
13876 prev: Some(self),
13877 header_offset: Some(header_offset),
13878 }
13879 }
13880 pub fn push_trap_group_name(mut self, value: &CStr) -> Self {
13881 push_header(
13882 self.as_vec_mut(),
13883 135u16,
13884 value.to_bytes_with_nul().len() as u16,
13885 );
13886 self.as_vec_mut().extend(value.to_bytes_with_nul());
13887 self
13888 }
13889 pub fn push_trap_group_name_bytes(mut self, value: &[u8]) -> Self {
13890 push_header(self.as_vec_mut(), 135u16, (value.len() + 1) as u16);
13891 self.as_vec_mut().extend(value);
13892 self.as_vec_mut().push(0);
13893 self
13894 }
13895 pub fn push_reload_failed(mut self, value: u8) -> Self {
13896 push_header(self.as_vec_mut(), 136u16, 1 as u16);
13897 self.as_vec_mut().extend(value.to_ne_bytes());
13898 self
13899 }
13900 pub fn push_health_reporter_dump_ts_ns(mut self, value: u64) -> Self {
13901 push_header(self.as_vec_mut(), 137u16, 8 as u16);
13902 self.as_vec_mut().extend(value.to_ne_bytes());
13903 self
13904 }
13905 pub fn push_netns_fd(mut self, value: u32) -> Self {
13906 push_header(self.as_vec_mut(), 138u16, 4 as u16);
13907 self.as_vec_mut().extend(value.to_ne_bytes());
13908 self
13909 }
13910 pub fn push_netns_pid(mut self, value: u32) -> Self {
13911 push_header(self.as_vec_mut(), 139u16, 4 as u16);
13912 self.as_vec_mut().extend(value.to_ne_bytes());
13913 self
13914 }
13915 pub fn push_netns_id(mut self, value: u32) -> Self {
13916 push_header(self.as_vec_mut(), 140u16, 4 as u16);
13917 self.as_vec_mut().extend(value.to_ne_bytes());
13918 self
13919 }
13920 pub fn push_health_reporter_auto_dump(mut self, value: u8) -> Self {
13921 push_header(self.as_vec_mut(), 141u16, 1 as u16);
13922 self.as_vec_mut().extend(value.to_ne_bytes());
13923 self
13924 }
13925 pub fn push_trap_policer_id(mut self, value: u32) -> Self {
13926 push_header(self.as_vec_mut(), 142u16, 4 as u16);
13927 self.as_vec_mut().extend(value.to_ne_bytes());
13928 self
13929 }
13930 pub fn push_trap_policer_rate(mut self, value: u64) -> Self {
13931 push_header(self.as_vec_mut(), 143u16, 8 as u16);
13932 self.as_vec_mut().extend(value.to_ne_bytes());
13933 self
13934 }
13935 pub fn push_trap_policer_burst(mut self, value: u64) -> Self {
13936 push_header(self.as_vec_mut(), 144u16, 8 as u16);
13937 self.as_vec_mut().extend(value.to_ne_bytes());
13938 self
13939 }
13940 pub fn nested_port_function(mut self) -> PushDlPortFunction<Self> {
13941 let header_offset = push_nested_header(self.as_vec_mut(), 145u16);
13942 PushDlPortFunction {
13943 prev: Some(self),
13944 header_offset: Some(header_offset),
13945 }
13946 }
13947 pub fn push_info_board_serial_number(mut self, value: &CStr) -> Self {
13948 push_header(
13949 self.as_vec_mut(),
13950 146u16,
13951 value.to_bytes_with_nul().len() as u16,
13952 );
13953 self.as_vec_mut().extend(value.to_bytes_with_nul());
13954 self
13955 }
13956 pub fn push_info_board_serial_number_bytes(mut self, value: &[u8]) -> Self {
13957 push_header(self.as_vec_mut(), 146u16, (value.len() + 1) as u16);
13958 self.as_vec_mut().extend(value);
13959 self.as_vec_mut().push(0);
13960 self
13961 }
13962 pub fn push_port_lanes(mut self, value: u32) -> Self {
13963 push_header(self.as_vec_mut(), 147u16, 4 as u16);
13964 self.as_vec_mut().extend(value.to_ne_bytes());
13965 self
13966 }
13967 pub fn push_port_splittable(mut self, value: u8) -> Self {
13968 push_header(self.as_vec_mut(), 148u16, 1 as u16);
13969 self.as_vec_mut().extend(value.to_ne_bytes());
13970 self
13971 }
13972 pub fn push_port_external(mut self, value: u8) -> Self {
13973 push_header(self.as_vec_mut(), 149u16, 1 as u16);
13974 self.as_vec_mut().extend(value.to_ne_bytes());
13975 self
13976 }
13977 pub fn push_port_controller_number(mut self, value: u32) -> Self {
13978 push_header(self.as_vec_mut(), 150u16, 4 as u16);
13979 self.as_vec_mut().extend(value.to_ne_bytes());
13980 self
13981 }
13982 pub fn push_flash_update_status_timeout(mut self, value: u64) -> Self {
13983 push_header(self.as_vec_mut(), 151u16, 8 as u16);
13984 self.as_vec_mut().extend(value.to_ne_bytes());
13985 self
13986 }
13987 #[doc = "Associated type: [`FlashOverwrite`] (1 bit per enumeration)"]
13988 pub fn push_flash_update_overwrite_mask(mut self, value: BuiltinBitfield32) -> Self {
13989 push_header(self.as_vec_mut(), 152u16, value.as_slice().len() as u16);
13990 self.as_vec_mut().extend(value.as_slice());
13991 self
13992 }
13993 #[doc = "Associated type: [`ReloadAction`] (enum)"]
13994 pub fn push_reload_action(mut self, value: u8) -> Self {
13995 push_header(self.as_vec_mut(), 153u16, 1 as u16);
13996 self.as_vec_mut().extend(value.to_ne_bytes());
13997 self
13998 }
13999 #[doc = "Associated type: [`ReloadAction`] (1 bit per enumeration)"]
14000 pub fn push_reload_actions_performed(mut self, value: BuiltinBitfield32) -> Self {
14001 push_header(self.as_vec_mut(), 154u16, value.as_slice().len() as u16);
14002 self.as_vec_mut().extend(value.as_slice());
14003 self
14004 }
14005 #[doc = "Associated type: [`ReloadAction`] (1 bit per enumeration)"]
14006 pub fn push_reload_limits(mut self, value: BuiltinBitfield32) -> Self {
14007 push_header(self.as_vec_mut(), 155u16, value.as_slice().len() as u16);
14008 self.as_vec_mut().extend(value.as_slice());
14009 self
14010 }
14011 pub fn nested_dev_stats(mut self) -> PushDlDevStats<Self> {
14012 let header_offset = push_nested_header(self.as_vec_mut(), 156u16);
14013 PushDlDevStats {
14014 prev: Some(self),
14015 header_offset: Some(header_offset),
14016 }
14017 }
14018 pub fn nested_reload_stats(mut self) -> PushDlReloadStats<Self> {
14019 let header_offset = push_nested_header(self.as_vec_mut(), 157u16);
14020 PushDlReloadStats {
14021 prev: Some(self),
14022 header_offset: Some(header_offset),
14023 }
14024 }
14025 #[doc = "Attribute may repeat multiple times (treat it as array)"]
14026 pub fn nested_reload_stats_entry(mut self) -> PushDlReloadStatsEntry<Self> {
14027 let header_offset = push_nested_header(self.as_vec_mut(), 158u16);
14028 PushDlReloadStatsEntry {
14029 prev: Some(self),
14030 header_offset: Some(header_offset),
14031 }
14032 }
14033 pub fn push_reload_stats_limit(mut self, value: u8) -> Self {
14034 push_header(self.as_vec_mut(), 159u16, 1 as u16);
14035 self.as_vec_mut().extend(value.to_ne_bytes());
14036 self
14037 }
14038 pub fn push_reload_stats_value(mut self, value: u32) -> Self {
14039 push_header(self.as_vec_mut(), 160u16, 4 as u16);
14040 self.as_vec_mut().extend(value.to_ne_bytes());
14041 self
14042 }
14043 pub fn nested_remote_reload_stats(mut self) -> PushDlReloadStats<Self> {
14044 let header_offset = push_nested_header(self.as_vec_mut(), 161u16);
14045 PushDlReloadStats {
14046 prev: Some(self),
14047 header_offset: Some(header_offset),
14048 }
14049 }
14050 #[doc = "Attribute may repeat multiple times (treat it as array)"]
14051 pub fn nested_reload_action_info(mut self) -> PushDlReloadActInfo<Self> {
14052 let header_offset = push_nested_header(self.as_vec_mut(), 162u16);
14053 PushDlReloadActInfo {
14054 prev: Some(self),
14055 header_offset: Some(header_offset),
14056 }
14057 }
14058 #[doc = "Attribute may repeat multiple times (treat it as array)"]
14059 pub fn nested_reload_action_stats(mut self) -> PushDlReloadActStats<Self> {
14060 let header_offset = push_nested_header(self.as_vec_mut(), 163u16);
14061 PushDlReloadActStats {
14062 prev: Some(self),
14063 header_offset: Some(header_offset),
14064 }
14065 }
14066 pub fn push_port_pci_sf_number(mut self, value: u32) -> Self {
14067 push_header(self.as_vec_mut(), 164u16, 4 as u16);
14068 self.as_vec_mut().extend(value.to_ne_bytes());
14069 self
14070 }
14071 #[doc = "Associated type: [`RateType`] (enum)"]
14072 pub fn push_rate_type(mut self, value: u16) -> Self {
14073 push_header(self.as_vec_mut(), 165u16, 2 as u16);
14074 self.as_vec_mut().extend(value.to_ne_bytes());
14075 self
14076 }
14077 pub fn push_rate_tx_share(mut self, value: u64) -> Self {
14078 push_header(self.as_vec_mut(), 166u16, 8 as u16);
14079 self.as_vec_mut().extend(value.to_ne_bytes());
14080 self
14081 }
14082 pub fn push_rate_tx_max(mut self, value: u64) -> Self {
14083 push_header(self.as_vec_mut(), 167u16, 8 as u16);
14084 self.as_vec_mut().extend(value.to_ne_bytes());
14085 self
14086 }
14087 pub fn push_rate_node_name(mut self, value: &CStr) -> Self {
14088 push_header(
14089 self.as_vec_mut(),
14090 168u16,
14091 value.to_bytes_with_nul().len() as u16,
14092 );
14093 self.as_vec_mut().extend(value.to_bytes_with_nul());
14094 self
14095 }
14096 pub fn push_rate_node_name_bytes(mut self, value: &[u8]) -> Self {
14097 push_header(self.as_vec_mut(), 168u16, (value.len() + 1) as u16);
14098 self.as_vec_mut().extend(value);
14099 self.as_vec_mut().push(0);
14100 self
14101 }
14102 pub fn push_rate_parent_node_name(mut self, value: &CStr) -> Self {
14103 push_header(
14104 self.as_vec_mut(),
14105 169u16,
14106 value.to_bytes_with_nul().len() as u16,
14107 );
14108 self.as_vec_mut().extend(value.to_bytes_with_nul());
14109 self
14110 }
14111 pub fn push_rate_parent_node_name_bytes(mut self, value: &[u8]) -> Self {
14112 push_header(self.as_vec_mut(), 169u16, (value.len() + 1) as u16);
14113 self.as_vec_mut().extend(value);
14114 self.as_vec_mut().push(0);
14115 self
14116 }
14117 pub fn push_region_max_snapshots(mut self, value: u32) -> Self {
14118 push_header(self.as_vec_mut(), 170u16, 4 as u16);
14119 self.as_vec_mut().extend(value.to_ne_bytes());
14120 self
14121 }
14122 pub fn push_linecard_index(mut self, value: u32) -> Self {
14123 push_header(self.as_vec_mut(), 171u16, 4 as u16);
14124 self.as_vec_mut().extend(value.to_ne_bytes());
14125 self
14126 }
14127 pub fn push_linecard_state(mut self, value: u8) -> Self {
14128 push_header(self.as_vec_mut(), 172u16, 1 as u16);
14129 self.as_vec_mut().extend(value.to_ne_bytes());
14130 self
14131 }
14132 pub fn push_linecard_type(mut self, value: &CStr) -> Self {
14133 push_header(
14134 self.as_vec_mut(),
14135 173u16,
14136 value.to_bytes_with_nul().len() as u16,
14137 );
14138 self.as_vec_mut().extend(value.to_bytes_with_nul());
14139 self
14140 }
14141 pub fn push_linecard_type_bytes(mut self, value: &[u8]) -> Self {
14142 push_header(self.as_vec_mut(), 173u16, (value.len() + 1) as u16);
14143 self.as_vec_mut().extend(value);
14144 self.as_vec_mut().push(0);
14145 self
14146 }
14147 pub fn nested_linecard_supported_types(mut self) -> PushDlLinecardSupportedTypes<Self> {
14148 let header_offset = push_nested_header(self.as_vec_mut(), 174u16);
14149 PushDlLinecardSupportedTypes {
14150 prev: Some(self),
14151 header_offset: Some(header_offset),
14152 }
14153 }
14154 pub fn nested_selftests(mut self) -> PushDlSelftestId<Self> {
14155 let header_offset = push_nested_header(self.as_vec_mut(), 176u16);
14156 PushDlSelftestId {
14157 prev: Some(self),
14158 header_offset: Some(header_offset),
14159 }
14160 }
14161 pub fn push_rate_tx_priority(mut self, value: u32) -> Self {
14162 push_header(self.as_vec_mut(), 177u16, 4 as u16);
14163 self.as_vec_mut().extend(value.to_ne_bytes());
14164 self
14165 }
14166 pub fn push_rate_tx_weight(mut self, value: u32) -> Self {
14167 push_header(self.as_vec_mut(), 178u16, 4 as u16);
14168 self.as_vec_mut().extend(value.to_ne_bytes());
14169 self
14170 }
14171 pub fn push_region_direct(mut self, value: ()) -> Self {
14172 push_header(self.as_vec_mut(), 179u16, 0 as u16);
14173 self
14174 }
14175 #[doc = "Attribute may repeat multiple times (treat it as array)"]
14176 pub fn nested_rate_tc_bws(mut self) -> PushDlRateTcBws<Self> {
14177 let header_offset = push_nested_header(self.as_vec_mut(), 180u16);
14178 PushDlRateTcBws {
14179 prev: Some(self),
14180 header_offset: Some(header_offset),
14181 }
14182 }
14183 #[doc = "Time (in msec) for recoveries before starting the grace period.\n"]
14184 pub fn push_health_reporter_burst_period(mut self, value: u64) -> Self {
14185 push_header(self.as_vec_mut(), 181u16, 8 as u16);
14186 self.as_vec_mut().extend(value.to_ne_bytes());
14187 self
14188 }
14189 #[doc = "Request restoring parameter to its default value.\n"]
14190 pub fn push_param_reset_default(mut self, value: ()) -> Self {
14191 push_header(self.as_vec_mut(), 183u16, 0 as u16);
14192 self
14193 }
14194 #[doc = "Unique devlink instance index.\n"]
14195 pub fn push_index(mut self, value: u32) -> Self {
14196 push_header(self.as_vec_mut(), 184u16, 4 as u16);
14197 self.as_vec_mut().extend(value.to_ne_bytes());
14198 self
14199 }
14200 #[doc = "Bitmask selecting which resource classes to include in a resource-dump\nresponse. Bit 0 (dev) selects device-level resources; bit 1 (port)\nselects port-level resources. When absent all classes are returned.\n\nAssociated type: [`ResourceScope`] (1 bit per enumeration)"]
14201 pub fn push_resource_scope_mask(mut self, value: u32) -> Self {
14202 push_header(self.as_vec_mut(), 185u16, 4 as u16);
14203 self.as_vec_mut().extend(value.to_ne_bytes());
14204 self
14205 }
14206}
14207impl<Prev: Pusher> Drop for PushDevlink<Prev> {
14208 fn drop(&mut self) {
14209 if let Some(prev) = &mut self.prev {
14210 if let Some(header_offset) = &self.header_offset {
14211 finalize_nested_header(prev.as_vec_mut(), *header_offset);
14212 }
14213 }
14214 }
14215}
14216pub struct PushDlDevStats<Prev: Pusher> {
14217 pub(crate) prev: Option<Prev>,
14218 pub(crate) header_offset: Option<usize>,
14219}
14220impl<Prev: Pusher> Pusher for PushDlDevStats<Prev> {
14221 fn as_vec_mut(&mut self) -> &mut Vec<u8> {
14222 self.prev.as_mut().unwrap().as_vec_mut()
14223 }
14224 fn as_vec(&self) -> &Vec<u8> {
14225 self.prev.as_ref().unwrap().as_vec()
14226 }
14227}
14228impl<Prev: Pusher> PushDlDevStats<Prev> {
14229 pub fn new(prev: Prev) -> Self {
14230 Self {
14231 prev: Some(prev),
14232 header_offset: None,
14233 }
14234 }
14235 pub fn end_nested(mut self) -> Prev {
14236 let mut prev = self.prev.take().unwrap();
14237 if let Some(header_offset) = &self.header_offset {
14238 finalize_nested_header(prev.as_vec_mut(), *header_offset);
14239 }
14240 prev
14241 }
14242 pub fn nested_reload_stats(mut self) -> PushDlReloadStats<Self> {
14243 let header_offset = push_nested_header(self.as_vec_mut(), 157u16);
14244 PushDlReloadStats {
14245 prev: Some(self),
14246 header_offset: Some(header_offset),
14247 }
14248 }
14249 pub fn nested_remote_reload_stats(mut self) -> PushDlReloadStats<Self> {
14250 let header_offset = push_nested_header(self.as_vec_mut(), 161u16);
14251 PushDlReloadStats {
14252 prev: Some(self),
14253 header_offset: Some(header_offset),
14254 }
14255 }
14256}
14257impl<Prev: Pusher> Drop for PushDlDevStats<Prev> {
14258 fn drop(&mut self) {
14259 if let Some(prev) = &mut self.prev {
14260 if let Some(header_offset) = &self.header_offset {
14261 finalize_nested_header(prev.as_vec_mut(), *header_offset);
14262 }
14263 }
14264 }
14265}
14266pub struct PushDlReloadStats<Prev: Pusher> {
14267 pub(crate) prev: Option<Prev>,
14268 pub(crate) header_offset: Option<usize>,
14269}
14270impl<Prev: Pusher> Pusher for PushDlReloadStats<Prev> {
14271 fn as_vec_mut(&mut self) -> &mut Vec<u8> {
14272 self.prev.as_mut().unwrap().as_vec_mut()
14273 }
14274 fn as_vec(&self) -> &Vec<u8> {
14275 self.prev.as_ref().unwrap().as_vec()
14276 }
14277}
14278impl<Prev: Pusher> PushDlReloadStats<Prev> {
14279 pub fn new(prev: Prev) -> Self {
14280 Self {
14281 prev: Some(prev),
14282 header_offset: None,
14283 }
14284 }
14285 pub fn end_nested(mut self) -> Prev {
14286 let mut prev = self.prev.take().unwrap();
14287 if let Some(header_offset) = &self.header_offset {
14288 finalize_nested_header(prev.as_vec_mut(), *header_offset);
14289 }
14290 prev
14291 }
14292 #[doc = "Attribute may repeat multiple times (treat it as array)"]
14293 pub fn nested_reload_action_info(mut self) -> PushDlReloadActInfo<Self> {
14294 let header_offset = push_nested_header(self.as_vec_mut(), 162u16);
14295 PushDlReloadActInfo {
14296 prev: Some(self),
14297 header_offset: Some(header_offset),
14298 }
14299 }
14300}
14301impl<Prev: Pusher> Drop for PushDlReloadStats<Prev> {
14302 fn drop(&mut self) {
14303 if let Some(prev) = &mut self.prev {
14304 if let Some(header_offset) = &self.header_offset {
14305 finalize_nested_header(prev.as_vec_mut(), *header_offset);
14306 }
14307 }
14308 }
14309}
14310pub struct PushDlReloadActInfo<Prev: Pusher> {
14311 pub(crate) prev: Option<Prev>,
14312 pub(crate) header_offset: Option<usize>,
14313}
14314impl<Prev: Pusher> Pusher for PushDlReloadActInfo<Prev> {
14315 fn as_vec_mut(&mut self) -> &mut Vec<u8> {
14316 self.prev.as_mut().unwrap().as_vec_mut()
14317 }
14318 fn as_vec(&self) -> &Vec<u8> {
14319 self.prev.as_ref().unwrap().as_vec()
14320 }
14321}
14322impl<Prev: Pusher> PushDlReloadActInfo<Prev> {
14323 pub fn new(prev: Prev) -> Self {
14324 Self {
14325 prev: Some(prev),
14326 header_offset: None,
14327 }
14328 }
14329 pub fn end_nested(mut self) -> Prev {
14330 let mut prev = self.prev.take().unwrap();
14331 if let Some(header_offset) = &self.header_offset {
14332 finalize_nested_header(prev.as_vec_mut(), *header_offset);
14333 }
14334 prev
14335 }
14336 #[doc = "Associated type: [`ReloadAction`] (enum)"]
14337 pub fn push_reload_action(mut self, value: u8) -> Self {
14338 push_header(self.as_vec_mut(), 153u16, 1 as u16);
14339 self.as_vec_mut().extend(value.to_ne_bytes());
14340 self
14341 }
14342 #[doc = "Attribute may repeat multiple times (treat it as array)"]
14343 pub fn nested_reload_action_stats(mut self) -> PushDlReloadActStats<Self> {
14344 let header_offset = push_nested_header(self.as_vec_mut(), 163u16);
14345 PushDlReloadActStats {
14346 prev: Some(self),
14347 header_offset: Some(header_offset),
14348 }
14349 }
14350}
14351impl<Prev: Pusher> Drop for PushDlReloadActInfo<Prev> {
14352 fn drop(&mut self) {
14353 if let Some(prev) = &mut self.prev {
14354 if let Some(header_offset) = &self.header_offset {
14355 finalize_nested_header(prev.as_vec_mut(), *header_offset);
14356 }
14357 }
14358 }
14359}
14360pub struct PushDlReloadActStats<Prev: Pusher> {
14361 pub(crate) prev: Option<Prev>,
14362 pub(crate) header_offset: Option<usize>,
14363}
14364impl<Prev: Pusher> Pusher for PushDlReloadActStats<Prev> {
14365 fn as_vec_mut(&mut self) -> &mut Vec<u8> {
14366 self.prev.as_mut().unwrap().as_vec_mut()
14367 }
14368 fn as_vec(&self) -> &Vec<u8> {
14369 self.prev.as_ref().unwrap().as_vec()
14370 }
14371}
14372impl<Prev: Pusher> PushDlReloadActStats<Prev> {
14373 pub fn new(prev: Prev) -> Self {
14374 Self {
14375 prev: Some(prev),
14376 header_offset: None,
14377 }
14378 }
14379 pub fn end_nested(mut self) -> Prev {
14380 let mut prev = self.prev.take().unwrap();
14381 if let Some(header_offset) = &self.header_offset {
14382 finalize_nested_header(prev.as_vec_mut(), *header_offset);
14383 }
14384 prev
14385 }
14386 #[doc = "Attribute may repeat multiple times (treat it as array)"]
14387 pub fn nested_reload_stats_entry(mut self) -> PushDlReloadStatsEntry<Self> {
14388 let header_offset = push_nested_header(self.as_vec_mut(), 158u16);
14389 PushDlReloadStatsEntry {
14390 prev: Some(self),
14391 header_offset: Some(header_offset),
14392 }
14393 }
14394}
14395impl<Prev: Pusher> Drop for PushDlReloadActStats<Prev> {
14396 fn drop(&mut self) {
14397 if let Some(prev) = &mut self.prev {
14398 if let Some(header_offset) = &self.header_offset {
14399 finalize_nested_header(prev.as_vec_mut(), *header_offset);
14400 }
14401 }
14402 }
14403}
14404pub struct PushDlReloadStatsEntry<Prev: Pusher> {
14405 pub(crate) prev: Option<Prev>,
14406 pub(crate) header_offset: Option<usize>,
14407}
14408impl<Prev: Pusher> Pusher for PushDlReloadStatsEntry<Prev> {
14409 fn as_vec_mut(&mut self) -> &mut Vec<u8> {
14410 self.prev.as_mut().unwrap().as_vec_mut()
14411 }
14412 fn as_vec(&self) -> &Vec<u8> {
14413 self.prev.as_ref().unwrap().as_vec()
14414 }
14415}
14416impl<Prev: Pusher> PushDlReloadStatsEntry<Prev> {
14417 pub fn new(prev: Prev) -> Self {
14418 Self {
14419 prev: Some(prev),
14420 header_offset: None,
14421 }
14422 }
14423 pub fn end_nested(mut self) -> Prev {
14424 let mut prev = self.prev.take().unwrap();
14425 if let Some(header_offset) = &self.header_offset {
14426 finalize_nested_header(prev.as_vec_mut(), *header_offset);
14427 }
14428 prev
14429 }
14430 pub fn push_reload_stats_limit(mut self, value: u8) -> Self {
14431 push_header(self.as_vec_mut(), 159u16, 1 as u16);
14432 self.as_vec_mut().extend(value.to_ne_bytes());
14433 self
14434 }
14435 pub fn push_reload_stats_value(mut self, value: u32) -> Self {
14436 push_header(self.as_vec_mut(), 160u16, 4 as u16);
14437 self.as_vec_mut().extend(value.to_ne_bytes());
14438 self
14439 }
14440}
14441impl<Prev: Pusher> Drop for PushDlReloadStatsEntry<Prev> {
14442 fn drop(&mut self) {
14443 if let Some(prev) = &mut self.prev {
14444 if let Some(header_offset) = &self.header_offset {
14445 finalize_nested_header(prev.as_vec_mut(), *header_offset);
14446 }
14447 }
14448 }
14449}
14450pub struct PushDlInfoVersion<Prev: Pusher> {
14451 pub(crate) prev: Option<Prev>,
14452 pub(crate) header_offset: Option<usize>,
14453}
14454impl<Prev: Pusher> Pusher for PushDlInfoVersion<Prev> {
14455 fn as_vec_mut(&mut self) -> &mut Vec<u8> {
14456 self.prev.as_mut().unwrap().as_vec_mut()
14457 }
14458 fn as_vec(&self) -> &Vec<u8> {
14459 self.prev.as_ref().unwrap().as_vec()
14460 }
14461}
14462impl<Prev: Pusher> PushDlInfoVersion<Prev> {
14463 pub fn new(prev: Prev) -> Self {
14464 Self {
14465 prev: Some(prev),
14466 header_offset: None,
14467 }
14468 }
14469 pub fn end_nested(mut self) -> Prev {
14470 let mut prev = self.prev.take().unwrap();
14471 if let Some(header_offset) = &self.header_offset {
14472 finalize_nested_header(prev.as_vec_mut(), *header_offset);
14473 }
14474 prev
14475 }
14476 pub fn push_info_version_name(mut self, value: &CStr) -> Self {
14477 push_header(
14478 self.as_vec_mut(),
14479 103u16,
14480 value.to_bytes_with_nul().len() as u16,
14481 );
14482 self.as_vec_mut().extend(value.to_bytes_with_nul());
14483 self
14484 }
14485 pub fn push_info_version_name_bytes(mut self, value: &[u8]) -> Self {
14486 push_header(self.as_vec_mut(), 103u16, (value.len() + 1) as u16);
14487 self.as_vec_mut().extend(value);
14488 self.as_vec_mut().push(0);
14489 self
14490 }
14491 pub fn push_info_version_value(mut self, value: &CStr) -> Self {
14492 push_header(
14493 self.as_vec_mut(),
14494 104u16,
14495 value.to_bytes_with_nul().len() as u16,
14496 );
14497 self.as_vec_mut().extend(value.to_bytes_with_nul());
14498 self
14499 }
14500 pub fn push_info_version_value_bytes(mut self, value: &[u8]) -> Self {
14501 push_header(self.as_vec_mut(), 104u16, (value.len() + 1) as u16);
14502 self.as_vec_mut().extend(value);
14503 self.as_vec_mut().push(0);
14504 self
14505 }
14506}
14507impl<Prev: Pusher> Drop for PushDlInfoVersion<Prev> {
14508 fn drop(&mut self) {
14509 if let Some(prev) = &mut self.prev {
14510 if let Some(header_offset) = &self.header_offset {
14511 finalize_nested_header(prev.as_vec_mut(), *header_offset);
14512 }
14513 }
14514 }
14515}
14516pub struct PushDlPortFunction<Prev: Pusher> {
14517 pub(crate) prev: Option<Prev>,
14518 pub(crate) header_offset: Option<usize>,
14519}
14520impl<Prev: Pusher> Pusher for PushDlPortFunction<Prev> {
14521 fn as_vec_mut(&mut self) -> &mut Vec<u8> {
14522 self.prev.as_mut().unwrap().as_vec_mut()
14523 }
14524 fn as_vec(&self) -> &Vec<u8> {
14525 self.prev.as_ref().unwrap().as_vec()
14526 }
14527}
14528impl<Prev: Pusher> PushDlPortFunction<Prev> {
14529 pub fn new(prev: Prev) -> Self {
14530 Self {
14531 prev: Some(prev),
14532 header_offset: None,
14533 }
14534 }
14535 pub fn end_nested(mut self) -> Prev {
14536 let mut prev = self.prev.take().unwrap();
14537 if let Some(header_offset) = &self.header_offset {
14538 finalize_nested_header(prev.as_vec_mut(), *header_offset);
14539 }
14540 prev
14541 }
14542 pub fn push_hw_addr(mut self, value: &[u8]) -> Self {
14543 push_header(self.as_vec_mut(), 1u16, value.len() as u16);
14544 self.as_vec_mut().extend(value);
14545 self
14546 }
14547 #[doc = "Associated type: [`PortFnState`] (enum)"]
14548 pub fn push_state(mut self, value: u8) -> Self {
14549 push_header(self.as_vec_mut(), 2u16, 1 as u16);
14550 self.as_vec_mut().extend(value.to_ne_bytes());
14551 self
14552 }
14553 #[doc = "Associated type: [`PortFnOpstate`] (enum)"]
14554 pub fn push_opstate(mut self, value: u8) -> Self {
14555 push_header(self.as_vec_mut(), 3u16, 1 as u16);
14556 self.as_vec_mut().extend(value.to_ne_bytes());
14557 self
14558 }
14559 #[doc = "Associated type: [`PortFnAttrCap`] (1 bit per enumeration)"]
14560 pub fn push_caps(mut self, value: BuiltinBitfield32) -> Self {
14561 push_header(self.as_vec_mut(), 4u16, value.as_slice().len() as u16);
14562 self.as_vec_mut().extend(value.as_slice());
14563 self
14564 }
14565}
14566impl<Prev: Pusher> Drop for PushDlPortFunction<Prev> {
14567 fn drop(&mut self) {
14568 if let Some(prev) = &mut self.prev {
14569 if let Some(header_offset) = &self.header_offset {
14570 finalize_nested_header(prev.as_vec_mut(), *header_offset);
14571 }
14572 }
14573 }
14574}
14575pub struct PushDlDpipeTables<Prev: Pusher> {
14576 pub(crate) prev: Option<Prev>,
14577 pub(crate) header_offset: Option<usize>,
14578}
14579impl<Prev: Pusher> Pusher for PushDlDpipeTables<Prev> {
14580 fn as_vec_mut(&mut self) -> &mut Vec<u8> {
14581 self.prev.as_mut().unwrap().as_vec_mut()
14582 }
14583 fn as_vec(&self) -> &Vec<u8> {
14584 self.prev.as_ref().unwrap().as_vec()
14585 }
14586}
14587impl<Prev: Pusher> PushDlDpipeTables<Prev> {
14588 pub fn new(prev: Prev) -> Self {
14589 Self {
14590 prev: Some(prev),
14591 header_offset: None,
14592 }
14593 }
14594 pub fn end_nested(mut self) -> Prev {
14595 let mut prev = self.prev.take().unwrap();
14596 if let Some(header_offset) = &self.header_offset {
14597 finalize_nested_header(prev.as_vec_mut(), *header_offset);
14598 }
14599 prev
14600 }
14601 #[doc = "Attribute may repeat multiple times (treat it as array)"]
14602 pub fn nested_dpipe_table(mut self) -> PushDlDpipeTable<Self> {
14603 let header_offset = push_nested_header(self.as_vec_mut(), 28u16);
14604 PushDlDpipeTable {
14605 prev: Some(self),
14606 header_offset: Some(header_offset),
14607 }
14608 }
14609}
14610impl<Prev: Pusher> Drop for PushDlDpipeTables<Prev> {
14611 fn drop(&mut self) {
14612 if let Some(prev) = &mut self.prev {
14613 if let Some(header_offset) = &self.header_offset {
14614 finalize_nested_header(prev.as_vec_mut(), *header_offset);
14615 }
14616 }
14617 }
14618}
14619pub struct PushDlDpipeTable<Prev: Pusher> {
14620 pub(crate) prev: Option<Prev>,
14621 pub(crate) header_offset: Option<usize>,
14622}
14623impl<Prev: Pusher> Pusher for PushDlDpipeTable<Prev> {
14624 fn as_vec_mut(&mut self) -> &mut Vec<u8> {
14625 self.prev.as_mut().unwrap().as_vec_mut()
14626 }
14627 fn as_vec(&self) -> &Vec<u8> {
14628 self.prev.as_ref().unwrap().as_vec()
14629 }
14630}
14631impl<Prev: Pusher> PushDlDpipeTable<Prev> {
14632 pub fn new(prev: Prev) -> Self {
14633 Self {
14634 prev: Some(prev),
14635 header_offset: None,
14636 }
14637 }
14638 pub fn end_nested(mut self) -> Prev {
14639 let mut prev = self.prev.take().unwrap();
14640 if let Some(header_offset) = &self.header_offset {
14641 finalize_nested_header(prev.as_vec_mut(), *header_offset);
14642 }
14643 prev
14644 }
14645 pub fn push_dpipe_table_name(mut self, value: &CStr) -> Self {
14646 push_header(
14647 self.as_vec_mut(),
14648 29u16,
14649 value.to_bytes_with_nul().len() as u16,
14650 );
14651 self.as_vec_mut().extend(value.to_bytes_with_nul());
14652 self
14653 }
14654 pub fn push_dpipe_table_name_bytes(mut self, value: &[u8]) -> Self {
14655 push_header(self.as_vec_mut(), 29u16, (value.len() + 1) as u16);
14656 self.as_vec_mut().extend(value);
14657 self.as_vec_mut().push(0);
14658 self
14659 }
14660 pub fn push_dpipe_table_size(mut self, value: u64) -> Self {
14661 push_header(self.as_vec_mut(), 30u16, 8 as u16);
14662 self.as_vec_mut().extend(value.to_ne_bytes());
14663 self
14664 }
14665 pub fn nested_dpipe_table_matches(mut self) -> PushDlDpipeTableMatches<Self> {
14666 let header_offset = push_nested_header(self.as_vec_mut(), 31u16);
14667 PushDlDpipeTableMatches {
14668 prev: Some(self),
14669 header_offset: Some(header_offset),
14670 }
14671 }
14672 pub fn nested_dpipe_table_actions(mut self) -> PushDlDpipeTableActions<Self> {
14673 let header_offset = push_nested_header(self.as_vec_mut(), 32u16);
14674 PushDlDpipeTableActions {
14675 prev: Some(self),
14676 header_offset: Some(header_offset),
14677 }
14678 }
14679 pub fn push_dpipe_table_counters_enabled(mut self, value: u8) -> Self {
14680 push_header(self.as_vec_mut(), 33u16, 1 as u16);
14681 self.as_vec_mut().extend(value.to_ne_bytes());
14682 self
14683 }
14684 pub fn push_dpipe_table_resource_id(mut self, value: u64) -> Self {
14685 push_header(self.as_vec_mut(), 75u16, 8 as u16);
14686 self.as_vec_mut().extend(value.to_ne_bytes());
14687 self
14688 }
14689 pub fn push_dpipe_table_resource_units(mut self, value: u64) -> Self {
14690 push_header(self.as_vec_mut(), 76u16, 8 as u16);
14691 self.as_vec_mut().extend(value.to_ne_bytes());
14692 self
14693 }
14694}
14695impl<Prev: Pusher> Drop for PushDlDpipeTable<Prev> {
14696 fn drop(&mut self) {
14697 if let Some(prev) = &mut self.prev {
14698 if let Some(header_offset) = &self.header_offset {
14699 finalize_nested_header(prev.as_vec_mut(), *header_offset);
14700 }
14701 }
14702 }
14703}
14704pub struct PushDlDpipeTableMatches<Prev: Pusher> {
14705 pub(crate) prev: Option<Prev>,
14706 pub(crate) header_offset: Option<usize>,
14707}
14708impl<Prev: Pusher> Pusher for PushDlDpipeTableMatches<Prev> {
14709 fn as_vec_mut(&mut self) -> &mut Vec<u8> {
14710 self.prev.as_mut().unwrap().as_vec_mut()
14711 }
14712 fn as_vec(&self) -> &Vec<u8> {
14713 self.prev.as_ref().unwrap().as_vec()
14714 }
14715}
14716impl<Prev: Pusher> PushDlDpipeTableMatches<Prev> {
14717 pub fn new(prev: Prev) -> Self {
14718 Self {
14719 prev: Some(prev),
14720 header_offset: None,
14721 }
14722 }
14723 pub fn end_nested(mut self) -> Prev {
14724 let mut prev = self.prev.take().unwrap();
14725 if let Some(header_offset) = &self.header_offset {
14726 finalize_nested_header(prev.as_vec_mut(), *header_offset);
14727 }
14728 prev
14729 }
14730 #[doc = "Attribute may repeat multiple times (treat it as array)"]
14731 pub fn nested_dpipe_match(mut self) -> PushDlDpipeMatch<Self> {
14732 let header_offset = push_nested_header(self.as_vec_mut(), 40u16);
14733 PushDlDpipeMatch {
14734 prev: Some(self),
14735 header_offset: Some(header_offset),
14736 }
14737 }
14738}
14739impl<Prev: Pusher> Drop for PushDlDpipeTableMatches<Prev> {
14740 fn drop(&mut self) {
14741 if let Some(prev) = &mut self.prev {
14742 if let Some(header_offset) = &self.header_offset {
14743 finalize_nested_header(prev.as_vec_mut(), *header_offset);
14744 }
14745 }
14746 }
14747}
14748pub struct PushDlDpipeTableActions<Prev: Pusher> {
14749 pub(crate) prev: Option<Prev>,
14750 pub(crate) header_offset: Option<usize>,
14751}
14752impl<Prev: Pusher> Pusher for PushDlDpipeTableActions<Prev> {
14753 fn as_vec_mut(&mut self) -> &mut Vec<u8> {
14754 self.prev.as_mut().unwrap().as_vec_mut()
14755 }
14756 fn as_vec(&self) -> &Vec<u8> {
14757 self.prev.as_ref().unwrap().as_vec()
14758 }
14759}
14760impl<Prev: Pusher> PushDlDpipeTableActions<Prev> {
14761 pub fn new(prev: Prev) -> Self {
14762 Self {
14763 prev: Some(prev),
14764 header_offset: None,
14765 }
14766 }
14767 pub fn end_nested(mut self) -> Prev {
14768 let mut prev = self.prev.take().unwrap();
14769 if let Some(header_offset) = &self.header_offset {
14770 finalize_nested_header(prev.as_vec_mut(), *header_offset);
14771 }
14772 prev
14773 }
14774 #[doc = "Attribute may repeat multiple times (treat it as array)"]
14775 pub fn nested_dpipe_action(mut self) -> PushDlDpipeAction<Self> {
14776 let header_offset = push_nested_header(self.as_vec_mut(), 43u16);
14777 PushDlDpipeAction {
14778 prev: Some(self),
14779 header_offset: Some(header_offset),
14780 }
14781 }
14782}
14783impl<Prev: Pusher> Drop for PushDlDpipeTableActions<Prev> {
14784 fn drop(&mut self) {
14785 if let Some(prev) = &mut self.prev {
14786 if let Some(header_offset) = &self.header_offset {
14787 finalize_nested_header(prev.as_vec_mut(), *header_offset);
14788 }
14789 }
14790 }
14791}
14792pub struct PushDlDpipeEntries<Prev: Pusher> {
14793 pub(crate) prev: Option<Prev>,
14794 pub(crate) header_offset: Option<usize>,
14795}
14796impl<Prev: Pusher> Pusher for PushDlDpipeEntries<Prev> {
14797 fn as_vec_mut(&mut self) -> &mut Vec<u8> {
14798 self.prev.as_mut().unwrap().as_vec_mut()
14799 }
14800 fn as_vec(&self) -> &Vec<u8> {
14801 self.prev.as_ref().unwrap().as_vec()
14802 }
14803}
14804impl<Prev: Pusher> PushDlDpipeEntries<Prev> {
14805 pub fn new(prev: Prev) -> Self {
14806 Self {
14807 prev: Some(prev),
14808 header_offset: None,
14809 }
14810 }
14811 pub fn end_nested(mut self) -> Prev {
14812 let mut prev = self.prev.take().unwrap();
14813 if let Some(header_offset) = &self.header_offset {
14814 finalize_nested_header(prev.as_vec_mut(), *header_offset);
14815 }
14816 prev
14817 }
14818 #[doc = "Attribute may repeat multiple times (treat it as array)"]
14819 pub fn nested_dpipe_entry(mut self) -> PushDlDpipeEntry<Self> {
14820 let header_offset = push_nested_header(self.as_vec_mut(), 35u16);
14821 PushDlDpipeEntry {
14822 prev: Some(self),
14823 header_offset: Some(header_offset),
14824 }
14825 }
14826}
14827impl<Prev: Pusher> Drop for PushDlDpipeEntries<Prev> {
14828 fn drop(&mut self) {
14829 if let Some(prev) = &mut self.prev {
14830 if let Some(header_offset) = &self.header_offset {
14831 finalize_nested_header(prev.as_vec_mut(), *header_offset);
14832 }
14833 }
14834 }
14835}
14836pub struct PushDlDpipeEntry<Prev: Pusher> {
14837 pub(crate) prev: Option<Prev>,
14838 pub(crate) header_offset: Option<usize>,
14839}
14840impl<Prev: Pusher> Pusher for PushDlDpipeEntry<Prev> {
14841 fn as_vec_mut(&mut self) -> &mut Vec<u8> {
14842 self.prev.as_mut().unwrap().as_vec_mut()
14843 }
14844 fn as_vec(&self) -> &Vec<u8> {
14845 self.prev.as_ref().unwrap().as_vec()
14846 }
14847}
14848impl<Prev: Pusher> PushDlDpipeEntry<Prev> {
14849 pub fn new(prev: Prev) -> Self {
14850 Self {
14851 prev: Some(prev),
14852 header_offset: None,
14853 }
14854 }
14855 pub fn end_nested(mut self) -> Prev {
14856 let mut prev = self.prev.take().unwrap();
14857 if let Some(header_offset) = &self.header_offset {
14858 finalize_nested_header(prev.as_vec_mut(), *header_offset);
14859 }
14860 prev
14861 }
14862 pub fn push_dpipe_entry_index(mut self, value: u64) -> Self {
14863 push_header(self.as_vec_mut(), 36u16, 8 as u16);
14864 self.as_vec_mut().extend(value.to_ne_bytes());
14865 self
14866 }
14867 pub fn nested_dpipe_entry_match_values(mut self) -> PushDlDpipeEntryMatchValues<Self> {
14868 let header_offset = push_nested_header(self.as_vec_mut(), 37u16);
14869 PushDlDpipeEntryMatchValues {
14870 prev: Some(self),
14871 header_offset: Some(header_offset),
14872 }
14873 }
14874 pub fn nested_dpipe_entry_action_values(mut self) -> PushDlDpipeEntryActionValues<Self> {
14875 let header_offset = push_nested_header(self.as_vec_mut(), 38u16);
14876 PushDlDpipeEntryActionValues {
14877 prev: Some(self),
14878 header_offset: Some(header_offset),
14879 }
14880 }
14881 pub fn push_dpipe_entry_counter(mut self, value: u64) -> Self {
14882 push_header(self.as_vec_mut(), 39u16, 8 as u16);
14883 self.as_vec_mut().extend(value.to_ne_bytes());
14884 self
14885 }
14886}
14887impl<Prev: Pusher> Drop for PushDlDpipeEntry<Prev> {
14888 fn drop(&mut self) {
14889 if let Some(prev) = &mut self.prev {
14890 if let Some(header_offset) = &self.header_offset {
14891 finalize_nested_header(prev.as_vec_mut(), *header_offset);
14892 }
14893 }
14894 }
14895}
14896pub struct PushDlDpipeEntryMatchValues<Prev: Pusher> {
14897 pub(crate) prev: Option<Prev>,
14898 pub(crate) header_offset: Option<usize>,
14899}
14900impl<Prev: Pusher> Pusher for PushDlDpipeEntryMatchValues<Prev> {
14901 fn as_vec_mut(&mut self) -> &mut Vec<u8> {
14902 self.prev.as_mut().unwrap().as_vec_mut()
14903 }
14904 fn as_vec(&self) -> &Vec<u8> {
14905 self.prev.as_ref().unwrap().as_vec()
14906 }
14907}
14908impl<Prev: Pusher> PushDlDpipeEntryMatchValues<Prev> {
14909 pub fn new(prev: Prev) -> Self {
14910 Self {
14911 prev: Some(prev),
14912 header_offset: None,
14913 }
14914 }
14915 pub fn end_nested(mut self) -> Prev {
14916 let mut prev = self.prev.take().unwrap();
14917 if let Some(header_offset) = &self.header_offset {
14918 finalize_nested_header(prev.as_vec_mut(), *header_offset);
14919 }
14920 prev
14921 }
14922 #[doc = "Attribute may repeat multiple times (treat it as array)"]
14923 pub fn nested_dpipe_match_value(mut self) -> PushDlDpipeMatchValue<Self> {
14924 let header_offset = push_nested_header(self.as_vec_mut(), 41u16);
14925 PushDlDpipeMatchValue {
14926 prev: Some(self),
14927 header_offset: Some(header_offset),
14928 }
14929 }
14930}
14931impl<Prev: Pusher> Drop for PushDlDpipeEntryMatchValues<Prev> {
14932 fn drop(&mut self) {
14933 if let Some(prev) = &mut self.prev {
14934 if let Some(header_offset) = &self.header_offset {
14935 finalize_nested_header(prev.as_vec_mut(), *header_offset);
14936 }
14937 }
14938 }
14939}
14940pub struct PushDlDpipeEntryActionValues<Prev: Pusher> {
14941 pub(crate) prev: Option<Prev>,
14942 pub(crate) header_offset: Option<usize>,
14943}
14944impl<Prev: Pusher> Pusher for PushDlDpipeEntryActionValues<Prev> {
14945 fn as_vec_mut(&mut self) -> &mut Vec<u8> {
14946 self.prev.as_mut().unwrap().as_vec_mut()
14947 }
14948 fn as_vec(&self) -> &Vec<u8> {
14949 self.prev.as_ref().unwrap().as_vec()
14950 }
14951}
14952impl<Prev: Pusher> PushDlDpipeEntryActionValues<Prev> {
14953 pub fn new(prev: Prev) -> Self {
14954 Self {
14955 prev: Some(prev),
14956 header_offset: None,
14957 }
14958 }
14959 pub fn end_nested(mut self) -> Prev {
14960 let mut prev = self.prev.take().unwrap();
14961 if let Some(header_offset) = &self.header_offset {
14962 finalize_nested_header(prev.as_vec_mut(), *header_offset);
14963 }
14964 prev
14965 }
14966 #[doc = "Attribute may repeat multiple times (treat it as array)"]
14967 pub fn nested_dpipe_action_value(mut self) -> PushDlDpipeActionValue<Self> {
14968 let header_offset = push_nested_header(self.as_vec_mut(), 44u16);
14969 PushDlDpipeActionValue {
14970 prev: Some(self),
14971 header_offset: Some(header_offset),
14972 }
14973 }
14974}
14975impl<Prev: Pusher> Drop for PushDlDpipeEntryActionValues<Prev> {
14976 fn drop(&mut self) {
14977 if let Some(prev) = &mut self.prev {
14978 if let Some(header_offset) = &self.header_offset {
14979 finalize_nested_header(prev.as_vec_mut(), *header_offset);
14980 }
14981 }
14982 }
14983}
14984pub struct PushDlDpipeMatch<Prev: Pusher> {
14985 pub(crate) prev: Option<Prev>,
14986 pub(crate) header_offset: Option<usize>,
14987}
14988impl<Prev: Pusher> Pusher for PushDlDpipeMatch<Prev> {
14989 fn as_vec_mut(&mut self) -> &mut Vec<u8> {
14990 self.prev.as_mut().unwrap().as_vec_mut()
14991 }
14992 fn as_vec(&self) -> &Vec<u8> {
14993 self.prev.as_ref().unwrap().as_vec()
14994 }
14995}
14996impl<Prev: Pusher> PushDlDpipeMatch<Prev> {
14997 pub fn new(prev: Prev) -> Self {
14998 Self {
14999 prev: Some(prev),
15000 header_offset: None,
15001 }
15002 }
15003 pub fn end_nested(mut self) -> Prev {
15004 let mut prev = self.prev.take().unwrap();
15005 if let Some(header_offset) = &self.header_offset {
15006 finalize_nested_header(prev.as_vec_mut(), *header_offset);
15007 }
15008 prev
15009 }
15010 #[doc = "Associated type: [`DpipeMatchType`] (enum)"]
15011 pub fn push_dpipe_match_type(mut self, value: u32) -> Self {
15012 push_header(self.as_vec_mut(), 42u16, 4 as u16);
15013 self.as_vec_mut().extend(value.to_ne_bytes());
15014 self
15015 }
15016 #[doc = "Associated type: [`DpipeHeaderId`] (enum)"]
15017 pub fn push_dpipe_header_id(mut self, value: u32) -> Self {
15018 push_header(self.as_vec_mut(), 52u16, 4 as u16);
15019 self.as_vec_mut().extend(value.to_ne_bytes());
15020 self
15021 }
15022 pub fn push_dpipe_header_global(mut self, value: u8) -> Self {
15023 push_header(self.as_vec_mut(), 54u16, 1 as u16);
15024 self.as_vec_mut().extend(value.to_ne_bytes());
15025 self
15026 }
15027 pub fn push_dpipe_header_index(mut self, value: u32) -> Self {
15028 push_header(self.as_vec_mut(), 55u16, 4 as u16);
15029 self.as_vec_mut().extend(value.to_ne_bytes());
15030 self
15031 }
15032 pub fn push_dpipe_field_id(mut self, value: u32) -> Self {
15033 push_header(self.as_vec_mut(), 58u16, 4 as u16);
15034 self.as_vec_mut().extend(value.to_ne_bytes());
15035 self
15036 }
15037}
15038impl<Prev: Pusher> Drop for PushDlDpipeMatch<Prev> {
15039 fn drop(&mut self) {
15040 if let Some(prev) = &mut self.prev {
15041 if let Some(header_offset) = &self.header_offset {
15042 finalize_nested_header(prev.as_vec_mut(), *header_offset);
15043 }
15044 }
15045 }
15046}
15047pub struct PushDlDpipeMatchValue<Prev: Pusher> {
15048 pub(crate) prev: Option<Prev>,
15049 pub(crate) header_offset: Option<usize>,
15050}
15051impl<Prev: Pusher> Pusher for PushDlDpipeMatchValue<Prev> {
15052 fn as_vec_mut(&mut self) -> &mut Vec<u8> {
15053 self.prev.as_mut().unwrap().as_vec_mut()
15054 }
15055 fn as_vec(&self) -> &Vec<u8> {
15056 self.prev.as_ref().unwrap().as_vec()
15057 }
15058}
15059impl<Prev: Pusher> PushDlDpipeMatchValue<Prev> {
15060 pub fn new(prev: Prev) -> Self {
15061 Self {
15062 prev: Some(prev),
15063 header_offset: None,
15064 }
15065 }
15066 pub fn end_nested(mut self) -> Prev {
15067 let mut prev = self.prev.take().unwrap();
15068 if let Some(header_offset) = &self.header_offset {
15069 finalize_nested_header(prev.as_vec_mut(), *header_offset);
15070 }
15071 prev
15072 }
15073 #[doc = "Attribute may repeat multiple times (treat it as array)"]
15074 pub fn nested_dpipe_match(mut self) -> PushDlDpipeMatch<Self> {
15075 let header_offset = push_nested_header(self.as_vec_mut(), 40u16);
15076 PushDlDpipeMatch {
15077 prev: Some(self),
15078 header_offset: Some(header_offset),
15079 }
15080 }
15081 pub fn push_dpipe_value(mut self, value: &[u8]) -> Self {
15082 push_header(self.as_vec_mut(), 46u16, value.len() as u16);
15083 self.as_vec_mut().extend(value);
15084 self
15085 }
15086 pub fn push_dpipe_value_mask(mut self, value: &[u8]) -> Self {
15087 push_header(self.as_vec_mut(), 47u16, value.len() as u16);
15088 self.as_vec_mut().extend(value);
15089 self
15090 }
15091 pub fn push_dpipe_value_mapping(mut self, value: u32) -> Self {
15092 push_header(self.as_vec_mut(), 48u16, 4 as u16);
15093 self.as_vec_mut().extend(value.to_ne_bytes());
15094 self
15095 }
15096}
15097impl<Prev: Pusher> Drop for PushDlDpipeMatchValue<Prev> {
15098 fn drop(&mut self) {
15099 if let Some(prev) = &mut self.prev {
15100 if let Some(header_offset) = &self.header_offset {
15101 finalize_nested_header(prev.as_vec_mut(), *header_offset);
15102 }
15103 }
15104 }
15105}
15106pub struct PushDlDpipeAction<Prev: Pusher> {
15107 pub(crate) prev: Option<Prev>,
15108 pub(crate) header_offset: Option<usize>,
15109}
15110impl<Prev: Pusher> Pusher for PushDlDpipeAction<Prev> {
15111 fn as_vec_mut(&mut self) -> &mut Vec<u8> {
15112 self.prev.as_mut().unwrap().as_vec_mut()
15113 }
15114 fn as_vec(&self) -> &Vec<u8> {
15115 self.prev.as_ref().unwrap().as_vec()
15116 }
15117}
15118impl<Prev: Pusher> PushDlDpipeAction<Prev> {
15119 pub fn new(prev: Prev) -> Self {
15120 Self {
15121 prev: Some(prev),
15122 header_offset: None,
15123 }
15124 }
15125 pub fn end_nested(mut self) -> Prev {
15126 let mut prev = self.prev.take().unwrap();
15127 if let Some(header_offset) = &self.header_offset {
15128 finalize_nested_header(prev.as_vec_mut(), *header_offset);
15129 }
15130 prev
15131 }
15132 #[doc = "Associated type: [`DpipeActionType`] (enum)"]
15133 pub fn push_dpipe_action_type(mut self, value: u32) -> Self {
15134 push_header(self.as_vec_mut(), 45u16, 4 as u16);
15135 self.as_vec_mut().extend(value.to_ne_bytes());
15136 self
15137 }
15138 #[doc = "Associated type: [`DpipeHeaderId`] (enum)"]
15139 pub fn push_dpipe_header_id(mut self, value: u32) -> Self {
15140 push_header(self.as_vec_mut(), 52u16, 4 as u16);
15141 self.as_vec_mut().extend(value.to_ne_bytes());
15142 self
15143 }
15144 pub fn push_dpipe_header_global(mut self, value: u8) -> Self {
15145 push_header(self.as_vec_mut(), 54u16, 1 as u16);
15146 self.as_vec_mut().extend(value.to_ne_bytes());
15147 self
15148 }
15149 pub fn push_dpipe_header_index(mut self, value: u32) -> Self {
15150 push_header(self.as_vec_mut(), 55u16, 4 as u16);
15151 self.as_vec_mut().extend(value.to_ne_bytes());
15152 self
15153 }
15154 pub fn push_dpipe_field_id(mut self, value: u32) -> Self {
15155 push_header(self.as_vec_mut(), 58u16, 4 as u16);
15156 self.as_vec_mut().extend(value.to_ne_bytes());
15157 self
15158 }
15159}
15160impl<Prev: Pusher> Drop for PushDlDpipeAction<Prev> {
15161 fn drop(&mut self) {
15162 if let Some(prev) = &mut self.prev {
15163 if let Some(header_offset) = &self.header_offset {
15164 finalize_nested_header(prev.as_vec_mut(), *header_offset);
15165 }
15166 }
15167 }
15168}
15169pub struct PushDlDpipeActionValue<Prev: Pusher> {
15170 pub(crate) prev: Option<Prev>,
15171 pub(crate) header_offset: Option<usize>,
15172}
15173impl<Prev: Pusher> Pusher for PushDlDpipeActionValue<Prev> {
15174 fn as_vec_mut(&mut self) -> &mut Vec<u8> {
15175 self.prev.as_mut().unwrap().as_vec_mut()
15176 }
15177 fn as_vec(&self) -> &Vec<u8> {
15178 self.prev.as_ref().unwrap().as_vec()
15179 }
15180}
15181impl<Prev: Pusher> PushDlDpipeActionValue<Prev> {
15182 pub fn new(prev: Prev) -> Self {
15183 Self {
15184 prev: Some(prev),
15185 header_offset: None,
15186 }
15187 }
15188 pub fn end_nested(mut self) -> Prev {
15189 let mut prev = self.prev.take().unwrap();
15190 if let Some(header_offset) = &self.header_offset {
15191 finalize_nested_header(prev.as_vec_mut(), *header_offset);
15192 }
15193 prev
15194 }
15195 #[doc = "Attribute may repeat multiple times (treat it as array)"]
15196 pub fn nested_dpipe_action(mut self) -> PushDlDpipeAction<Self> {
15197 let header_offset = push_nested_header(self.as_vec_mut(), 43u16);
15198 PushDlDpipeAction {
15199 prev: Some(self),
15200 header_offset: Some(header_offset),
15201 }
15202 }
15203 pub fn push_dpipe_value(mut self, value: &[u8]) -> Self {
15204 push_header(self.as_vec_mut(), 46u16, value.len() as u16);
15205 self.as_vec_mut().extend(value);
15206 self
15207 }
15208 pub fn push_dpipe_value_mask(mut self, value: &[u8]) -> Self {
15209 push_header(self.as_vec_mut(), 47u16, value.len() as u16);
15210 self.as_vec_mut().extend(value);
15211 self
15212 }
15213 pub fn push_dpipe_value_mapping(mut self, value: u32) -> Self {
15214 push_header(self.as_vec_mut(), 48u16, 4 as u16);
15215 self.as_vec_mut().extend(value.to_ne_bytes());
15216 self
15217 }
15218}
15219impl<Prev: Pusher> Drop for PushDlDpipeActionValue<Prev> {
15220 fn drop(&mut self) {
15221 if let Some(prev) = &mut self.prev {
15222 if let Some(header_offset) = &self.header_offset {
15223 finalize_nested_header(prev.as_vec_mut(), *header_offset);
15224 }
15225 }
15226 }
15227}
15228pub struct PushDlDpipeHeaders<Prev: Pusher> {
15229 pub(crate) prev: Option<Prev>,
15230 pub(crate) header_offset: Option<usize>,
15231}
15232impl<Prev: Pusher> Pusher for PushDlDpipeHeaders<Prev> {
15233 fn as_vec_mut(&mut self) -> &mut Vec<u8> {
15234 self.prev.as_mut().unwrap().as_vec_mut()
15235 }
15236 fn as_vec(&self) -> &Vec<u8> {
15237 self.prev.as_ref().unwrap().as_vec()
15238 }
15239}
15240impl<Prev: Pusher> PushDlDpipeHeaders<Prev> {
15241 pub fn new(prev: Prev) -> Self {
15242 Self {
15243 prev: Some(prev),
15244 header_offset: None,
15245 }
15246 }
15247 pub fn end_nested(mut self) -> Prev {
15248 let mut prev = self.prev.take().unwrap();
15249 if let Some(header_offset) = &self.header_offset {
15250 finalize_nested_header(prev.as_vec_mut(), *header_offset);
15251 }
15252 prev
15253 }
15254 #[doc = "Attribute may repeat multiple times (treat it as array)"]
15255 pub fn nested_dpipe_header(mut self) -> PushDlDpipeHeader<Self> {
15256 let header_offset = push_nested_header(self.as_vec_mut(), 50u16);
15257 PushDlDpipeHeader {
15258 prev: Some(self),
15259 header_offset: Some(header_offset),
15260 }
15261 }
15262}
15263impl<Prev: Pusher> Drop for PushDlDpipeHeaders<Prev> {
15264 fn drop(&mut self) {
15265 if let Some(prev) = &mut self.prev {
15266 if let Some(header_offset) = &self.header_offset {
15267 finalize_nested_header(prev.as_vec_mut(), *header_offset);
15268 }
15269 }
15270 }
15271}
15272pub struct PushDlDpipeHeader<Prev: Pusher> {
15273 pub(crate) prev: Option<Prev>,
15274 pub(crate) header_offset: Option<usize>,
15275}
15276impl<Prev: Pusher> Pusher for PushDlDpipeHeader<Prev> {
15277 fn as_vec_mut(&mut self) -> &mut Vec<u8> {
15278 self.prev.as_mut().unwrap().as_vec_mut()
15279 }
15280 fn as_vec(&self) -> &Vec<u8> {
15281 self.prev.as_ref().unwrap().as_vec()
15282 }
15283}
15284impl<Prev: Pusher> PushDlDpipeHeader<Prev> {
15285 pub fn new(prev: Prev) -> Self {
15286 Self {
15287 prev: Some(prev),
15288 header_offset: None,
15289 }
15290 }
15291 pub fn end_nested(mut self) -> Prev {
15292 let mut prev = self.prev.take().unwrap();
15293 if let Some(header_offset) = &self.header_offset {
15294 finalize_nested_header(prev.as_vec_mut(), *header_offset);
15295 }
15296 prev
15297 }
15298 pub fn push_dpipe_header_name(mut self, value: &CStr) -> Self {
15299 push_header(
15300 self.as_vec_mut(),
15301 51u16,
15302 value.to_bytes_with_nul().len() as u16,
15303 );
15304 self.as_vec_mut().extend(value.to_bytes_with_nul());
15305 self
15306 }
15307 pub fn push_dpipe_header_name_bytes(mut self, value: &[u8]) -> Self {
15308 push_header(self.as_vec_mut(), 51u16, (value.len() + 1) as u16);
15309 self.as_vec_mut().extend(value);
15310 self.as_vec_mut().push(0);
15311 self
15312 }
15313 #[doc = "Associated type: [`DpipeHeaderId`] (enum)"]
15314 pub fn push_dpipe_header_id(mut self, value: u32) -> Self {
15315 push_header(self.as_vec_mut(), 52u16, 4 as u16);
15316 self.as_vec_mut().extend(value.to_ne_bytes());
15317 self
15318 }
15319 pub fn nested_dpipe_header_fields(mut self) -> PushDlDpipeHeaderFields<Self> {
15320 let header_offset = push_nested_header(self.as_vec_mut(), 53u16);
15321 PushDlDpipeHeaderFields {
15322 prev: Some(self),
15323 header_offset: Some(header_offset),
15324 }
15325 }
15326 pub fn push_dpipe_header_global(mut self, value: u8) -> Self {
15327 push_header(self.as_vec_mut(), 54u16, 1 as u16);
15328 self.as_vec_mut().extend(value.to_ne_bytes());
15329 self
15330 }
15331}
15332impl<Prev: Pusher> Drop for PushDlDpipeHeader<Prev> {
15333 fn drop(&mut self) {
15334 if let Some(prev) = &mut self.prev {
15335 if let Some(header_offset) = &self.header_offset {
15336 finalize_nested_header(prev.as_vec_mut(), *header_offset);
15337 }
15338 }
15339 }
15340}
15341pub struct PushDlDpipeHeaderFields<Prev: Pusher> {
15342 pub(crate) prev: Option<Prev>,
15343 pub(crate) header_offset: Option<usize>,
15344}
15345impl<Prev: Pusher> Pusher for PushDlDpipeHeaderFields<Prev> {
15346 fn as_vec_mut(&mut self) -> &mut Vec<u8> {
15347 self.prev.as_mut().unwrap().as_vec_mut()
15348 }
15349 fn as_vec(&self) -> &Vec<u8> {
15350 self.prev.as_ref().unwrap().as_vec()
15351 }
15352}
15353impl<Prev: Pusher> PushDlDpipeHeaderFields<Prev> {
15354 pub fn new(prev: Prev) -> Self {
15355 Self {
15356 prev: Some(prev),
15357 header_offset: None,
15358 }
15359 }
15360 pub fn end_nested(mut self) -> Prev {
15361 let mut prev = self.prev.take().unwrap();
15362 if let Some(header_offset) = &self.header_offset {
15363 finalize_nested_header(prev.as_vec_mut(), *header_offset);
15364 }
15365 prev
15366 }
15367 #[doc = "Attribute may repeat multiple times (treat it as array)"]
15368 pub fn nested_dpipe_field(mut self) -> PushDlDpipeField<Self> {
15369 let header_offset = push_nested_header(self.as_vec_mut(), 56u16);
15370 PushDlDpipeField {
15371 prev: Some(self),
15372 header_offset: Some(header_offset),
15373 }
15374 }
15375}
15376impl<Prev: Pusher> Drop for PushDlDpipeHeaderFields<Prev> {
15377 fn drop(&mut self) {
15378 if let Some(prev) = &mut self.prev {
15379 if let Some(header_offset) = &self.header_offset {
15380 finalize_nested_header(prev.as_vec_mut(), *header_offset);
15381 }
15382 }
15383 }
15384}
15385pub struct PushDlDpipeField<Prev: Pusher> {
15386 pub(crate) prev: Option<Prev>,
15387 pub(crate) header_offset: Option<usize>,
15388}
15389impl<Prev: Pusher> Pusher for PushDlDpipeField<Prev> {
15390 fn as_vec_mut(&mut self) -> &mut Vec<u8> {
15391 self.prev.as_mut().unwrap().as_vec_mut()
15392 }
15393 fn as_vec(&self) -> &Vec<u8> {
15394 self.prev.as_ref().unwrap().as_vec()
15395 }
15396}
15397impl<Prev: Pusher> PushDlDpipeField<Prev> {
15398 pub fn new(prev: Prev) -> Self {
15399 Self {
15400 prev: Some(prev),
15401 header_offset: None,
15402 }
15403 }
15404 pub fn end_nested(mut self) -> Prev {
15405 let mut prev = self.prev.take().unwrap();
15406 if let Some(header_offset) = &self.header_offset {
15407 finalize_nested_header(prev.as_vec_mut(), *header_offset);
15408 }
15409 prev
15410 }
15411 pub fn push_dpipe_field_name(mut self, value: &CStr) -> Self {
15412 push_header(
15413 self.as_vec_mut(),
15414 57u16,
15415 value.to_bytes_with_nul().len() as u16,
15416 );
15417 self.as_vec_mut().extend(value.to_bytes_with_nul());
15418 self
15419 }
15420 pub fn push_dpipe_field_name_bytes(mut self, value: &[u8]) -> Self {
15421 push_header(self.as_vec_mut(), 57u16, (value.len() + 1) as u16);
15422 self.as_vec_mut().extend(value);
15423 self.as_vec_mut().push(0);
15424 self
15425 }
15426 pub fn push_dpipe_field_id(mut self, value: u32) -> Self {
15427 push_header(self.as_vec_mut(), 58u16, 4 as u16);
15428 self.as_vec_mut().extend(value.to_ne_bytes());
15429 self
15430 }
15431 pub fn push_dpipe_field_bitwidth(mut self, value: u32) -> Self {
15432 push_header(self.as_vec_mut(), 59u16, 4 as u16);
15433 self.as_vec_mut().extend(value.to_ne_bytes());
15434 self
15435 }
15436 #[doc = "Associated type: [`DpipeFieldMappingType`] (enum)"]
15437 pub fn push_dpipe_field_mapping_type(mut self, value: u32) -> Self {
15438 push_header(self.as_vec_mut(), 60u16, 4 as u16);
15439 self.as_vec_mut().extend(value.to_ne_bytes());
15440 self
15441 }
15442}
15443impl<Prev: Pusher> Drop for PushDlDpipeField<Prev> {
15444 fn drop(&mut self) {
15445 if let Some(prev) = &mut self.prev {
15446 if let Some(header_offset) = &self.header_offset {
15447 finalize_nested_header(prev.as_vec_mut(), *header_offset);
15448 }
15449 }
15450 }
15451}
15452pub struct PushDlResource<Prev: Pusher> {
15453 pub(crate) prev: Option<Prev>,
15454 pub(crate) header_offset: Option<usize>,
15455}
15456impl<Prev: Pusher> Pusher for PushDlResource<Prev> {
15457 fn as_vec_mut(&mut self) -> &mut Vec<u8> {
15458 self.prev.as_mut().unwrap().as_vec_mut()
15459 }
15460 fn as_vec(&self) -> &Vec<u8> {
15461 self.prev.as_ref().unwrap().as_vec()
15462 }
15463}
15464impl<Prev: Pusher> PushDlResource<Prev> {
15465 pub fn new(prev: Prev) -> Self {
15466 Self {
15467 prev: Some(prev),
15468 header_offset: None,
15469 }
15470 }
15471 pub fn end_nested(mut self) -> Prev {
15472 let mut prev = self.prev.take().unwrap();
15473 if let Some(header_offset) = &self.header_offset {
15474 finalize_nested_header(prev.as_vec_mut(), *header_offset);
15475 }
15476 prev
15477 }
15478 pub fn push_resource_name(mut self, value: &CStr) -> Self {
15479 push_header(
15480 self.as_vec_mut(),
15481 65u16,
15482 value.to_bytes_with_nul().len() as u16,
15483 );
15484 self.as_vec_mut().extend(value.to_bytes_with_nul());
15485 self
15486 }
15487 pub fn push_resource_name_bytes(mut self, value: &[u8]) -> Self {
15488 push_header(self.as_vec_mut(), 65u16, (value.len() + 1) as u16);
15489 self.as_vec_mut().extend(value);
15490 self.as_vec_mut().push(0);
15491 self
15492 }
15493 pub fn push_resource_id(mut self, value: u64) -> Self {
15494 push_header(self.as_vec_mut(), 66u16, 8 as u16);
15495 self.as_vec_mut().extend(value.to_ne_bytes());
15496 self
15497 }
15498 pub fn push_resource_size(mut self, value: u64) -> Self {
15499 push_header(self.as_vec_mut(), 67u16, 8 as u16);
15500 self.as_vec_mut().extend(value.to_ne_bytes());
15501 self
15502 }
15503 pub fn push_resource_size_new(mut self, value: u64) -> Self {
15504 push_header(self.as_vec_mut(), 68u16, 8 as u16);
15505 self.as_vec_mut().extend(value.to_ne_bytes());
15506 self
15507 }
15508 pub fn push_resource_size_valid(mut self, value: u8) -> Self {
15509 push_header(self.as_vec_mut(), 69u16, 1 as u16);
15510 self.as_vec_mut().extend(value.to_ne_bytes());
15511 self
15512 }
15513 pub fn push_resource_size_min(mut self, value: u64) -> Self {
15514 push_header(self.as_vec_mut(), 70u16, 8 as u16);
15515 self.as_vec_mut().extend(value.to_ne_bytes());
15516 self
15517 }
15518 pub fn push_resource_size_max(mut self, value: u64) -> Self {
15519 push_header(self.as_vec_mut(), 71u16, 8 as u16);
15520 self.as_vec_mut().extend(value.to_ne_bytes());
15521 self
15522 }
15523 pub fn push_resource_size_gran(mut self, value: u64) -> Self {
15524 push_header(self.as_vec_mut(), 72u16, 8 as u16);
15525 self.as_vec_mut().extend(value.to_ne_bytes());
15526 self
15527 }
15528 #[doc = "Associated type: [`ResourceUnit`] (enum)"]
15529 pub fn push_resource_unit(mut self, value: u8) -> Self {
15530 push_header(self.as_vec_mut(), 73u16, 1 as u16);
15531 self.as_vec_mut().extend(value.to_ne_bytes());
15532 self
15533 }
15534 pub fn push_resource_occ(mut self, value: u64) -> Self {
15535 push_header(self.as_vec_mut(), 74u16, 8 as u16);
15536 self.as_vec_mut().extend(value.to_ne_bytes());
15537 self
15538 }
15539}
15540impl<Prev: Pusher> Drop for PushDlResource<Prev> {
15541 fn drop(&mut self) {
15542 if let Some(prev) = &mut self.prev {
15543 if let Some(header_offset) = &self.header_offset {
15544 finalize_nested_header(prev.as_vec_mut(), *header_offset);
15545 }
15546 }
15547 }
15548}
15549pub struct PushDlResourceList<Prev: Pusher> {
15550 pub(crate) prev: Option<Prev>,
15551 pub(crate) header_offset: Option<usize>,
15552}
15553impl<Prev: Pusher> Pusher for PushDlResourceList<Prev> {
15554 fn as_vec_mut(&mut self) -> &mut Vec<u8> {
15555 self.prev.as_mut().unwrap().as_vec_mut()
15556 }
15557 fn as_vec(&self) -> &Vec<u8> {
15558 self.prev.as_ref().unwrap().as_vec()
15559 }
15560}
15561impl<Prev: Pusher> PushDlResourceList<Prev> {
15562 pub fn new(prev: Prev) -> Self {
15563 Self {
15564 prev: Some(prev),
15565 header_offset: None,
15566 }
15567 }
15568 pub fn end_nested(mut self) -> Prev {
15569 let mut prev = self.prev.take().unwrap();
15570 if let Some(header_offset) = &self.header_offset {
15571 finalize_nested_header(prev.as_vec_mut(), *header_offset);
15572 }
15573 prev
15574 }
15575 #[doc = "Attribute may repeat multiple times (treat it as array)"]
15576 pub fn nested_resource(mut self) -> PushDlResource<Self> {
15577 let header_offset = push_nested_header(self.as_vec_mut(), 64u16);
15578 PushDlResource {
15579 prev: Some(self),
15580 header_offset: Some(header_offset),
15581 }
15582 }
15583}
15584impl<Prev: Pusher> Drop for PushDlResourceList<Prev> {
15585 fn drop(&mut self) {
15586 if let Some(prev) = &mut self.prev {
15587 if let Some(header_offset) = &self.header_offset {
15588 finalize_nested_header(prev.as_vec_mut(), *header_offset);
15589 }
15590 }
15591 }
15592}
15593pub struct PushDlParam<Prev: Pusher> {
15594 pub(crate) prev: Option<Prev>,
15595 pub(crate) header_offset: Option<usize>,
15596}
15597impl<Prev: Pusher> Pusher for PushDlParam<Prev> {
15598 fn as_vec_mut(&mut self) -> &mut Vec<u8> {
15599 self.prev.as_mut().unwrap().as_vec_mut()
15600 }
15601 fn as_vec(&self) -> &Vec<u8> {
15602 self.prev.as_ref().unwrap().as_vec()
15603 }
15604}
15605impl<Prev: Pusher> PushDlParam<Prev> {
15606 pub fn new(prev: Prev) -> Self {
15607 Self {
15608 prev: Some(prev),
15609 header_offset: None,
15610 }
15611 }
15612 pub fn end_nested(mut self) -> Prev {
15613 let mut prev = self.prev.take().unwrap();
15614 if let Some(header_offset) = &self.header_offset {
15615 finalize_nested_header(prev.as_vec_mut(), *header_offset);
15616 }
15617 prev
15618 }
15619 pub fn push_param_name(mut self, value: &CStr) -> Self {
15620 push_header(
15621 self.as_vec_mut(),
15622 81u16,
15623 value.to_bytes_with_nul().len() as u16,
15624 );
15625 self.as_vec_mut().extend(value.to_bytes_with_nul());
15626 self
15627 }
15628 pub fn push_param_name_bytes(mut self, value: &[u8]) -> Self {
15629 push_header(self.as_vec_mut(), 81u16, (value.len() + 1) as u16);
15630 self.as_vec_mut().extend(value);
15631 self.as_vec_mut().push(0);
15632 self
15633 }
15634 pub fn push_param_generic(mut self, value: ()) -> Self {
15635 push_header(self.as_vec_mut(), 82u16, 0 as u16);
15636 self
15637 }
15638 #[doc = "Associated type: [`VarAttrType`] (enum)"]
15639 pub fn push_param_type(mut self, value: u8) -> Self {
15640 push_header(self.as_vec_mut(), 83u16, 1 as u16);
15641 self.as_vec_mut().extend(value.to_ne_bytes());
15642 self
15643 }
15644}
15645impl<Prev: Pusher> Drop for PushDlParam<Prev> {
15646 fn drop(&mut self) {
15647 if let Some(prev) = &mut self.prev {
15648 if let Some(header_offset) = &self.header_offset {
15649 finalize_nested_header(prev.as_vec_mut(), *header_offset);
15650 }
15651 }
15652 }
15653}
15654pub struct PushDlRegionSnapshots<Prev: Pusher> {
15655 pub(crate) prev: Option<Prev>,
15656 pub(crate) header_offset: Option<usize>,
15657}
15658impl<Prev: Pusher> Pusher for PushDlRegionSnapshots<Prev> {
15659 fn as_vec_mut(&mut self) -> &mut Vec<u8> {
15660 self.prev.as_mut().unwrap().as_vec_mut()
15661 }
15662 fn as_vec(&self) -> &Vec<u8> {
15663 self.prev.as_ref().unwrap().as_vec()
15664 }
15665}
15666impl<Prev: Pusher> PushDlRegionSnapshots<Prev> {
15667 pub fn new(prev: Prev) -> Self {
15668 Self {
15669 prev: Some(prev),
15670 header_offset: None,
15671 }
15672 }
15673 pub fn end_nested(mut self) -> Prev {
15674 let mut prev = self.prev.take().unwrap();
15675 if let Some(header_offset) = &self.header_offset {
15676 finalize_nested_header(prev.as_vec_mut(), *header_offset);
15677 }
15678 prev
15679 }
15680 pub fn nested_region_snapshot(mut self) -> PushDlRegionSnapshot<Self> {
15681 let header_offset = push_nested_header(self.as_vec_mut(), 91u16);
15682 PushDlRegionSnapshot {
15683 prev: Some(self),
15684 header_offset: Some(header_offset),
15685 }
15686 }
15687}
15688impl<Prev: Pusher> Drop for PushDlRegionSnapshots<Prev> {
15689 fn drop(&mut self) {
15690 if let Some(prev) = &mut self.prev {
15691 if let Some(header_offset) = &self.header_offset {
15692 finalize_nested_header(prev.as_vec_mut(), *header_offset);
15693 }
15694 }
15695 }
15696}
15697pub struct PushDlRegionSnapshot<Prev: Pusher> {
15698 pub(crate) prev: Option<Prev>,
15699 pub(crate) header_offset: Option<usize>,
15700}
15701impl<Prev: Pusher> Pusher for PushDlRegionSnapshot<Prev> {
15702 fn as_vec_mut(&mut self) -> &mut Vec<u8> {
15703 self.prev.as_mut().unwrap().as_vec_mut()
15704 }
15705 fn as_vec(&self) -> &Vec<u8> {
15706 self.prev.as_ref().unwrap().as_vec()
15707 }
15708}
15709impl<Prev: Pusher> PushDlRegionSnapshot<Prev> {
15710 pub fn new(prev: Prev) -> Self {
15711 Self {
15712 prev: Some(prev),
15713 header_offset: None,
15714 }
15715 }
15716 pub fn end_nested(mut self) -> Prev {
15717 let mut prev = self.prev.take().unwrap();
15718 if let Some(header_offset) = &self.header_offset {
15719 finalize_nested_header(prev.as_vec_mut(), *header_offset);
15720 }
15721 prev
15722 }
15723 pub fn push_region_snapshot_id(mut self, value: u32) -> Self {
15724 push_header(self.as_vec_mut(), 92u16, 4 as u16);
15725 self.as_vec_mut().extend(value.to_ne_bytes());
15726 self
15727 }
15728}
15729impl<Prev: Pusher> Drop for PushDlRegionSnapshot<Prev> {
15730 fn drop(&mut self) {
15731 if let Some(prev) = &mut self.prev {
15732 if let Some(header_offset) = &self.header_offset {
15733 finalize_nested_header(prev.as_vec_mut(), *header_offset);
15734 }
15735 }
15736 }
15737}
15738pub struct PushDlRegionChunks<Prev: Pusher> {
15739 pub(crate) prev: Option<Prev>,
15740 pub(crate) header_offset: Option<usize>,
15741}
15742impl<Prev: Pusher> Pusher for PushDlRegionChunks<Prev> {
15743 fn as_vec_mut(&mut self) -> &mut Vec<u8> {
15744 self.prev.as_mut().unwrap().as_vec_mut()
15745 }
15746 fn as_vec(&self) -> &Vec<u8> {
15747 self.prev.as_ref().unwrap().as_vec()
15748 }
15749}
15750impl<Prev: Pusher> PushDlRegionChunks<Prev> {
15751 pub fn new(prev: Prev) -> Self {
15752 Self {
15753 prev: Some(prev),
15754 header_offset: None,
15755 }
15756 }
15757 pub fn end_nested(mut self) -> Prev {
15758 let mut prev = self.prev.take().unwrap();
15759 if let Some(header_offset) = &self.header_offset {
15760 finalize_nested_header(prev.as_vec_mut(), *header_offset);
15761 }
15762 prev
15763 }
15764 pub fn nested_region_chunk(mut self) -> PushDlRegionChunk<Self> {
15765 let header_offset = push_nested_header(self.as_vec_mut(), 94u16);
15766 PushDlRegionChunk {
15767 prev: Some(self),
15768 header_offset: Some(header_offset),
15769 }
15770 }
15771}
15772impl<Prev: Pusher> Drop for PushDlRegionChunks<Prev> {
15773 fn drop(&mut self) {
15774 if let Some(prev) = &mut self.prev {
15775 if let Some(header_offset) = &self.header_offset {
15776 finalize_nested_header(prev.as_vec_mut(), *header_offset);
15777 }
15778 }
15779 }
15780}
15781pub struct PushDlRegionChunk<Prev: Pusher> {
15782 pub(crate) prev: Option<Prev>,
15783 pub(crate) header_offset: Option<usize>,
15784}
15785impl<Prev: Pusher> Pusher for PushDlRegionChunk<Prev> {
15786 fn as_vec_mut(&mut self) -> &mut Vec<u8> {
15787 self.prev.as_mut().unwrap().as_vec_mut()
15788 }
15789 fn as_vec(&self) -> &Vec<u8> {
15790 self.prev.as_ref().unwrap().as_vec()
15791 }
15792}
15793impl<Prev: Pusher> PushDlRegionChunk<Prev> {
15794 pub fn new(prev: Prev) -> Self {
15795 Self {
15796 prev: Some(prev),
15797 header_offset: None,
15798 }
15799 }
15800 pub fn end_nested(mut self) -> Prev {
15801 let mut prev = self.prev.take().unwrap();
15802 if let Some(header_offset) = &self.header_offset {
15803 finalize_nested_header(prev.as_vec_mut(), *header_offset);
15804 }
15805 prev
15806 }
15807 pub fn push_region_chunk_data(mut self, value: &[u8]) -> Self {
15808 push_header(self.as_vec_mut(), 95u16, value.len() as u16);
15809 self.as_vec_mut().extend(value);
15810 self
15811 }
15812 pub fn push_region_chunk_addr(mut self, value: u64) -> Self {
15813 push_header(self.as_vec_mut(), 96u16, 8 as u16);
15814 self.as_vec_mut().extend(value.to_ne_bytes());
15815 self
15816 }
15817}
15818impl<Prev: Pusher> Drop for PushDlRegionChunk<Prev> {
15819 fn drop(&mut self) {
15820 if let Some(prev) = &mut self.prev {
15821 if let Some(header_offset) = &self.header_offset {
15822 finalize_nested_header(prev.as_vec_mut(), *header_offset);
15823 }
15824 }
15825 }
15826}
15827pub struct PushDlFmsg<Prev: Pusher> {
15828 pub(crate) prev: Option<Prev>,
15829 pub(crate) header_offset: Option<usize>,
15830}
15831impl<Prev: Pusher> Pusher for PushDlFmsg<Prev> {
15832 fn as_vec_mut(&mut self) -> &mut Vec<u8> {
15833 self.prev.as_mut().unwrap().as_vec_mut()
15834 }
15835 fn as_vec(&self) -> &Vec<u8> {
15836 self.prev.as_ref().unwrap().as_vec()
15837 }
15838}
15839impl<Prev: Pusher> PushDlFmsg<Prev> {
15840 pub fn new(prev: Prev) -> Self {
15841 Self {
15842 prev: Some(prev),
15843 header_offset: None,
15844 }
15845 }
15846 pub fn end_nested(mut self) -> Prev {
15847 let mut prev = self.prev.take().unwrap();
15848 if let Some(header_offset) = &self.header_offset {
15849 finalize_nested_header(prev.as_vec_mut(), *header_offset);
15850 }
15851 prev
15852 }
15853 pub fn push_fmsg_obj_nest_start(mut self, value: ()) -> Self {
15854 push_header(self.as_vec_mut(), 107u16, 0 as u16);
15855 self
15856 }
15857 pub fn push_fmsg_pair_nest_start(mut self, value: ()) -> Self {
15858 push_header(self.as_vec_mut(), 108u16, 0 as u16);
15859 self
15860 }
15861 pub fn push_fmsg_arr_nest_start(mut self, value: ()) -> Self {
15862 push_header(self.as_vec_mut(), 109u16, 0 as u16);
15863 self
15864 }
15865 pub fn push_fmsg_nest_end(mut self, value: ()) -> Self {
15866 push_header(self.as_vec_mut(), 110u16, 0 as u16);
15867 self
15868 }
15869 pub fn push_fmsg_obj_name(mut self, value: &CStr) -> Self {
15870 push_header(
15871 self.as_vec_mut(),
15872 111u16,
15873 value.to_bytes_with_nul().len() as u16,
15874 );
15875 self.as_vec_mut().extend(value.to_bytes_with_nul());
15876 self
15877 }
15878 pub fn push_fmsg_obj_name_bytes(mut self, value: &[u8]) -> Self {
15879 push_header(self.as_vec_mut(), 111u16, (value.len() + 1) as u16);
15880 self.as_vec_mut().extend(value);
15881 self.as_vec_mut().push(0);
15882 self
15883 }
15884}
15885impl<Prev: Pusher> Drop for PushDlFmsg<Prev> {
15886 fn drop(&mut self) {
15887 if let Some(prev) = &mut self.prev {
15888 if let Some(header_offset) = &self.header_offset {
15889 finalize_nested_header(prev.as_vec_mut(), *header_offset);
15890 }
15891 }
15892 }
15893}
15894pub struct PushDlHealthReporter<Prev: Pusher> {
15895 pub(crate) prev: Option<Prev>,
15896 pub(crate) header_offset: Option<usize>,
15897}
15898impl<Prev: Pusher> Pusher for PushDlHealthReporter<Prev> {
15899 fn as_vec_mut(&mut self) -> &mut Vec<u8> {
15900 self.prev.as_mut().unwrap().as_vec_mut()
15901 }
15902 fn as_vec(&self) -> &Vec<u8> {
15903 self.prev.as_ref().unwrap().as_vec()
15904 }
15905}
15906impl<Prev: Pusher> PushDlHealthReporter<Prev> {
15907 pub fn new(prev: Prev) -> Self {
15908 Self {
15909 prev: Some(prev),
15910 header_offset: None,
15911 }
15912 }
15913 pub fn end_nested(mut self) -> Prev {
15914 let mut prev = self.prev.take().unwrap();
15915 if let Some(header_offset) = &self.header_offset {
15916 finalize_nested_header(prev.as_vec_mut(), *header_offset);
15917 }
15918 prev
15919 }
15920 pub fn push_health_reporter_name(mut self, value: &CStr) -> Self {
15921 push_header(
15922 self.as_vec_mut(),
15923 115u16,
15924 value.to_bytes_with_nul().len() as u16,
15925 );
15926 self.as_vec_mut().extend(value.to_bytes_with_nul());
15927 self
15928 }
15929 pub fn push_health_reporter_name_bytes(mut self, value: &[u8]) -> Self {
15930 push_header(self.as_vec_mut(), 115u16, (value.len() + 1) as u16);
15931 self.as_vec_mut().extend(value);
15932 self.as_vec_mut().push(0);
15933 self
15934 }
15935 pub fn push_health_reporter_state(mut self, value: u8) -> Self {
15936 push_header(self.as_vec_mut(), 116u16, 1 as u16);
15937 self.as_vec_mut().extend(value.to_ne_bytes());
15938 self
15939 }
15940 pub fn push_health_reporter_err_count(mut self, value: u64) -> Self {
15941 push_header(self.as_vec_mut(), 117u16, 8 as u16);
15942 self.as_vec_mut().extend(value.to_ne_bytes());
15943 self
15944 }
15945 pub fn push_health_reporter_recover_count(mut self, value: u64) -> Self {
15946 push_header(self.as_vec_mut(), 118u16, 8 as u16);
15947 self.as_vec_mut().extend(value.to_ne_bytes());
15948 self
15949 }
15950 pub fn push_health_reporter_dump_ts(mut self, value: u64) -> Self {
15951 push_header(self.as_vec_mut(), 119u16, 8 as u16);
15952 self.as_vec_mut().extend(value.to_ne_bytes());
15953 self
15954 }
15955 pub fn push_health_reporter_graceful_period(mut self, value: u64) -> Self {
15956 push_header(self.as_vec_mut(), 120u16, 8 as u16);
15957 self.as_vec_mut().extend(value.to_ne_bytes());
15958 self
15959 }
15960 pub fn push_health_reporter_auto_recover(mut self, value: u8) -> Self {
15961 push_header(self.as_vec_mut(), 121u16, 1 as u16);
15962 self.as_vec_mut().extend(value.to_ne_bytes());
15963 self
15964 }
15965 pub fn push_health_reporter_dump_ts_ns(mut self, value: u64) -> Self {
15966 push_header(self.as_vec_mut(), 137u16, 8 as u16);
15967 self.as_vec_mut().extend(value.to_ne_bytes());
15968 self
15969 }
15970 pub fn push_health_reporter_auto_dump(mut self, value: u8) -> Self {
15971 push_header(self.as_vec_mut(), 141u16, 1 as u16);
15972 self.as_vec_mut().extend(value.to_ne_bytes());
15973 self
15974 }
15975 #[doc = "Time (in msec) for recoveries before starting the grace period.\n"]
15976 pub fn push_health_reporter_burst_period(mut self, value: u64) -> Self {
15977 push_header(self.as_vec_mut(), 181u16, 8 as u16);
15978 self.as_vec_mut().extend(value.to_ne_bytes());
15979 self
15980 }
15981}
15982impl<Prev: Pusher> Drop for PushDlHealthReporter<Prev> {
15983 fn drop(&mut self) {
15984 if let Some(prev) = &mut self.prev {
15985 if let Some(header_offset) = &self.header_offset {
15986 finalize_nested_header(prev.as_vec_mut(), *header_offset);
15987 }
15988 }
15989 }
15990}
15991pub struct PushDlAttrStats<Prev: Pusher> {
15992 pub(crate) prev: Option<Prev>,
15993 pub(crate) header_offset: Option<usize>,
15994}
15995impl<Prev: Pusher> Pusher for PushDlAttrStats<Prev> {
15996 fn as_vec_mut(&mut self) -> &mut Vec<u8> {
15997 self.prev.as_mut().unwrap().as_vec_mut()
15998 }
15999 fn as_vec(&self) -> &Vec<u8> {
16000 self.prev.as_ref().unwrap().as_vec()
16001 }
16002}
16003impl<Prev: Pusher> PushDlAttrStats<Prev> {
16004 pub fn new(prev: Prev) -> Self {
16005 Self {
16006 prev: Some(prev),
16007 header_offset: None,
16008 }
16009 }
16010 pub fn end_nested(mut self) -> Prev {
16011 let mut prev = self.prev.take().unwrap();
16012 if let Some(header_offset) = &self.header_offset {
16013 finalize_nested_header(prev.as_vec_mut(), *header_offset);
16014 }
16015 prev
16016 }
16017 pub fn push_stats_rx_packets(mut self, value: u64) -> Self {
16018 push_header(self.as_vec_mut(), 0u16, 8 as u16);
16019 self.as_vec_mut().extend(value.to_ne_bytes());
16020 self
16021 }
16022 pub fn push_stats_rx_bytes(mut self, value: u64) -> Self {
16023 push_header(self.as_vec_mut(), 1u16, 8 as u16);
16024 self.as_vec_mut().extend(value.to_ne_bytes());
16025 self
16026 }
16027 pub fn push_stats_rx_dropped(mut self, value: u64) -> Self {
16028 push_header(self.as_vec_mut(), 2u16, 8 as u16);
16029 self.as_vec_mut().extend(value.to_ne_bytes());
16030 self
16031 }
16032}
16033impl<Prev: Pusher> Drop for PushDlAttrStats<Prev> {
16034 fn drop(&mut self) {
16035 if let Some(prev) = &mut self.prev {
16036 if let Some(header_offset) = &self.header_offset {
16037 finalize_nested_header(prev.as_vec_mut(), *header_offset);
16038 }
16039 }
16040 }
16041}
16042pub struct PushDlTrapMetadata<Prev: Pusher> {
16043 pub(crate) prev: Option<Prev>,
16044 pub(crate) header_offset: Option<usize>,
16045}
16046impl<Prev: Pusher> Pusher for PushDlTrapMetadata<Prev> {
16047 fn as_vec_mut(&mut self) -> &mut Vec<u8> {
16048 self.prev.as_mut().unwrap().as_vec_mut()
16049 }
16050 fn as_vec(&self) -> &Vec<u8> {
16051 self.prev.as_ref().unwrap().as_vec()
16052 }
16053}
16054impl<Prev: Pusher> PushDlTrapMetadata<Prev> {
16055 pub fn new(prev: Prev) -> Self {
16056 Self {
16057 prev: Some(prev),
16058 header_offset: None,
16059 }
16060 }
16061 pub fn end_nested(mut self) -> Prev {
16062 let mut prev = self.prev.take().unwrap();
16063 if let Some(header_offset) = &self.header_offset {
16064 finalize_nested_header(prev.as_vec_mut(), *header_offset);
16065 }
16066 prev
16067 }
16068 pub fn push_trap_metadata_type_in_port(mut self, value: ()) -> Self {
16069 push_header(self.as_vec_mut(), 0u16, 0 as u16);
16070 self
16071 }
16072 pub fn push_trap_metadata_type_fa_cookie(mut self, value: ()) -> Self {
16073 push_header(self.as_vec_mut(), 1u16, 0 as u16);
16074 self
16075 }
16076}
16077impl<Prev: Pusher> Drop for PushDlTrapMetadata<Prev> {
16078 fn drop(&mut self) {
16079 if let Some(prev) = &mut self.prev {
16080 if let Some(header_offset) = &self.header_offset {
16081 finalize_nested_header(prev.as_vec_mut(), *header_offset);
16082 }
16083 }
16084 }
16085}
16086pub struct PushDlLinecardSupportedTypes<Prev: Pusher> {
16087 pub(crate) prev: Option<Prev>,
16088 pub(crate) header_offset: Option<usize>,
16089}
16090impl<Prev: Pusher> Pusher for PushDlLinecardSupportedTypes<Prev> {
16091 fn as_vec_mut(&mut self) -> &mut Vec<u8> {
16092 self.prev.as_mut().unwrap().as_vec_mut()
16093 }
16094 fn as_vec(&self) -> &Vec<u8> {
16095 self.prev.as_ref().unwrap().as_vec()
16096 }
16097}
16098impl<Prev: Pusher> PushDlLinecardSupportedTypes<Prev> {
16099 pub fn new(prev: Prev) -> Self {
16100 Self {
16101 prev: Some(prev),
16102 header_offset: None,
16103 }
16104 }
16105 pub fn end_nested(mut self) -> Prev {
16106 let mut prev = self.prev.take().unwrap();
16107 if let Some(header_offset) = &self.header_offset {
16108 finalize_nested_header(prev.as_vec_mut(), *header_offset);
16109 }
16110 prev
16111 }
16112 pub fn push_linecard_type(mut self, value: &CStr) -> Self {
16113 push_header(
16114 self.as_vec_mut(),
16115 173u16,
16116 value.to_bytes_with_nul().len() as u16,
16117 );
16118 self.as_vec_mut().extend(value.to_bytes_with_nul());
16119 self
16120 }
16121 pub fn push_linecard_type_bytes(mut self, value: &[u8]) -> Self {
16122 push_header(self.as_vec_mut(), 173u16, (value.len() + 1) as u16);
16123 self.as_vec_mut().extend(value);
16124 self.as_vec_mut().push(0);
16125 self
16126 }
16127}
16128impl<Prev: Pusher> Drop for PushDlLinecardSupportedTypes<Prev> {
16129 fn drop(&mut self) {
16130 if let Some(prev) = &mut self.prev {
16131 if let Some(header_offset) = &self.header_offset {
16132 finalize_nested_header(prev.as_vec_mut(), *header_offset);
16133 }
16134 }
16135 }
16136}
16137pub struct PushDlSelftestId<Prev: Pusher> {
16138 pub(crate) prev: Option<Prev>,
16139 pub(crate) header_offset: Option<usize>,
16140}
16141impl<Prev: Pusher> Pusher for PushDlSelftestId<Prev> {
16142 fn as_vec_mut(&mut self) -> &mut Vec<u8> {
16143 self.prev.as_mut().unwrap().as_vec_mut()
16144 }
16145 fn as_vec(&self) -> &Vec<u8> {
16146 self.prev.as_ref().unwrap().as_vec()
16147 }
16148}
16149impl<Prev: Pusher> PushDlSelftestId<Prev> {
16150 pub fn new(prev: Prev) -> Self {
16151 Self {
16152 prev: Some(prev),
16153 header_offset: None,
16154 }
16155 }
16156 pub fn end_nested(mut self) -> Prev {
16157 let mut prev = self.prev.take().unwrap();
16158 if let Some(header_offset) = &self.header_offset {
16159 finalize_nested_header(prev.as_vec_mut(), *header_offset);
16160 }
16161 prev
16162 }
16163 pub fn push_flash(mut self, value: ()) -> Self {
16164 push_header(self.as_vec_mut(), 1u16, 0 as u16);
16165 self
16166 }
16167}
16168impl<Prev: Pusher> Drop for PushDlSelftestId<Prev> {
16169 fn drop(&mut self) {
16170 if let Some(prev) = &mut self.prev {
16171 if let Some(header_offset) = &self.header_offset {
16172 finalize_nested_header(prev.as_vec_mut(), *header_offset);
16173 }
16174 }
16175 }
16176}
16177pub struct PushDlRateTcBws<Prev: Pusher> {
16178 pub(crate) prev: Option<Prev>,
16179 pub(crate) header_offset: Option<usize>,
16180}
16181impl<Prev: Pusher> Pusher for PushDlRateTcBws<Prev> {
16182 fn as_vec_mut(&mut self) -> &mut Vec<u8> {
16183 self.prev.as_mut().unwrap().as_vec_mut()
16184 }
16185 fn as_vec(&self) -> &Vec<u8> {
16186 self.prev.as_ref().unwrap().as_vec()
16187 }
16188}
16189impl<Prev: Pusher> PushDlRateTcBws<Prev> {
16190 pub fn new(prev: Prev) -> Self {
16191 Self {
16192 prev: Some(prev),
16193 header_offset: None,
16194 }
16195 }
16196 pub fn end_nested(mut self) -> Prev {
16197 let mut prev = self.prev.take().unwrap();
16198 if let Some(header_offset) = &self.header_offset {
16199 finalize_nested_header(prev.as_vec_mut(), *header_offset);
16200 }
16201 prev
16202 }
16203 pub fn push_index(mut self, value: u8) -> Self {
16204 push_header(self.as_vec_mut(), 1u16, 1 as u16);
16205 self.as_vec_mut().extend(value.to_ne_bytes());
16206 self
16207 }
16208 #[doc = "Specifies the bandwidth share assigned to the Traffic Class. The\nbandwidth for the traffic class is determined in proportion to the sum\nof the shares of all configured classes.\n"]
16209 pub fn push_bw(mut self, value: u32) -> Self {
16210 push_header(self.as_vec_mut(), 2u16, 4 as u16);
16211 self.as_vec_mut().extend(value.to_ne_bytes());
16212 self
16213 }
16214}
16215impl<Prev: Pusher> Drop for PushDlRateTcBws<Prev> {
16216 fn drop(&mut self) {
16217 if let Some(prev) = &mut self.prev {
16218 if let Some(header_offset) = &self.header_offset {
16219 finalize_nested_header(prev.as_vec_mut(), *header_offset);
16220 }
16221 }
16222 }
16223}
16224#[doc = "Get devlink instances.\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_reload_failed()](IterableDevlink::get_reload_failed)\n- [.get_dev_stats()](IterableDevlink::get_dev_stats)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
16225#[derive(Debug)]
16226pub struct OpGetDump<'r> {
16227 request: Request<'r>,
16228}
16229impl<'r> OpGetDump<'r> {
16230 pub fn new(mut request: Request<'r>) -> Self {
16231 Self::write_header(request.buf_mut());
16232 Self {
16233 request: request.set_dump(),
16234 }
16235 }
16236 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
16237 Self::write_header(buf);
16238 PushDevlink::new(buf)
16239 }
16240 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
16241 PushDevlink::new(self.request.buf_mut())
16242 }
16243 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
16244 PushDevlink::new(self.request.buf)
16245 }
16246 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
16247 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
16248 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
16249 }
16250 fn write_header<Prev: Pusher>(prev: &mut Prev) {
16251 let mut header = BuiltinNfgenmsg::new();
16252 header.cmd = 1u8;
16253 header.version = 1u8;
16254 prev.as_vec_mut().extend(header.as_slice());
16255 }
16256}
16257impl NetlinkRequest for OpGetDump<'_> {
16258 fn protocol(&self) -> Protocol {
16259 Protocol::Generic("devlink".as_bytes())
16260 }
16261 fn flags(&self) -> u16 {
16262 self.request.flags
16263 }
16264 fn payload(&self) -> &[u8] {
16265 self.request.buf()
16266 }
16267 type ReplyType<'buf> = IterableDevlink<'buf>;
16268 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
16269 Self::decode_request(buf)
16270 }
16271 fn lookup(
16272 buf: &[u8],
16273 offset: usize,
16274 missing_type: Option<u16>,
16275 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
16276 Self::decode_request(buf).lookup_attr(offset, missing_type)
16277 }
16278}
16279#[doc = "Get devlink instances.\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_reload_failed()](IterableDevlink::get_reload_failed)\n- [.get_dev_stats()](IterableDevlink::get_dev_stats)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
16280#[derive(Debug)]
16281pub struct OpGetDo<'r> {
16282 request: Request<'r>,
16283}
16284impl<'r> OpGetDo<'r> {
16285 pub fn new(mut request: Request<'r>) -> Self {
16286 Self::write_header(request.buf_mut());
16287 Self { request: request }
16288 }
16289 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
16290 Self::write_header(buf);
16291 PushDevlink::new(buf)
16292 }
16293 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
16294 PushDevlink::new(self.request.buf_mut())
16295 }
16296 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
16297 PushDevlink::new(self.request.buf)
16298 }
16299 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
16300 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
16301 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
16302 }
16303 fn write_header<Prev: Pusher>(prev: &mut Prev) {
16304 let mut header = BuiltinNfgenmsg::new();
16305 header.cmd = 1u8;
16306 header.version = 1u8;
16307 prev.as_vec_mut().extend(header.as_slice());
16308 }
16309}
16310impl NetlinkRequest for OpGetDo<'_> {
16311 fn protocol(&self) -> Protocol {
16312 Protocol::Generic("devlink".as_bytes())
16313 }
16314 fn flags(&self) -> u16 {
16315 self.request.flags
16316 }
16317 fn payload(&self) -> &[u8] {
16318 self.request.buf()
16319 }
16320 type ReplyType<'buf> = IterableDevlink<'buf>;
16321 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
16322 Self::decode_request(buf)
16323 }
16324 fn lookup(
16325 buf: &[u8],
16326 offset: usize,
16327 missing_type: Option<u16>,
16328 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
16329 Self::decode_request(buf).lookup_attr(offset, missing_type)
16330 }
16331}
16332#[doc = "Get devlink port instances.\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_port_index()](IterableDevlink::get_port_index)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
16333#[derive(Debug)]
16334pub struct OpPortGetDump<'r> {
16335 request: Request<'r>,
16336}
16337impl<'r> OpPortGetDump<'r> {
16338 pub fn new(mut request: Request<'r>) -> Self {
16339 Self::write_header(request.buf_mut());
16340 Self {
16341 request: request.set_dump(),
16342 }
16343 }
16344 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
16345 Self::write_header(buf);
16346 PushDevlink::new(buf)
16347 }
16348 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
16349 PushDevlink::new(self.request.buf_mut())
16350 }
16351 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
16352 PushDevlink::new(self.request.buf)
16353 }
16354 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
16355 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
16356 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
16357 }
16358 fn write_header<Prev: Pusher>(prev: &mut Prev) {
16359 let mut header = BuiltinNfgenmsg::new();
16360 header.cmd = 5u8;
16361 header.version = 1u8;
16362 prev.as_vec_mut().extend(header.as_slice());
16363 }
16364}
16365impl NetlinkRequest for OpPortGetDump<'_> {
16366 fn protocol(&self) -> Protocol {
16367 Protocol::Generic("devlink".as_bytes())
16368 }
16369 fn flags(&self) -> u16 {
16370 self.request.flags
16371 }
16372 fn payload(&self) -> &[u8] {
16373 self.request.buf()
16374 }
16375 type ReplyType<'buf> = IterableDevlink<'buf>;
16376 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
16377 Self::decode_request(buf)
16378 }
16379 fn lookup(
16380 buf: &[u8],
16381 offset: usize,
16382 missing_type: Option<u16>,
16383 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
16384 Self::decode_request(buf).lookup_attr(offset, missing_type)
16385 }
16386}
16387#[doc = "Get devlink port instances.\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_port_index()](PushDevlink::push_port_index)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_port_index()](IterableDevlink::get_port_index)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
16388#[derive(Debug)]
16389pub struct OpPortGetDo<'r> {
16390 request: Request<'r>,
16391}
16392impl<'r> OpPortGetDo<'r> {
16393 pub fn new(mut request: Request<'r>) -> Self {
16394 Self::write_header(request.buf_mut());
16395 Self { request: request }
16396 }
16397 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
16398 Self::write_header(buf);
16399 PushDevlink::new(buf)
16400 }
16401 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
16402 PushDevlink::new(self.request.buf_mut())
16403 }
16404 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
16405 PushDevlink::new(self.request.buf)
16406 }
16407 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
16408 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
16409 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
16410 }
16411 fn write_header<Prev: Pusher>(prev: &mut Prev) {
16412 let mut header = BuiltinNfgenmsg::new();
16413 header.cmd = 5u8;
16414 header.version = 1u8;
16415 prev.as_vec_mut().extend(header.as_slice());
16416 }
16417}
16418impl NetlinkRequest for OpPortGetDo<'_> {
16419 fn protocol(&self) -> Protocol {
16420 Protocol::Generic("devlink".as_bytes())
16421 }
16422 fn flags(&self) -> u16 {
16423 self.request.flags
16424 }
16425 fn payload(&self) -> &[u8] {
16426 self.request.buf()
16427 }
16428 type ReplyType<'buf> = IterableDevlink<'buf>;
16429 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
16430 Self::decode_request(buf)
16431 }
16432 fn lookup(
16433 buf: &[u8],
16434 offset: usize,
16435 missing_type: Option<u16>,
16436 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
16437 Self::decode_request(buf).lookup_attr(offset, missing_type)
16438 }
16439}
16440#[doc = "Set devlink port instances.\n\nFlags: admin-perm\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_port_index()](PushDevlink::push_port_index)\n- [.push_port_type()](PushDevlink::push_port_type)\n- [.nested_port_function()](PushDevlink::nested_port_function)\n- [.push_index()](PushDevlink::push_index)\n\n"]
16441#[derive(Debug)]
16442pub struct OpPortSetDo<'r> {
16443 request: Request<'r>,
16444}
16445impl<'r> OpPortSetDo<'r> {
16446 pub fn new(mut request: Request<'r>) -> Self {
16447 Self::write_header(request.buf_mut());
16448 Self { request: request }
16449 }
16450 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
16451 Self::write_header(buf);
16452 PushDevlink::new(buf)
16453 }
16454 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
16455 PushDevlink::new(self.request.buf_mut())
16456 }
16457 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
16458 PushDevlink::new(self.request.buf)
16459 }
16460 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
16461 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
16462 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
16463 }
16464 fn write_header<Prev: Pusher>(prev: &mut Prev) {
16465 let mut header = BuiltinNfgenmsg::new();
16466 header.cmd = 6u8;
16467 header.version = 1u8;
16468 prev.as_vec_mut().extend(header.as_slice());
16469 }
16470}
16471impl NetlinkRequest for OpPortSetDo<'_> {
16472 fn protocol(&self) -> Protocol {
16473 Protocol::Generic("devlink".as_bytes())
16474 }
16475 fn flags(&self) -> u16 {
16476 self.request.flags
16477 }
16478 fn payload(&self) -> &[u8] {
16479 self.request.buf()
16480 }
16481 type ReplyType<'buf> = IterableDevlink<'buf>;
16482 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
16483 Self::decode_request(buf)
16484 }
16485 fn lookup(
16486 buf: &[u8],
16487 offset: usize,
16488 missing_type: Option<u16>,
16489 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
16490 Self::decode_request(buf).lookup_attr(offset, missing_type)
16491 }
16492}
16493#[doc = "Create devlink port instances.\n\nFlags: admin-perm\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_port_index()](PushDevlink::push_port_index)\n- [.push_port_flavour()](PushDevlink::push_port_flavour)\n- [.push_port_pci_pf_number()](PushDevlink::push_port_pci_pf_number)\n- [.push_port_controller_number()](PushDevlink::push_port_controller_number)\n- [.push_port_pci_sf_number()](PushDevlink::push_port_pci_sf_number)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_port_index()](IterableDevlink::get_port_index)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
16494#[derive(Debug)]
16495pub struct OpPortNewDo<'r> {
16496 request: Request<'r>,
16497}
16498impl<'r> OpPortNewDo<'r> {
16499 pub fn new(mut request: Request<'r>) -> Self {
16500 Self::write_header(request.buf_mut());
16501 Self { request: request }
16502 }
16503 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
16504 Self::write_header(buf);
16505 PushDevlink::new(buf)
16506 }
16507 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
16508 PushDevlink::new(self.request.buf_mut())
16509 }
16510 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
16511 PushDevlink::new(self.request.buf)
16512 }
16513 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
16514 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
16515 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
16516 }
16517 fn write_header<Prev: Pusher>(prev: &mut Prev) {
16518 let mut header = BuiltinNfgenmsg::new();
16519 header.cmd = 7u8;
16520 header.version = 1u8;
16521 prev.as_vec_mut().extend(header.as_slice());
16522 }
16523}
16524impl NetlinkRequest for OpPortNewDo<'_> {
16525 fn protocol(&self) -> Protocol {
16526 Protocol::Generic("devlink".as_bytes())
16527 }
16528 fn flags(&self) -> u16 {
16529 self.request.flags
16530 }
16531 fn payload(&self) -> &[u8] {
16532 self.request.buf()
16533 }
16534 type ReplyType<'buf> = IterableDevlink<'buf>;
16535 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
16536 Self::decode_request(buf)
16537 }
16538 fn lookup(
16539 buf: &[u8],
16540 offset: usize,
16541 missing_type: Option<u16>,
16542 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
16543 Self::decode_request(buf).lookup_attr(offset, missing_type)
16544 }
16545}
16546#[doc = "Delete devlink port instances.\n\nFlags: admin-perm\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_port_index()](PushDevlink::push_port_index)\n- [.push_index()](PushDevlink::push_index)\n\n"]
16547#[derive(Debug)]
16548pub struct OpPortDelDo<'r> {
16549 request: Request<'r>,
16550}
16551impl<'r> OpPortDelDo<'r> {
16552 pub fn new(mut request: Request<'r>) -> Self {
16553 Self::write_header(request.buf_mut());
16554 Self { request: request }
16555 }
16556 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
16557 Self::write_header(buf);
16558 PushDevlink::new(buf)
16559 }
16560 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
16561 PushDevlink::new(self.request.buf_mut())
16562 }
16563 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
16564 PushDevlink::new(self.request.buf)
16565 }
16566 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
16567 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
16568 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
16569 }
16570 fn write_header<Prev: Pusher>(prev: &mut Prev) {
16571 let mut header = BuiltinNfgenmsg::new();
16572 header.cmd = 8u8;
16573 header.version = 1u8;
16574 prev.as_vec_mut().extend(header.as_slice());
16575 }
16576}
16577impl NetlinkRequest for OpPortDelDo<'_> {
16578 fn protocol(&self) -> Protocol {
16579 Protocol::Generic("devlink".as_bytes())
16580 }
16581 fn flags(&self) -> u16 {
16582 self.request.flags
16583 }
16584 fn payload(&self) -> &[u8] {
16585 self.request.buf()
16586 }
16587 type ReplyType<'buf> = IterableDevlink<'buf>;
16588 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
16589 Self::decode_request(buf)
16590 }
16591 fn lookup(
16592 buf: &[u8],
16593 offset: usize,
16594 missing_type: Option<u16>,
16595 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
16596 Self::decode_request(buf).lookup_attr(offset, missing_type)
16597 }
16598}
16599#[doc = "Split devlink port instances.\n\nFlags: admin-perm\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_port_index()](PushDevlink::push_port_index)\n- [.push_port_split_count()](PushDevlink::push_port_split_count)\n- [.push_index()](PushDevlink::push_index)\n\n"]
16600#[derive(Debug)]
16601pub struct OpPortSplitDo<'r> {
16602 request: Request<'r>,
16603}
16604impl<'r> OpPortSplitDo<'r> {
16605 pub fn new(mut request: Request<'r>) -> Self {
16606 Self::write_header(request.buf_mut());
16607 Self { request: request }
16608 }
16609 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
16610 Self::write_header(buf);
16611 PushDevlink::new(buf)
16612 }
16613 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
16614 PushDevlink::new(self.request.buf_mut())
16615 }
16616 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
16617 PushDevlink::new(self.request.buf)
16618 }
16619 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
16620 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
16621 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
16622 }
16623 fn write_header<Prev: Pusher>(prev: &mut Prev) {
16624 let mut header = BuiltinNfgenmsg::new();
16625 header.cmd = 9u8;
16626 header.version = 1u8;
16627 prev.as_vec_mut().extend(header.as_slice());
16628 }
16629}
16630impl NetlinkRequest for OpPortSplitDo<'_> {
16631 fn protocol(&self) -> Protocol {
16632 Protocol::Generic("devlink".as_bytes())
16633 }
16634 fn flags(&self) -> u16 {
16635 self.request.flags
16636 }
16637 fn payload(&self) -> &[u8] {
16638 self.request.buf()
16639 }
16640 type ReplyType<'buf> = IterableDevlink<'buf>;
16641 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
16642 Self::decode_request(buf)
16643 }
16644 fn lookup(
16645 buf: &[u8],
16646 offset: usize,
16647 missing_type: Option<u16>,
16648 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
16649 Self::decode_request(buf).lookup_attr(offset, missing_type)
16650 }
16651}
16652#[doc = "Unplit devlink port instances.\n\nFlags: admin-perm\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_port_index()](PushDevlink::push_port_index)\n- [.push_index()](PushDevlink::push_index)\n\n"]
16653#[derive(Debug)]
16654pub struct OpPortUnsplitDo<'r> {
16655 request: Request<'r>,
16656}
16657impl<'r> OpPortUnsplitDo<'r> {
16658 pub fn new(mut request: Request<'r>) -> Self {
16659 Self::write_header(request.buf_mut());
16660 Self { request: request }
16661 }
16662 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
16663 Self::write_header(buf);
16664 PushDevlink::new(buf)
16665 }
16666 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
16667 PushDevlink::new(self.request.buf_mut())
16668 }
16669 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
16670 PushDevlink::new(self.request.buf)
16671 }
16672 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
16673 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
16674 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
16675 }
16676 fn write_header<Prev: Pusher>(prev: &mut Prev) {
16677 let mut header = BuiltinNfgenmsg::new();
16678 header.cmd = 10u8;
16679 header.version = 1u8;
16680 prev.as_vec_mut().extend(header.as_slice());
16681 }
16682}
16683impl NetlinkRequest for OpPortUnsplitDo<'_> {
16684 fn protocol(&self) -> Protocol {
16685 Protocol::Generic("devlink".as_bytes())
16686 }
16687 fn flags(&self) -> u16 {
16688 self.request.flags
16689 }
16690 fn payload(&self) -> &[u8] {
16691 self.request.buf()
16692 }
16693 type ReplyType<'buf> = IterableDevlink<'buf>;
16694 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
16695 Self::decode_request(buf)
16696 }
16697 fn lookup(
16698 buf: &[u8],
16699 offset: usize,
16700 missing_type: Option<u16>,
16701 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
16702 Self::decode_request(buf).lookup_attr(offset, missing_type)
16703 }
16704}
16705#[doc = "Get shared buffer instances.\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_sb_index()](IterableDevlink::get_sb_index)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
16706#[derive(Debug)]
16707pub struct OpSbGetDump<'r> {
16708 request: Request<'r>,
16709}
16710impl<'r> OpSbGetDump<'r> {
16711 pub fn new(mut request: Request<'r>) -> Self {
16712 Self::write_header(request.buf_mut());
16713 Self {
16714 request: request.set_dump(),
16715 }
16716 }
16717 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
16718 Self::write_header(buf);
16719 PushDevlink::new(buf)
16720 }
16721 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
16722 PushDevlink::new(self.request.buf_mut())
16723 }
16724 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
16725 PushDevlink::new(self.request.buf)
16726 }
16727 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
16728 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
16729 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
16730 }
16731 fn write_header<Prev: Pusher>(prev: &mut Prev) {
16732 let mut header = BuiltinNfgenmsg::new();
16733 header.cmd = 11u8;
16734 header.version = 1u8;
16735 prev.as_vec_mut().extend(header.as_slice());
16736 }
16737}
16738impl NetlinkRequest for OpSbGetDump<'_> {
16739 fn protocol(&self) -> Protocol {
16740 Protocol::Generic("devlink".as_bytes())
16741 }
16742 fn flags(&self) -> u16 {
16743 self.request.flags
16744 }
16745 fn payload(&self) -> &[u8] {
16746 self.request.buf()
16747 }
16748 type ReplyType<'buf> = IterableDevlink<'buf>;
16749 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
16750 Self::decode_request(buf)
16751 }
16752 fn lookup(
16753 buf: &[u8],
16754 offset: usize,
16755 missing_type: Option<u16>,
16756 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
16757 Self::decode_request(buf).lookup_attr(offset, missing_type)
16758 }
16759}
16760#[doc = "Get shared buffer instances.\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_sb_index()](PushDevlink::push_sb_index)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_sb_index()](IterableDevlink::get_sb_index)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
16761#[derive(Debug)]
16762pub struct OpSbGetDo<'r> {
16763 request: Request<'r>,
16764}
16765impl<'r> OpSbGetDo<'r> {
16766 pub fn new(mut request: Request<'r>) -> Self {
16767 Self::write_header(request.buf_mut());
16768 Self { request: request }
16769 }
16770 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
16771 Self::write_header(buf);
16772 PushDevlink::new(buf)
16773 }
16774 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
16775 PushDevlink::new(self.request.buf_mut())
16776 }
16777 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
16778 PushDevlink::new(self.request.buf)
16779 }
16780 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
16781 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
16782 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
16783 }
16784 fn write_header<Prev: Pusher>(prev: &mut Prev) {
16785 let mut header = BuiltinNfgenmsg::new();
16786 header.cmd = 11u8;
16787 header.version = 1u8;
16788 prev.as_vec_mut().extend(header.as_slice());
16789 }
16790}
16791impl NetlinkRequest for OpSbGetDo<'_> {
16792 fn protocol(&self) -> Protocol {
16793 Protocol::Generic("devlink".as_bytes())
16794 }
16795 fn flags(&self) -> u16 {
16796 self.request.flags
16797 }
16798 fn payload(&self) -> &[u8] {
16799 self.request.buf()
16800 }
16801 type ReplyType<'buf> = IterableDevlink<'buf>;
16802 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
16803 Self::decode_request(buf)
16804 }
16805 fn lookup(
16806 buf: &[u8],
16807 offset: usize,
16808 missing_type: Option<u16>,
16809 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
16810 Self::decode_request(buf).lookup_attr(offset, missing_type)
16811 }
16812}
16813#[doc = "Get shared buffer pool instances.\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_sb_index()](IterableDevlink::get_sb_index)\n- [.get_sb_pool_index()](IterableDevlink::get_sb_pool_index)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
16814#[derive(Debug)]
16815pub struct OpSbPoolGetDump<'r> {
16816 request: Request<'r>,
16817}
16818impl<'r> OpSbPoolGetDump<'r> {
16819 pub fn new(mut request: Request<'r>) -> Self {
16820 Self::write_header(request.buf_mut());
16821 Self {
16822 request: request.set_dump(),
16823 }
16824 }
16825 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
16826 Self::write_header(buf);
16827 PushDevlink::new(buf)
16828 }
16829 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
16830 PushDevlink::new(self.request.buf_mut())
16831 }
16832 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
16833 PushDevlink::new(self.request.buf)
16834 }
16835 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
16836 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
16837 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
16838 }
16839 fn write_header<Prev: Pusher>(prev: &mut Prev) {
16840 let mut header = BuiltinNfgenmsg::new();
16841 header.cmd = 15u8;
16842 header.version = 1u8;
16843 prev.as_vec_mut().extend(header.as_slice());
16844 }
16845}
16846impl NetlinkRequest for OpSbPoolGetDump<'_> {
16847 fn protocol(&self) -> Protocol {
16848 Protocol::Generic("devlink".as_bytes())
16849 }
16850 fn flags(&self) -> u16 {
16851 self.request.flags
16852 }
16853 fn payload(&self) -> &[u8] {
16854 self.request.buf()
16855 }
16856 type ReplyType<'buf> = IterableDevlink<'buf>;
16857 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
16858 Self::decode_request(buf)
16859 }
16860 fn lookup(
16861 buf: &[u8],
16862 offset: usize,
16863 missing_type: Option<u16>,
16864 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
16865 Self::decode_request(buf).lookup_attr(offset, missing_type)
16866 }
16867}
16868#[doc = "Get shared buffer pool instances.\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_sb_index()](PushDevlink::push_sb_index)\n- [.push_sb_pool_index()](PushDevlink::push_sb_pool_index)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_sb_index()](IterableDevlink::get_sb_index)\n- [.get_sb_pool_index()](IterableDevlink::get_sb_pool_index)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
16869#[derive(Debug)]
16870pub struct OpSbPoolGetDo<'r> {
16871 request: Request<'r>,
16872}
16873impl<'r> OpSbPoolGetDo<'r> {
16874 pub fn new(mut request: Request<'r>) -> Self {
16875 Self::write_header(request.buf_mut());
16876 Self { request: request }
16877 }
16878 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
16879 Self::write_header(buf);
16880 PushDevlink::new(buf)
16881 }
16882 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
16883 PushDevlink::new(self.request.buf_mut())
16884 }
16885 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
16886 PushDevlink::new(self.request.buf)
16887 }
16888 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
16889 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
16890 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
16891 }
16892 fn write_header<Prev: Pusher>(prev: &mut Prev) {
16893 let mut header = BuiltinNfgenmsg::new();
16894 header.cmd = 15u8;
16895 header.version = 1u8;
16896 prev.as_vec_mut().extend(header.as_slice());
16897 }
16898}
16899impl NetlinkRequest for OpSbPoolGetDo<'_> {
16900 fn protocol(&self) -> Protocol {
16901 Protocol::Generic("devlink".as_bytes())
16902 }
16903 fn flags(&self) -> u16 {
16904 self.request.flags
16905 }
16906 fn payload(&self) -> &[u8] {
16907 self.request.buf()
16908 }
16909 type ReplyType<'buf> = IterableDevlink<'buf>;
16910 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
16911 Self::decode_request(buf)
16912 }
16913 fn lookup(
16914 buf: &[u8],
16915 offset: usize,
16916 missing_type: Option<u16>,
16917 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
16918 Self::decode_request(buf).lookup_attr(offset, missing_type)
16919 }
16920}
16921#[doc = "Set shared buffer pool instances.\n\nFlags: admin-perm\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_sb_index()](PushDevlink::push_sb_index)\n- [.push_sb_pool_index()](PushDevlink::push_sb_pool_index)\n- [.push_sb_pool_size()](PushDevlink::push_sb_pool_size)\n- [.push_sb_pool_threshold_type()](PushDevlink::push_sb_pool_threshold_type)\n- [.push_index()](PushDevlink::push_index)\n\n"]
16922#[derive(Debug)]
16923pub struct OpSbPoolSetDo<'r> {
16924 request: Request<'r>,
16925}
16926impl<'r> OpSbPoolSetDo<'r> {
16927 pub fn new(mut request: Request<'r>) -> Self {
16928 Self::write_header(request.buf_mut());
16929 Self { request: request }
16930 }
16931 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
16932 Self::write_header(buf);
16933 PushDevlink::new(buf)
16934 }
16935 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
16936 PushDevlink::new(self.request.buf_mut())
16937 }
16938 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
16939 PushDevlink::new(self.request.buf)
16940 }
16941 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
16942 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
16943 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
16944 }
16945 fn write_header<Prev: Pusher>(prev: &mut Prev) {
16946 let mut header = BuiltinNfgenmsg::new();
16947 header.cmd = 16u8;
16948 header.version = 1u8;
16949 prev.as_vec_mut().extend(header.as_slice());
16950 }
16951}
16952impl NetlinkRequest for OpSbPoolSetDo<'_> {
16953 fn protocol(&self) -> Protocol {
16954 Protocol::Generic("devlink".as_bytes())
16955 }
16956 fn flags(&self) -> u16 {
16957 self.request.flags
16958 }
16959 fn payload(&self) -> &[u8] {
16960 self.request.buf()
16961 }
16962 type ReplyType<'buf> = IterableDevlink<'buf>;
16963 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
16964 Self::decode_request(buf)
16965 }
16966 fn lookup(
16967 buf: &[u8],
16968 offset: usize,
16969 missing_type: Option<u16>,
16970 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
16971 Self::decode_request(buf).lookup_attr(offset, missing_type)
16972 }
16973}
16974#[doc = "Get shared buffer port-pool combinations and threshold.\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_port_index()](IterableDevlink::get_port_index)\n- [.get_sb_index()](IterableDevlink::get_sb_index)\n- [.get_sb_pool_index()](IterableDevlink::get_sb_pool_index)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
16975#[derive(Debug)]
16976pub struct OpSbPortPoolGetDump<'r> {
16977 request: Request<'r>,
16978}
16979impl<'r> OpSbPortPoolGetDump<'r> {
16980 pub fn new(mut request: Request<'r>) -> Self {
16981 Self::write_header(request.buf_mut());
16982 Self {
16983 request: request.set_dump(),
16984 }
16985 }
16986 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
16987 Self::write_header(buf);
16988 PushDevlink::new(buf)
16989 }
16990 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
16991 PushDevlink::new(self.request.buf_mut())
16992 }
16993 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
16994 PushDevlink::new(self.request.buf)
16995 }
16996 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
16997 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
16998 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
16999 }
17000 fn write_header<Prev: Pusher>(prev: &mut Prev) {
17001 let mut header = BuiltinNfgenmsg::new();
17002 header.cmd = 19u8;
17003 header.version = 1u8;
17004 prev.as_vec_mut().extend(header.as_slice());
17005 }
17006}
17007impl NetlinkRequest for OpSbPortPoolGetDump<'_> {
17008 fn protocol(&self) -> Protocol {
17009 Protocol::Generic("devlink".as_bytes())
17010 }
17011 fn flags(&self) -> u16 {
17012 self.request.flags
17013 }
17014 fn payload(&self) -> &[u8] {
17015 self.request.buf()
17016 }
17017 type ReplyType<'buf> = IterableDevlink<'buf>;
17018 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
17019 Self::decode_request(buf)
17020 }
17021 fn lookup(
17022 buf: &[u8],
17023 offset: usize,
17024 missing_type: Option<u16>,
17025 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
17026 Self::decode_request(buf).lookup_attr(offset, missing_type)
17027 }
17028}
17029#[doc = "Get shared buffer port-pool combinations and threshold.\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_port_index()](PushDevlink::push_port_index)\n- [.push_sb_index()](PushDevlink::push_sb_index)\n- [.push_sb_pool_index()](PushDevlink::push_sb_pool_index)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_port_index()](IterableDevlink::get_port_index)\n- [.get_sb_index()](IterableDevlink::get_sb_index)\n- [.get_sb_pool_index()](IterableDevlink::get_sb_pool_index)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
17030#[derive(Debug)]
17031pub struct OpSbPortPoolGetDo<'r> {
17032 request: Request<'r>,
17033}
17034impl<'r> OpSbPortPoolGetDo<'r> {
17035 pub fn new(mut request: Request<'r>) -> Self {
17036 Self::write_header(request.buf_mut());
17037 Self { request: request }
17038 }
17039 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
17040 Self::write_header(buf);
17041 PushDevlink::new(buf)
17042 }
17043 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
17044 PushDevlink::new(self.request.buf_mut())
17045 }
17046 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
17047 PushDevlink::new(self.request.buf)
17048 }
17049 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
17050 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
17051 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
17052 }
17053 fn write_header<Prev: Pusher>(prev: &mut Prev) {
17054 let mut header = BuiltinNfgenmsg::new();
17055 header.cmd = 19u8;
17056 header.version = 1u8;
17057 prev.as_vec_mut().extend(header.as_slice());
17058 }
17059}
17060impl NetlinkRequest for OpSbPortPoolGetDo<'_> {
17061 fn protocol(&self) -> Protocol {
17062 Protocol::Generic("devlink".as_bytes())
17063 }
17064 fn flags(&self) -> u16 {
17065 self.request.flags
17066 }
17067 fn payload(&self) -> &[u8] {
17068 self.request.buf()
17069 }
17070 type ReplyType<'buf> = IterableDevlink<'buf>;
17071 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
17072 Self::decode_request(buf)
17073 }
17074 fn lookup(
17075 buf: &[u8],
17076 offset: usize,
17077 missing_type: Option<u16>,
17078 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
17079 Self::decode_request(buf).lookup_attr(offset, missing_type)
17080 }
17081}
17082#[doc = "Set shared buffer port-pool combinations and threshold.\n\nFlags: admin-perm\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_port_index()](PushDevlink::push_port_index)\n- [.push_sb_index()](PushDevlink::push_sb_index)\n- [.push_sb_pool_index()](PushDevlink::push_sb_pool_index)\n- [.push_sb_threshold()](PushDevlink::push_sb_threshold)\n- [.push_index()](PushDevlink::push_index)\n\n"]
17083#[derive(Debug)]
17084pub struct OpSbPortPoolSetDo<'r> {
17085 request: Request<'r>,
17086}
17087impl<'r> OpSbPortPoolSetDo<'r> {
17088 pub fn new(mut request: Request<'r>) -> Self {
17089 Self::write_header(request.buf_mut());
17090 Self { request: request }
17091 }
17092 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
17093 Self::write_header(buf);
17094 PushDevlink::new(buf)
17095 }
17096 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
17097 PushDevlink::new(self.request.buf_mut())
17098 }
17099 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
17100 PushDevlink::new(self.request.buf)
17101 }
17102 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
17103 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
17104 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
17105 }
17106 fn write_header<Prev: Pusher>(prev: &mut Prev) {
17107 let mut header = BuiltinNfgenmsg::new();
17108 header.cmd = 20u8;
17109 header.version = 1u8;
17110 prev.as_vec_mut().extend(header.as_slice());
17111 }
17112}
17113impl NetlinkRequest for OpSbPortPoolSetDo<'_> {
17114 fn protocol(&self) -> Protocol {
17115 Protocol::Generic("devlink".as_bytes())
17116 }
17117 fn flags(&self) -> u16 {
17118 self.request.flags
17119 }
17120 fn payload(&self) -> &[u8] {
17121 self.request.buf()
17122 }
17123 type ReplyType<'buf> = IterableDevlink<'buf>;
17124 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
17125 Self::decode_request(buf)
17126 }
17127 fn lookup(
17128 buf: &[u8],
17129 offset: usize,
17130 missing_type: Option<u16>,
17131 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
17132 Self::decode_request(buf).lookup_attr(offset, missing_type)
17133 }
17134}
17135#[doc = "Get shared buffer port-TC to pool bindings and threshold.\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_port_index()](IterableDevlink::get_port_index)\n- [.get_sb_index()](IterableDevlink::get_sb_index)\n- [.get_sb_pool_type()](IterableDevlink::get_sb_pool_type)\n- [.get_sb_tc_index()](IterableDevlink::get_sb_tc_index)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
17136#[derive(Debug)]
17137pub struct OpSbTcPoolBindGetDump<'r> {
17138 request: Request<'r>,
17139}
17140impl<'r> OpSbTcPoolBindGetDump<'r> {
17141 pub fn new(mut request: Request<'r>) -> Self {
17142 Self::write_header(request.buf_mut());
17143 Self {
17144 request: request.set_dump(),
17145 }
17146 }
17147 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
17148 Self::write_header(buf);
17149 PushDevlink::new(buf)
17150 }
17151 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
17152 PushDevlink::new(self.request.buf_mut())
17153 }
17154 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
17155 PushDevlink::new(self.request.buf)
17156 }
17157 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
17158 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
17159 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
17160 }
17161 fn write_header<Prev: Pusher>(prev: &mut Prev) {
17162 let mut header = BuiltinNfgenmsg::new();
17163 header.cmd = 23u8;
17164 header.version = 1u8;
17165 prev.as_vec_mut().extend(header.as_slice());
17166 }
17167}
17168impl NetlinkRequest for OpSbTcPoolBindGetDump<'_> {
17169 fn protocol(&self) -> Protocol {
17170 Protocol::Generic("devlink".as_bytes())
17171 }
17172 fn flags(&self) -> u16 {
17173 self.request.flags
17174 }
17175 fn payload(&self) -> &[u8] {
17176 self.request.buf()
17177 }
17178 type ReplyType<'buf> = IterableDevlink<'buf>;
17179 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
17180 Self::decode_request(buf)
17181 }
17182 fn lookup(
17183 buf: &[u8],
17184 offset: usize,
17185 missing_type: Option<u16>,
17186 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
17187 Self::decode_request(buf).lookup_attr(offset, missing_type)
17188 }
17189}
17190#[doc = "Get shared buffer port-TC to pool bindings and threshold.\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_port_index()](PushDevlink::push_port_index)\n- [.push_sb_index()](PushDevlink::push_sb_index)\n- [.push_sb_pool_type()](PushDevlink::push_sb_pool_type)\n- [.push_sb_tc_index()](PushDevlink::push_sb_tc_index)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_port_index()](IterableDevlink::get_port_index)\n- [.get_sb_index()](IterableDevlink::get_sb_index)\n- [.get_sb_pool_type()](IterableDevlink::get_sb_pool_type)\n- [.get_sb_tc_index()](IterableDevlink::get_sb_tc_index)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
17191#[derive(Debug)]
17192pub struct OpSbTcPoolBindGetDo<'r> {
17193 request: Request<'r>,
17194}
17195impl<'r> OpSbTcPoolBindGetDo<'r> {
17196 pub fn new(mut request: Request<'r>) -> Self {
17197 Self::write_header(request.buf_mut());
17198 Self { request: request }
17199 }
17200 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
17201 Self::write_header(buf);
17202 PushDevlink::new(buf)
17203 }
17204 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
17205 PushDevlink::new(self.request.buf_mut())
17206 }
17207 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
17208 PushDevlink::new(self.request.buf)
17209 }
17210 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
17211 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
17212 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
17213 }
17214 fn write_header<Prev: Pusher>(prev: &mut Prev) {
17215 let mut header = BuiltinNfgenmsg::new();
17216 header.cmd = 23u8;
17217 header.version = 1u8;
17218 prev.as_vec_mut().extend(header.as_slice());
17219 }
17220}
17221impl NetlinkRequest for OpSbTcPoolBindGetDo<'_> {
17222 fn protocol(&self) -> Protocol {
17223 Protocol::Generic("devlink".as_bytes())
17224 }
17225 fn flags(&self) -> u16 {
17226 self.request.flags
17227 }
17228 fn payload(&self) -> &[u8] {
17229 self.request.buf()
17230 }
17231 type ReplyType<'buf> = IterableDevlink<'buf>;
17232 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
17233 Self::decode_request(buf)
17234 }
17235 fn lookup(
17236 buf: &[u8],
17237 offset: usize,
17238 missing_type: Option<u16>,
17239 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
17240 Self::decode_request(buf).lookup_attr(offset, missing_type)
17241 }
17242}
17243#[doc = "Set shared buffer port-TC to pool bindings and threshold.\n\nFlags: admin-perm\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_port_index()](PushDevlink::push_port_index)\n- [.push_sb_index()](PushDevlink::push_sb_index)\n- [.push_sb_pool_index()](PushDevlink::push_sb_pool_index)\n- [.push_sb_pool_type()](PushDevlink::push_sb_pool_type)\n- [.push_sb_threshold()](PushDevlink::push_sb_threshold)\n- [.push_sb_tc_index()](PushDevlink::push_sb_tc_index)\n- [.push_index()](PushDevlink::push_index)\n\n"]
17244#[derive(Debug)]
17245pub struct OpSbTcPoolBindSetDo<'r> {
17246 request: Request<'r>,
17247}
17248impl<'r> OpSbTcPoolBindSetDo<'r> {
17249 pub fn new(mut request: Request<'r>) -> Self {
17250 Self::write_header(request.buf_mut());
17251 Self { request: request }
17252 }
17253 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
17254 Self::write_header(buf);
17255 PushDevlink::new(buf)
17256 }
17257 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
17258 PushDevlink::new(self.request.buf_mut())
17259 }
17260 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
17261 PushDevlink::new(self.request.buf)
17262 }
17263 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
17264 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
17265 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
17266 }
17267 fn write_header<Prev: Pusher>(prev: &mut Prev) {
17268 let mut header = BuiltinNfgenmsg::new();
17269 header.cmd = 24u8;
17270 header.version = 1u8;
17271 prev.as_vec_mut().extend(header.as_slice());
17272 }
17273}
17274impl NetlinkRequest for OpSbTcPoolBindSetDo<'_> {
17275 fn protocol(&self) -> Protocol {
17276 Protocol::Generic("devlink".as_bytes())
17277 }
17278 fn flags(&self) -> u16 {
17279 self.request.flags
17280 }
17281 fn payload(&self) -> &[u8] {
17282 self.request.buf()
17283 }
17284 type ReplyType<'buf> = IterableDevlink<'buf>;
17285 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
17286 Self::decode_request(buf)
17287 }
17288 fn lookup(
17289 buf: &[u8],
17290 offset: usize,
17291 missing_type: Option<u16>,
17292 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
17293 Self::decode_request(buf).lookup_attr(offset, missing_type)
17294 }
17295}
17296#[doc = "Take occupancy snapshot of shared buffer.\n\nFlags: admin-perm\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_sb_index()](PushDevlink::push_sb_index)\n- [.push_index()](PushDevlink::push_index)\n\n"]
17297#[derive(Debug)]
17298pub struct OpSbOccSnapshotDo<'r> {
17299 request: Request<'r>,
17300}
17301impl<'r> OpSbOccSnapshotDo<'r> {
17302 pub fn new(mut request: Request<'r>) -> Self {
17303 Self::write_header(request.buf_mut());
17304 Self { request: request }
17305 }
17306 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
17307 Self::write_header(buf);
17308 PushDevlink::new(buf)
17309 }
17310 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
17311 PushDevlink::new(self.request.buf_mut())
17312 }
17313 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
17314 PushDevlink::new(self.request.buf)
17315 }
17316 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
17317 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
17318 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
17319 }
17320 fn write_header<Prev: Pusher>(prev: &mut Prev) {
17321 let mut header = BuiltinNfgenmsg::new();
17322 header.cmd = 27u8;
17323 header.version = 1u8;
17324 prev.as_vec_mut().extend(header.as_slice());
17325 }
17326}
17327impl NetlinkRequest for OpSbOccSnapshotDo<'_> {
17328 fn protocol(&self) -> Protocol {
17329 Protocol::Generic("devlink".as_bytes())
17330 }
17331 fn flags(&self) -> u16 {
17332 self.request.flags
17333 }
17334 fn payload(&self) -> &[u8] {
17335 self.request.buf()
17336 }
17337 type ReplyType<'buf> = IterableDevlink<'buf>;
17338 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
17339 Self::decode_request(buf)
17340 }
17341 fn lookup(
17342 buf: &[u8],
17343 offset: usize,
17344 missing_type: Option<u16>,
17345 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
17346 Self::decode_request(buf).lookup_attr(offset, missing_type)
17347 }
17348}
17349#[doc = "Clear occupancy watermarks of shared buffer.\n\nFlags: admin-perm\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_sb_index()](PushDevlink::push_sb_index)\n- [.push_index()](PushDevlink::push_index)\n\n"]
17350#[derive(Debug)]
17351pub struct OpSbOccMaxClearDo<'r> {
17352 request: Request<'r>,
17353}
17354impl<'r> OpSbOccMaxClearDo<'r> {
17355 pub fn new(mut request: Request<'r>) -> Self {
17356 Self::write_header(request.buf_mut());
17357 Self { request: request }
17358 }
17359 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
17360 Self::write_header(buf);
17361 PushDevlink::new(buf)
17362 }
17363 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
17364 PushDevlink::new(self.request.buf_mut())
17365 }
17366 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
17367 PushDevlink::new(self.request.buf)
17368 }
17369 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
17370 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
17371 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
17372 }
17373 fn write_header<Prev: Pusher>(prev: &mut Prev) {
17374 let mut header = BuiltinNfgenmsg::new();
17375 header.cmd = 28u8;
17376 header.version = 1u8;
17377 prev.as_vec_mut().extend(header.as_slice());
17378 }
17379}
17380impl NetlinkRequest for OpSbOccMaxClearDo<'_> {
17381 fn protocol(&self) -> Protocol {
17382 Protocol::Generic("devlink".as_bytes())
17383 }
17384 fn flags(&self) -> u16 {
17385 self.request.flags
17386 }
17387 fn payload(&self) -> &[u8] {
17388 self.request.buf()
17389 }
17390 type ReplyType<'buf> = IterableDevlink<'buf>;
17391 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
17392 Self::decode_request(buf)
17393 }
17394 fn lookup(
17395 buf: &[u8],
17396 offset: usize,
17397 missing_type: Option<u16>,
17398 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
17399 Self::decode_request(buf).lookup_attr(offset, missing_type)
17400 }
17401}
17402#[doc = "Get eswitch attributes.\n\nFlags: admin-perm\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_eswitch_mode()](IterableDevlink::get_eswitch_mode)\n- [.get_eswitch_inline_mode()](IterableDevlink::get_eswitch_inline_mode)\n- [.get_eswitch_encap_mode()](IterableDevlink::get_eswitch_encap_mode)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
17403#[derive(Debug)]
17404pub struct OpEswitchGetDo<'r> {
17405 request: Request<'r>,
17406}
17407impl<'r> OpEswitchGetDo<'r> {
17408 pub fn new(mut request: Request<'r>) -> Self {
17409 Self::write_header(request.buf_mut());
17410 Self { request: request }
17411 }
17412 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
17413 Self::write_header(buf);
17414 PushDevlink::new(buf)
17415 }
17416 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
17417 PushDevlink::new(self.request.buf_mut())
17418 }
17419 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
17420 PushDevlink::new(self.request.buf)
17421 }
17422 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
17423 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
17424 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
17425 }
17426 fn write_header<Prev: Pusher>(prev: &mut Prev) {
17427 let mut header = BuiltinNfgenmsg::new();
17428 header.cmd = 29u8;
17429 header.version = 1u8;
17430 prev.as_vec_mut().extend(header.as_slice());
17431 }
17432}
17433impl NetlinkRequest for OpEswitchGetDo<'_> {
17434 fn protocol(&self) -> Protocol {
17435 Protocol::Generic("devlink".as_bytes())
17436 }
17437 fn flags(&self) -> u16 {
17438 self.request.flags
17439 }
17440 fn payload(&self) -> &[u8] {
17441 self.request.buf()
17442 }
17443 type ReplyType<'buf> = IterableDevlink<'buf>;
17444 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
17445 Self::decode_request(buf)
17446 }
17447 fn lookup(
17448 buf: &[u8],
17449 offset: usize,
17450 missing_type: Option<u16>,
17451 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
17452 Self::decode_request(buf).lookup_attr(offset, missing_type)
17453 }
17454}
17455#[doc = "Set eswitch attributes.\n\nFlags: admin-perm\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_eswitch_mode()](PushDevlink::push_eswitch_mode)\n- [.push_eswitch_inline_mode()](PushDevlink::push_eswitch_inline_mode)\n- [.push_eswitch_encap_mode()](PushDevlink::push_eswitch_encap_mode)\n- [.push_index()](PushDevlink::push_index)\n\n"]
17456#[derive(Debug)]
17457pub struct OpEswitchSetDo<'r> {
17458 request: Request<'r>,
17459}
17460impl<'r> OpEswitchSetDo<'r> {
17461 pub fn new(mut request: Request<'r>) -> Self {
17462 Self::write_header(request.buf_mut());
17463 Self { request: request }
17464 }
17465 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
17466 Self::write_header(buf);
17467 PushDevlink::new(buf)
17468 }
17469 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
17470 PushDevlink::new(self.request.buf_mut())
17471 }
17472 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
17473 PushDevlink::new(self.request.buf)
17474 }
17475 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
17476 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
17477 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
17478 }
17479 fn write_header<Prev: Pusher>(prev: &mut Prev) {
17480 let mut header = BuiltinNfgenmsg::new();
17481 header.cmd = 30u8;
17482 header.version = 1u8;
17483 prev.as_vec_mut().extend(header.as_slice());
17484 }
17485}
17486impl NetlinkRequest for OpEswitchSetDo<'_> {
17487 fn protocol(&self) -> Protocol {
17488 Protocol::Generic("devlink".as_bytes())
17489 }
17490 fn flags(&self) -> u16 {
17491 self.request.flags
17492 }
17493 fn payload(&self) -> &[u8] {
17494 self.request.buf()
17495 }
17496 type ReplyType<'buf> = IterableDevlink<'buf>;
17497 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
17498 Self::decode_request(buf)
17499 }
17500 fn lookup(
17501 buf: &[u8],
17502 offset: usize,
17503 missing_type: Option<u16>,
17504 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
17505 Self::decode_request(buf).lookup_attr(offset, missing_type)
17506 }
17507}
17508#[doc = "Get dpipe table attributes.\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_dpipe_table_name()](PushDevlink::push_dpipe_table_name)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_dpipe_tables()](IterableDevlink::get_dpipe_tables)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
17509#[derive(Debug)]
17510pub struct OpDpipeTableGetDo<'r> {
17511 request: Request<'r>,
17512}
17513impl<'r> OpDpipeTableGetDo<'r> {
17514 pub fn new(mut request: Request<'r>) -> Self {
17515 Self::write_header(request.buf_mut());
17516 Self { request: request }
17517 }
17518 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
17519 Self::write_header(buf);
17520 PushDevlink::new(buf)
17521 }
17522 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
17523 PushDevlink::new(self.request.buf_mut())
17524 }
17525 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
17526 PushDevlink::new(self.request.buf)
17527 }
17528 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
17529 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
17530 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
17531 }
17532 fn write_header<Prev: Pusher>(prev: &mut Prev) {
17533 let mut header = BuiltinNfgenmsg::new();
17534 header.cmd = 31u8;
17535 header.version = 1u8;
17536 prev.as_vec_mut().extend(header.as_slice());
17537 }
17538}
17539impl NetlinkRequest for OpDpipeTableGetDo<'_> {
17540 fn protocol(&self) -> Protocol {
17541 Protocol::Generic("devlink".as_bytes())
17542 }
17543 fn flags(&self) -> u16 {
17544 self.request.flags
17545 }
17546 fn payload(&self) -> &[u8] {
17547 self.request.buf()
17548 }
17549 type ReplyType<'buf> = IterableDevlink<'buf>;
17550 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
17551 Self::decode_request(buf)
17552 }
17553 fn lookup(
17554 buf: &[u8],
17555 offset: usize,
17556 missing_type: Option<u16>,
17557 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
17558 Self::decode_request(buf).lookup_attr(offset, missing_type)
17559 }
17560}
17561#[doc = "Get dpipe entries attributes.\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_dpipe_table_name()](PushDevlink::push_dpipe_table_name)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_dpipe_entries()](IterableDevlink::get_dpipe_entries)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
17562#[derive(Debug)]
17563pub struct OpDpipeEntriesGetDo<'r> {
17564 request: Request<'r>,
17565}
17566impl<'r> OpDpipeEntriesGetDo<'r> {
17567 pub fn new(mut request: Request<'r>) -> Self {
17568 Self::write_header(request.buf_mut());
17569 Self { request: request }
17570 }
17571 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
17572 Self::write_header(buf);
17573 PushDevlink::new(buf)
17574 }
17575 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
17576 PushDevlink::new(self.request.buf_mut())
17577 }
17578 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
17579 PushDevlink::new(self.request.buf)
17580 }
17581 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
17582 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
17583 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
17584 }
17585 fn write_header<Prev: Pusher>(prev: &mut Prev) {
17586 let mut header = BuiltinNfgenmsg::new();
17587 header.cmd = 32u8;
17588 header.version = 1u8;
17589 prev.as_vec_mut().extend(header.as_slice());
17590 }
17591}
17592impl NetlinkRequest for OpDpipeEntriesGetDo<'_> {
17593 fn protocol(&self) -> Protocol {
17594 Protocol::Generic("devlink".as_bytes())
17595 }
17596 fn flags(&self) -> u16 {
17597 self.request.flags
17598 }
17599 fn payload(&self) -> &[u8] {
17600 self.request.buf()
17601 }
17602 type ReplyType<'buf> = IterableDevlink<'buf>;
17603 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
17604 Self::decode_request(buf)
17605 }
17606 fn lookup(
17607 buf: &[u8],
17608 offset: usize,
17609 missing_type: Option<u16>,
17610 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
17611 Self::decode_request(buf).lookup_attr(offset, missing_type)
17612 }
17613}
17614#[doc = "Get dpipe headers attributes.\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_dpipe_headers()](IterableDevlink::get_dpipe_headers)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
17615#[derive(Debug)]
17616pub struct OpDpipeHeadersGetDo<'r> {
17617 request: Request<'r>,
17618}
17619impl<'r> OpDpipeHeadersGetDo<'r> {
17620 pub fn new(mut request: Request<'r>) -> Self {
17621 Self::write_header(request.buf_mut());
17622 Self { request: request }
17623 }
17624 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
17625 Self::write_header(buf);
17626 PushDevlink::new(buf)
17627 }
17628 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
17629 PushDevlink::new(self.request.buf_mut())
17630 }
17631 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
17632 PushDevlink::new(self.request.buf)
17633 }
17634 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
17635 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
17636 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
17637 }
17638 fn write_header<Prev: Pusher>(prev: &mut Prev) {
17639 let mut header = BuiltinNfgenmsg::new();
17640 header.cmd = 33u8;
17641 header.version = 1u8;
17642 prev.as_vec_mut().extend(header.as_slice());
17643 }
17644}
17645impl NetlinkRequest for OpDpipeHeadersGetDo<'_> {
17646 fn protocol(&self) -> Protocol {
17647 Protocol::Generic("devlink".as_bytes())
17648 }
17649 fn flags(&self) -> u16 {
17650 self.request.flags
17651 }
17652 fn payload(&self) -> &[u8] {
17653 self.request.buf()
17654 }
17655 type ReplyType<'buf> = IterableDevlink<'buf>;
17656 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
17657 Self::decode_request(buf)
17658 }
17659 fn lookup(
17660 buf: &[u8],
17661 offset: usize,
17662 missing_type: Option<u16>,
17663 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
17664 Self::decode_request(buf).lookup_attr(offset, missing_type)
17665 }
17666}
17667#[doc = "Set dpipe counter attributes.\n\nFlags: admin-perm\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_dpipe_table_name()](PushDevlink::push_dpipe_table_name)\n- [.push_dpipe_table_counters_enabled()](PushDevlink::push_dpipe_table_counters_enabled)\n- [.push_index()](PushDevlink::push_index)\n\n"]
17668#[derive(Debug)]
17669pub struct OpDpipeTableCountersSetDo<'r> {
17670 request: Request<'r>,
17671}
17672impl<'r> OpDpipeTableCountersSetDo<'r> {
17673 pub fn new(mut request: Request<'r>) -> Self {
17674 Self::write_header(request.buf_mut());
17675 Self { request: request }
17676 }
17677 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
17678 Self::write_header(buf);
17679 PushDevlink::new(buf)
17680 }
17681 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
17682 PushDevlink::new(self.request.buf_mut())
17683 }
17684 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
17685 PushDevlink::new(self.request.buf)
17686 }
17687 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
17688 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
17689 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
17690 }
17691 fn write_header<Prev: Pusher>(prev: &mut Prev) {
17692 let mut header = BuiltinNfgenmsg::new();
17693 header.cmd = 34u8;
17694 header.version = 1u8;
17695 prev.as_vec_mut().extend(header.as_slice());
17696 }
17697}
17698impl NetlinkRequest for OpDpipeTableCountersSetDo<'_> {
17699 fn protocol(&self) -> Protocol {
17700 Protocol::Generic("devlink".as_bytes())
17701 }
17702 fn flags(&self) -> u16 {
17703 self.request.flags
17704 }
17705 fn payload(&self) -> &[u8] {
17706 self.request.buf()
17707 }
17708 type ReplyType<'buf> = IterableDevlink<'buf>;
17709 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
17710 Self::decode_request(buf)
17711 }
17712 fn lookup(
17713 buf: &[u8],
17714 offset: usize,
17715 missing_type: Option<u16>,
17716 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
17717 Self::decode_request(buf).lookup_attr(offset, missing_type)
17718 }
17719}
17720#[doc = "Set resource attributes.\n\nFlags: admin-perm\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_resource_id()](PushDevlink::push_resource_id)\n- [.push_resource_size()](PushDevlink::push_resource_size)\n- [.push_index()](PushDevlink::push_index)\n\n"]
17721#[derive(Debug)]
17722pub struct OpResourceSetDo<'r> {
17723 request: Request<'r>,
17724}
17725impl<'r> OpResourceSetDo<'r> {
17726 pub fn new(mut request: Request<'r>) -> Self {
17727 Self::write_header(request.buf_mut());
17728 Self { request: request }
17729 }
17730 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
17731 Self::write_header(buf);
17732 PushDevlink::new(buf)
17733 }
17734 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
17735 PushDevlink::new(self.request.buf_mut())
17736 }
17737 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
17738 PushDevlink::new(self.request.buf)
17739 }
17740 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
17741 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
17742 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
17743 }
17744 fn write_header<Prev: Pusher>(prev: &mut Prev) {
17745 let mut header = BuiltinNfgenmsg::new();
17746 header.cmd = 35u8;
17747 header.version = 1u8;
17748 prev.as_vec_mut().extend(header.as_slice());
17749 }
17750}
17751impl NetlinkRequest for OpResourceSetDo<'_> {
17752 fn protocol(&self) -> Protocol {
17753 Protocol::Generic("devlink".as_bytes())
17754 }
17755 fn flags(&self) -> u16 {
17756 self.request.flags
17757 }
17758 fn payload(&self) -> &[u8] {
17759 self.request.buf()
17760 }
17761 type ReplyType<'buf> = IterableDevlink<'buf>;
17762 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
17763 Self::decode_request(buf)
17764 }
17765 fn lookup(
17766 buf: &[u8],
17767 offset: usize,
17768 missing_type: Option<u16>,
17769 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
17770 Self::decode_request(buf).lookup_attr(offset, missing_type)
17771 }
17772}
17773#[doc = "Get resource attributes.\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_index()](PushDevlink::push_index)\n- [.push_resource_scope_mask()](PushDevlink::push_resource_scope_mask)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_port_index()](IterableDevlink::get_port_index)\n- [.get_resource_list()](IterableDevlink::get_resource_list)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
17774#[derive(Debug)]
17775pub struct OpResourceDumpDump<'r> {
17776 request: Request<'r>,
17777}
17778impl<'r> OpResourceDumpDump<'r> {
17779 pub fn new(mut request: Request<'r>) -> Self {
17780 Self::write_header(request.buf_mut());
17781 Self {
17782 request: request.set_dump(),
17783 }
17784 }
17785 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
17786 Self::write_header(buf);
17787 PushDevlink::new(buf)
17788 }
17789 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
17790 PushDevlink::new(self.request.buf_mut())
17791 }
17792 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
17793 PushDevlink::new(self.request.buf)
17794 }
17795 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
17796 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
17797 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
17798 }
17799 fn write_header<Prev: Pusher>(prev: &mut Prev) {
17800 let mut header = BuiltinNfgenmsg::new();
17801 header.cmd = 36u8;
17802 header.version = 1u8;
17803 prev.as_vec_mut().extend(header.as_slice());
17804 }
17805}
17806impl NetlinkRequest for OpResourceDumpDump<'_> {
17807 fn protocol(&self) -> Protocol {
17808 Protocol::Generic("devlink".as_bytes())
17809 }
17810 fn flags(&self) -> u16 {
17811 self.request.flags
17812 }
17813 fn payload(&self) -> &[u8] {
17814 self.request.buf()
17815 }
17816 type ReplyType<'buf> = IterableDevlink<'buf>;
17817 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
17818 Self::decode_request(buf)
17819 }
17820 fn lookup(
17821 buf: &[u8],
17822 offset: usize,
17823 missing_type: Option<u16>,
17824 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
17825 Self::decode_request(buf).lookup_attr(offset, missing_type)
17826 }
17827}
17828#[doc = "Get resource attributes.\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_port_index()](PushDevlink::push_port_index)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_port_index()](IterableDevlink::get_port_index)\n- [.get_resource_list()](IterableDevlink::get_resource_list)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
17829#[derive(Debug)]
17830pub struct OpResourceDumpDo<'r> {
17831 request: Request<'r>,
17832}
17833impl<'r> OpResourceDumpDo<'r> {
17834 pub fn new(mut request: Request<'r>) -> Self {
17835 Self::write_header(request.buf_mut());
17836 Self { request: request }
17837 }
17838 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
17839 Self::write_header(buf);
17840 PushDevlink::new(buf)
17841 }
17842 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
17843 PushDevlink::new(self.request.buf_mut())
17844 }
17845 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
17846 PushDevlink::new(self.request.buf)
17847 }
17848 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
17849 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
17850 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
17851 }
17852 fn write_header<Prev: Pusher>(prev: &mut Prev) {
17853 let mut header = BuiltinNfgenmsg::new();
17854 header.cmd = 36u8;
17855 header.version = 1u8;
17856 prev.as_vec_mut().extend(header.as_slice());
17857 }
17858}
17859impl NetlinkRequest for OpResourceDumpDo<'_> {
17860 fn protocol(&self) -> Protocol {
17861 Protocol::Generic("devlink".as_bytes())
17862 }
17863 fn flags(&self) -> u16 {
17864 self.request.flags
17865 }
17866 fn payload(&self) -> &[u8] {
17867 self.request.buf()
17868 }
17869 type ReplyType<'buf> = IterableDevlink<'buf>;
17870 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
17871 Self::decode_request(buf)
17872 }
17873 fn lookup(
17874 buf: &[u8],
17875 offset: usize,
17876 missing_type: Option<u16>,
17877 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
17878 Self::decode_request(buf).lookup_attr(offset, missing_type)
17879 }
17880}
17881#[doc = "Reload devlink.\n\nFlags: admin-perm\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_netns_fd()](PushDevlink::push_netns_fd)\n- [.push_netns_pid()](PushDevlink::push_netns_pid)\n- [.push_netns_id()](PushDevlink::push_netns_id)\n- [.push_reload_action()](PushDevlink::push_reload_action)\n- [.push_reload_limits()](PushDevlink::push_reload_limits)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_reload_actions_performed()](IterableDevlink::get_reload_actions_performed)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
17882#[derive(Debug)]
17883pub struct OpReloadDo<'r> {
17884 request: Request<'r>,
17885}
17886impl<'r> OpReloadDo<'r> {
17887 pub fn new(mut request: Request<'r>) -> Self {
17888 Self::write_header(request.buf_mut());
17889 Self { request: request }
17890 }
17891 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
17892 Self::write_header(buf);
17893 PushDevlink::new(buf)
17894 }
17895 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
17896 PushDevlink::new(self.request.buf_mut())
17897 }
17898 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
17899 PushDevlink::new(self.request.buf)
17900 }
17901 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
17902 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
17903 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
17904 }
17905 fn write_header<Prev: Pusher>(prev: &mut Prev) {
17906 let mut header = BuiltinNfgenmsg::new();
17907 header.cmd = 37u8;
17908 header.version = 1u8;
17909 prev.as_vec_mut().extend(header.as_slice());
17910 }
17911}
17912impl NetlinkRequest for OpReloadDo<'_> {
17913 fn protocol(&self) -> Protocol {
17914 Protocol::Generic("devlink".as_bytes())
17915 }
17916 fn flags(&self) -> u16 {
17917 self.request.flags
17918 }
17919 fn payload(&self) -> &[u8] {
17920 self.request.buf()
17921 }
17922 type ReplyType<'buf> = IterableDevlink<'buf>;
17923 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
17924 Self::decode_request(buf)
17925 }
17926 fn lookup(
17927 buf: &[u8],
17928 offset: usize,
17929 missing_type: Option<u16>,
17930 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
17931 Self::decode_request(buf).lookup_attr(offset, missing_type)
17932 }
17933}
17934#[doc = "Get param instances.\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_param_name()](IterableDevlink::get_param_name)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
17935#[derive(Debug)]
17936pub struct OpParamGetDump<'r> {
17937 request: Request<'r>,
17938}
17939impl<'r> OpParamGetDump<'r> {
17940 pub fn new(mut request: Request<'r>) -> Self {
17941 Self::write_header(request.buf_mut());
17942 Self {
17943 request: request.set_dump(),
17944 }
17945 }
17946 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
17947 Self::write_header(buf);
17948 PushDevlink::new(buf)
17949 }
17950 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
17951 PushDevlink::new(self.request.buf_mut())
17952 }
17953 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
17954 PushDevlink::new(self.request.buf)
17955 }
17956 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
17957 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
17958 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
17959 }
17960 fn write_header<Prev: Pusher>(prev: &mut Prev) {
17961 let mut header = BuiltinNfgenmsg::new();
17962 header.cmd = 38u8;
17963 header.version = 1u8;
17964 prev.as_vec_mut().extend(header.as_slice());
17965 }
17966}
17967impl NetlinkRequest for OpParamGetDump<'_> {
17968 fn protocol(&self) -> Protocol {
17969 Protocol::Generic("devlink".as_bytes())
17970 }
17971 fn flags(&self) -> u16 {
17972 self.request.flags
17973 }
17974 fn payload(&self) -> &[u8] {
17975 self.request.buf()
17976 }
17977 type ReplyType<'buf> = IterableDevlink<'buf>;
17978 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
17979 Self::decode_request(buf)
17980 }
17981 fn lookup(
17982 buf: &[u8],
17983 offset: usize,
17984 missing_type: Option<u16>,
17985 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
17986 Self::decode_request(buf).lookup_attr(offset, missing_type)
17987 }
17988}
17989#[doc = "Get param instances.\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_param_name()](PushDevlink::push_param_name)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_param_name()](IterableDevlink::get_param_name)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
17990#[derive(Debug)]
17991pub struct OpParamGetDo<'r> {
17992 request: Request<'r>,
17993}
17994impl<'r> OpParamGetDo<'r> {
17995 pub fn new(mut request: Request<'r>) -> Self {
17996 Self::write_header(request.buf_mut());
17997 Self { request: request }
17998 }
17999 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
18000 Self::write_header(buf);
18001 PushDevlink::new(buf)
18002 }
18003 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
18004 PushDevlink::new(self.request.buf_mut())
18005 }
18006 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
18007 PushDevlink::new(self.request.buf)
18008 }
18009 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
18010 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
18011 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
18012 }
18013 fn write_header<Prev: Pusher>(prev: &mut Prev) {
18014 let mut header = BuiltinNfgenmsg::new();
18015 header.cmd = 38u8;
18016 header.version = 1u8;
18017 prev.as_vec_mut().extend(header.as_slice());
18018 }
18019}
18020impl NetlinkRequest for OpParamGetDo<'_> {
18021 fn protocol(&self) -> Protocol {
18022 Protocol::Generic("devlink".as_bytes())
18023 }
18024 fn flags(&self) -> u16 {
18025 self.request.flags
18026 }
18027 fn payload(&self) -> &[u8] {
18028 self.request.buf()
18029 }
18030 type ReplyType<'buf> = IterableDevlink<'buf>;
18031 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
18032 Self::decode_request(buf)
18033 }
18034 fn lookup(
18035 buf: &[u8],
18036 offset: usize,
18037 missing_type: Option<u16>,
18038 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
18039 Self::decode_request(buf).lookup_attr(offset, missing_type)
18040 }
18041}
18042#[doc = "Set param instances.\n\nFlags: admin-perm\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_param_name()](PushDevlink::push_param_name)\n- [.push_param_type()](PushDevlink::push_param_type)\n- [.push_param_value_cmode()](PushDevlink::push_param_value_cmode)\n- [.push_param_reset_default()](PushDevlink::push_param_reset_default)\n- [.push_index()](PushDevlink::push_index)\n\n"]
18043#[derive(Debug)]
18044pub struct OpParamSetDo<'r> {
18045 request: Request<'r>,
18046}
18047impl<'r> OpParamSetDo<'r> {
18048 pub fn new(mut request: Request<'r>) -> Self {
18049 Self::write_header(request.buf_mut());
18050 Self { request: request }
18051 }
18052 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
18053 Self::write_header(buf);
18054 PushDevlink::new(buf)
18055 }
18056 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
18057 PushDevlink::new(self.request.buf_mut())
18058 }
18059 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
18060 PushDevlink::new(self.request.buf)
18061 }
18062 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
18063 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
18064 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
18065 }
18066 fn write_header<Prev: Pusher>(prev: &mut Prev) {
18067 let mut header = BuiltinNfgenmsg::new();
18068 header.cmd = 39u8;
18069 header.version = 1u8;
18070 prev.as_vec_mut().extend(header.as_slice());
18071 }
18072}
18073impl NetlinkRequest for OpParamSetDo<'_> {
18074 fn protocol(&self) -> Protocol {
18075 Protocol::Generic("devlink".as_bytes())
18076 }
18077 fn flags(&self) -> u16 {
18078 self.request.flags
18079 }
18080 fn payload(&self) -> &[u8] {
18081 self.request.buf()
18082 }
18083 type ReplyType<'buf> = IterableDevlink<'buf>;
18084 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
18085 Self::decode_request(buf)
18086 }
18087 fn lookup(
18088 buf: &[u8],
18089 offset: usize,
18090 missing_type: Option<u16>,
18091 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
18092 Self::decode_request(buf).lookup_attr(offset, missing_type)
18093 }
18094}
18095#[doc = "Get region instances.\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_port_index()](IterableDevlink::get_port_index)\n- [.get_region_name()](IterableDevlink::get_region_name)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
18096#[derive(Debug)]
18097pub struct OpRegionGetDump<'r> {
18098 request: Request<'r>,
18099}
18100impl<'r> OpRegionGetDump<'r> {
18101 pub fn new(mut request: Request<'r>) -> Self {
18102 Self::write_header(request.buf_mut());
18103 Self {
18104 request: request.set_dump(),
18105 }
18106 }
18107 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
18108 Self::write_header(buf);
18109 PushDevlink::new(buf)
18110 }
18111 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
18112 PushDevlink::new(self.request.buf_mut())
18113 }
18114 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
18115 PushDevlink::new(self.request.buf)
18116 }
18117 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
18118 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
18119 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
18120 }
18121 fn write_header<Prev: Pusher>(prev: &mut Prev) {
18122 let mut header = BuiltinNfgenmsg::new();
18123 header.cmd = 42u8;
18124 header.version = 1u8;
18125 prev.as_vec_mut().extend(header.as_slice());
18126 }
18127}
18128impl NetlinkRequest for OpRegionGetDump<'_> {
18129 fn protocol(&self) -> Protocol {
18130 Protocol::Generic("devlink".as_bytes())
18131 }
18132 fn flags(&self) -> u16 {
18133 self.request.flags
18134 }
18135 fn payload(&self) -> &[u8] {
18136 self.request.buf()
18137 }
18138 type ReplyType<'buf> = IterableDevlink<'buf>;
18139 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
18140 Self::decode_request(buf)
18141 }
18142 fn lookup(
18143 buf: &[u8],
18144 offset: usize,
18145 missing_type: Option<u16>,
18146 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
18147 Self::decode_request(buf).lookup_attr(offset, missing_type)
18148 }
18149}
18150#[doc = "Get region instances.\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_port_index()](PushDevlink::push_port_index)\n- [.push_region_name()](PushDevlink::push_region_name)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_port_index()](IterableDevlink::get_port_index)\n- [.get_region_name()](IterableDevlink::get_region_name)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
18151#[derive(Debug)]
18152pub struct OpRegionGetDo<'r> {
18153 request: Request<'r>,
18154}
18155impl<'r> OpRegionGetDo<'r> {
18156 pub fn new(mut request: Request<'r>) -> Self {
18157 Self::write_header(request.buf_mut());
18158 Self { request: request }
18159 }
18160 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
18161 Self::write_header(buf);
18162 PushDevlink::new(buf)
18163 }
18164 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
18165 PushDevlink::new(self.request.buf_mut())
18166 }
18167 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
18168 PushDevlink::new(self.request.buf)
18169 }
18170 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
18171 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
18172 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
18173 }
18174 fn write_header<Prev: Pusher>(prev: &mut Prev) {
18175 let mut header = BuiltinNfgenmsg::new();
18176 header.cmd = 42u8;
18177 header.version = 1u8;
18178 prev.as_vec_mut().extend(header.as_slice());
18179 }
18180}
18181impl NetlinkRequest for OpRegionGetDo<'_> {
18182 fn protocol(&self) -> Protocol {
18183 Protocol::Generic("devlink".as_bytes())
18184 }
18185 fn flags(&self) -> u16 {
18186 self.request.flags
18187 }
18188 fn payload(&self) -> &[u8] {
18189 self.request.buf()
18190 }
18191 type ReplyType<'buf> = IterableDevlink<'buf>;
18192 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
18193 Self::decode_request(buf)
18194 }
18195 fn lookup(
18196 buf: &[u8],
18197 offset: usize,
18198 missing_type: Option<u16>,
18199 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
18200 Self::decode_request(buf).lookup_attr(offset, missing_type)
18201 }
18202}
18203#[doc = "Create region snapshot.\n\nFlags: admin-perm\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_port_index()](PushDevlink::push_port_index)\n- [.push_region_name()](PushDevlink::push_region_name)\n- [.push_region_snapshot_id()](PushDevlink::push_region_snapshot_id)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_port_index()](IterableDevlink::get_port_index)\n- [.get_region_name()](IterableDevlink::get_region_name)\n- [.get_region_snapshot_id()](IterableDevlink::get_region_snapshot_id)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
18204#[derive(Debug)]
18205pub struct OpRegionNewDo<'r> {
18206 request: Request<'r>,
18207}
18208impl<'r> OpRegionNewDo<'r> {
18209 pub fn new(mut request: Request<'r>) -> Self {
18210 Self::write_header(request.buf_mut());
18211 Self { request: request }
18212 }
18213 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
18214 Self::write_header(buf);
18215 PushDevlink::new(buf)
18216 }
18217 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
18218 PushDevlink::new(self.request.buf_mut())
18219 }
18220 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
18221 PushDevlink::new(self.request.buf)
18222 }
18223 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
18224 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
18225 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
18226 }
18227 fn write_header<Prev: Pusher>(prev: &mut Prev) {
18228 let mut header = BuiltinNfgenmsg::new();
18229 header.cmd = 44u8;
18230 header.version = 1u8;
18231 prev.as_vec_mut().extend(header.as_slice());
18232 }
18233}
18234impl NetlinkRequest for OpRegionNewDo<'_> {
18235 fn protocol(&self) -> Protocol {
18236 Protocol::Generic("devlink".as_bytes())
18237 }
18238 fn flags(&self) -> u16 {
18239 self.request.flags
18240 }
18241 fn payload(&self) -> &[u8] {
18242 self.request.buf()
18243 }
18244 type ReplyType<'buf> = IterableDevlink<'buf>;
18245 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
18246 Self::decode_request(buf)
18247 }
18248 fn lookup(
18249 buf: &[u8],
18250 offset: usize,
18251 missing_type: Option<u16>,
18252 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
18253 Self::decode_request(buf).lookup_attr(offset, missing_type)
18254 }
18255}
18256#[doc = "Delete region snapshot.\n\nFlags: admin-perm\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_port_index()](PushDevlink::push_port_index)\n- [.push_region_name()](PushDevlink::push_region_name)\n- [.push_region_snapshot_id()](PushDevlink::push_region_snapshot_id)\n- [.push_index()](PushDevlink::push_index)\n\n"]
18257#[derive(Debug)]
18258pub struct OpRegionDelDo<'r> {
18259 request: Request<'r>,
18260}
18261impl<'r> OpRegionDelDo<'r> {
18262 pub fn new(mut request: Request<'r>) -> Self {
18263 Self::write_header(request.buf_mut());
18264 Self { request: request }
18265 }
18266 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
18267 Self::write_header(buf);
18268 PushDevlink::new(buf)
18269 }
18270 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
18271 PushDevlink::new(self.request.buf_mut())
18272 }
18273 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
18274 PushDevlink::new(self.request.buf)
18275 }
18276 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
18277 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
18278 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
18279 }
18280 fn write_header<Prev: Pusher>(prev: &mut Prev) {
18281 let mut header = BuiltinNfgenmsg::new();
18282 header.cmd = 45u8;
18283 header.version = 1u8;
18284 prev.as_vec_mut().extend(header.as_slice());
18285 }
18286}
18287impl NetlinkRequest for OpRegionDelDo<'_> {
18288 fn protocol(&self) -> Protocol {
18289 Protocol::Generic("devlink".as_bytes())
18290 }
18291 fn flags(&self) -> u16 {
18292 self.request.flags
18293 }
18294 fn payload(&self) -> &[u8] {
18295 self.request.buf()
18296 }
18297 type ReplyType<'buf> = IterableDevlink<'buf>;
18298 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
18299 Self::decode_request(buf)
18300 }
18301 fn lookup(
18302 buf: &[u8],
18303 offset: usize,
18304 missing_type: Option<u16>,
18305 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
18306 Self::decode_request(buf).lookup_attr(offset, missing_type)
18307 }
18308}
18309#[doc = "Read region data.\n\nFlags: admin-perm\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_port_index()](PushDevlink::push_port_index)\n- [.push_region_name()](PushDevlink::push_region_name)\n- [.push_region_snapshot_id()](PushDevlink::push_region_snapshot_id)\n- [.push_region_chunk_addr()](PushDevlink::push_region_chunk_addr)\n- [.push_region_chunk_len()](PushDevlink::push_region_chunk_len)\n- [.push_region_direct()](PushDevlink::push_region_direct)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_port_index()](IterableDevlink::get_port_index)\n- [.get_region_name()](IterableDevlink::get_region_name)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
18310#[derive(Debug)]
18311pub struct OpRegionReadDump<'r> {
18312 request: Request<'r>,
18313}
18314impl<'r> OpRegionReadDump<'r> {
18315 pub fn new(mut request: Request<'r>) -> Self {
18316 Self::write_header(request.buf_mut());
18317 Self {
18318 request: request.set_dump(),
18319 }
18320 }
18321 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
18322 Self::write_header(buf);
18323 PushDevlink::new(buf)
18324 }
18325 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
18326 PushDevlink::new(self.request.buf_mut())
18327 }
18328 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
18329 PushDevlink::new(self.request.buf)
18330 }
18331 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
18332 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
18333 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
18334 }
18335 fn write_header<Prev: Pusher>(prev: &mut Prev) {
18336 let mut header = BuiltinNfgenmsg::new();
18337 header.cmd = 46u8;
18338 header.version = 1u8;
18339 prev.as_vec_mut().extend(header.as_slice());
18340 }
18341}
18342impl NetlinkRequest for OpRegionReadDump<'_> {
18343 fn protocol(&self) -> Protocol {
18344 Protocol::Generic("devlink".as_bytes())
18345 }
18346 fn flags(&self) -> u16 {
18347 self.request.flags
18348 }
18349 fn payload(&self) -> &[u8] {
18350 self.request.buf()
18351 }
18352 type ReplyType<'buf> = IterableDevlink<'buf>;
18353 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
18354 Self::decode_request(buf)
18355 }
18356 fn lookup(
18357 buf: &[u8],
18358 offset: usize,
18359 missing_type: Option<u16>,
18360 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
18361 Self::decode_request(buf).lookup_attr(offset, missing_type)
18362 }
18363}
18364#[doc = "Get port param instances.\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_port_index()](IterableDevlink::get_port_index)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
18365#[derive(Debug)]
18366pub struct OpPortParamGetDump<'r> {
18367 request: Request<'r>,
18368}
18369impl<'r> OpPortParamGetDump<'r> {
18370 pub fn new(mut request: Request<'r>) -> Self {
18371 Self::write_header(request.buf_mut());
18372 Self {
18373 request: request.set_dump(),
18374 }
18375 }
18376 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
18377 Self::write_header(buf);
18378 PushDevlink::new(buf)
18379 }
18380 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
18381 PushDevlink::new(self.request.buf_mut())
18382 }
18383 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
18384 PushDevlink::new(self.request.buf)
18385 }
18386 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
18387 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
18388 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
18389 }
18390 fn write_header<Prev: Pusher>(prev: &mut Prev) {
18391 let mut header = BuiltinNfgenmsg::new();
18392 header.cmd = 47u8;
18393 header.version = 1u8;
18394 prev.as_vec_mut().extend(header.as_slice());
18395 }
18396}
18397impl NetlinkRequest for OpPortParamGetDump<'_> {
18398 fn protocol(&self) -> Protocol {
18399 Protocol::Generic("devlink".as_bytes())
18400 }
18401 fn flags(&self) -> u16 {
18402 self.request.flags
18403 }
18404 fn payload(&self) -> &[u8] {
18405 self.request.buf()
18406 }
18407 type ReplyType<'buf> = IterableDevlink<'buf>;
18408 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
18409 Self::decode_request(buf)
18410 }
18411 fn lookup(
18412 buf: &[u8],
18413 offset: usize,
18414 missing_type: Option<u16>,
18415 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
18416 Self::decode_request(buf).lookup_attr(offset, missing_type)
18417 }
18418}
18419#[doc = "Get port param instances.\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_port_index()](PushDevlink::push_port_index)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_port_index()](IterableDevlink::get_port_index)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
18420#[derive(Debug)]
18421pub struct OpPortParamGetDo<'r> {
18422 request: Request<'r>,
18423}
18424impl<'r> OpPortParamGetDo<'r> {
18425 pub fn new(mut request: Request<'r>) -> Self {
18426 Self::write_header(request.buf_mut());
18427 Self { request: request }
18428 }
18429 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
18430 Self::write_header(buf);
18431 PushDevlink::new(buf)
18432 }
18433 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
18434 PushDevlink::new(self.request.buf_mut())
18435 }
18436 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
18437 PushDevlink::new(self.request.buf)
18438 }
18439 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
18440 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
18441 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
18442 }
18443 fn write_header<Prev: Pusher>(prev: &mut Prev) {
18444 let mut header = BuiltinNfgenmsg::new();
18445 header.cmd = 47u8;
18446 header.version = 1u8;
18447 prev.as_vec_mut().extend(header.as_slice());
18448 }
18449}
18450impl NetlinkRequest for OpPortParamGetDo<'_> {
18451 fn protocol(&self) -> Protocol {
18452 Protocol::Generic("devlink".as_bytes())
18453 }
18454 fn flags(&self) -> u16 {
18455 self.request.flags
18456 }
18457 fn payload(&self) -> &[u8] {
18458 self.request.buf()
18459 }
18460 type ReplyType<'buf> = IterableDevlink<'buf>;
18461 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
18462 Self::decode_request(buf)
18463 }
18464 fn lookup(
18465 buf: &[u8],
18466 offset: usize,
18467 missing_type: Option<u16>,
18468 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
18469 Self::decode_request(buf).lookup_attr(offset, missing_type)
18470 }
18471}
18472#[doc = "Set port param instances.\n\nFlags: admin-perm\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_port_index()](PushDevlink::push_port_index)\n- [.push_index()](PushDevlink::push_index)\n\n"]
18473#[derive(Debug)]
18474pub struct OpPortParamSetDo<'r> {
18475 request: Request<'r>,
18476}
18477impl<'r> OpPortParamSetDo<'r> {
18478 pub fn new(mut request: Request<'r>) -> Self {
18479 Self::write_header(request.buf_mut());
18480 Self { request: request }
18481 }
18482 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
18483 Self::write_header(buf);
18484 PushDevlink::new(buf)
18485 }
18486 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
18487 PushDevlink::new(self.request.buf_mut())
18488 }
18489 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
18490 PushDevlink::new(self.request.buf)
18491 }
18492 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
18493 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
18494 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
18495 }
18496 fn write_header<Prev: Pusher>(prev: &mut Prev) {
18497 let mut header = BuiltinNfgenmsg::new();
18498 header.cmd = 48u8;
18499 header.version = 1u8;
18500 prev.as_vec_mut().extend(header.as_slice());
18501 }
18502}
18503impl NetlinkRequest for OpPortParamSetDo<'_> {
18504 fn protocol(&self) -> Protocol {
18505 Protocol::Generic("devlink".as_bytes())
18506 }
18507 fn flags(&self) -> u16 {
18508 self.request.flags
18509 }
18510 fn payload(&self) -> &[u8] {
18511 self.request.buf()
18512 }
18513 type ReplyType<'buf> = IterableDevlink<'buf>;
18514 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
18515 Self::decode_request(buf)
18516 }
18517 fn lookup(
18518 buf: &[u8],
18519 offset: usize,
18520 missing_type: Option<u16>,
18521 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
18522 Self::decode_request(buf).lookup_attr(offset, missing_type)
18523 }
18524}
18525#[doc = "Get device information, like driver name, hardware and firmware versions\netc.\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_info_driver_name()](IterableDevlink::get_info_driver_name)\n- [.get_info_serial_number()](IterableDevlink::get_info_serial_number)\n- [.get_info_version_fixed()](IterableDevlink::get_info_version_fixed)\n- [.get_info_version_running()](IterableDevlink::get_info_version_running)\n- [.get_info_version_stored()](IterableDevlink::get_info_version_stored)\n- [.get_info_board_serial_number()](IterableDevlink::get_info_board_serial_number)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
18526#[derive(Debug)]
18527pub struct OpInfoGetDump<'r> {
18528 request: Request<'r>,
18529}
18530impl<'r> OpInfoGetDump<'r> {
18531 pub fn new(mut request: Request<'r>) -> Self {
18532 Self::write_header(request.buf_mut());
18533 Self {
18534 request: request.set_dump(),
18535 }
18536 }
18537 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
18538 Self::write_header(buf);
18539 PushDevlink::new(buf)
18540 }
18541 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
18542 PushDevlink::new(self.request.buf_mut())
18543 }
18544 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
18545 PushDevlink::new(self.request.buf)
18546 }
18547 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
18548 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
18549 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
18550 }
18551 fn write_header<Prev: Pusher>(prev: &mut Prev) {
18552 let mut header = BuiltinNfgenmsg::new();
18553 header.cmd = 51u8;
18554 header.version = 1u8;
18555 prev.as_vec_mut().extend(header.as_slice());
18556 }
18557}
18558impl NetlinkRequest for OpInfoGetDump<'_> {
18559 fn protocol(&self) -> Protocol {
18560 Protocol::Generic("devlink".as_bytes())
18561 }
18562 fn flags(&self) -> u16 {
18563 self.request.flags
18564 }
18565 fn payload(&self) -> &[u8] {
18566 self.request.buf()
18567 }
18568 type ReplyType<'buf> = IterableDevlink<'buf>;
18569 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
18570 Self::decode_request(buf)
18571 }
18572 fn lookup(
18573 buf: &[u8],
18574 offset: usize,
18575 missing_type: Option<u16>,
18576 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
18577 Self::decode_request(buf).lookup_attr(offset, missing_type)
18578 }
18579}
18580#[doc = "Get device information, like driver name, hardware and firmware versions\netc.\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_info_driver_name()](IterableDevlink::get_info_driver_name)\n- [.get_info_serial_number()](IterableDevlink::get_info_serial_number)\n- [.get_info_version_fixed()](IterableDevlink::get_info_version_fixed)\n- [.get_info_version_running()](IterableDevlink::get_info_version_running)\n- [.get_info_version_stored()](IterableDevlink::get_info_version_stored)\n- [.get_info_board_serial_number()](IterableDevlink::get_info_board_serial_number)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
18581#[derive(Debug)]
18582pub struct OpInfoGetDo<'r> {
18583 request: Request<'r>,
18584}
18585impl<'r> OpInfoGetDo<'r> {
18586 pub fn new(mut request: Request<'r>) -> Self {
18587 Self::write_header(request.buf_mut());
18588 Self { request: request }
18589 }
18590 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
18591 Self::write_header(buf);
18592 PushDevlink::new(buf)
18593 }
18594 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
18595 PushDevlink::new(self.request.buf_mut())
18596 }
18597 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
18598 PushDevlink::new(self.request.buf)
18599 }
18600 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
18601 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
18602 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
18603 }
18604 fn write_header<Prev: Pusher>(prev: &mut Prev) {
18605 let mut header = BuiltinNfgenmsg::new();
18606 header.cmd = 51u8;
18607 header.version = 1u8;
18608 prev.as_vec_mut().extend(header.as_slice());
18609 }
18610}
18611impl NetlinkRequest for OpInfoGetDo<'_> {
18612 fn protocol(&self) -> Protocol {
18613 Protocol::Generic("devlink".as_bytes())
18614 }
18615 fn flags(&self) -> u16 {
18616 self.request.flags
18617 }
18618 fn payload(&self) -> &[u8] {
18619 self.request.buf()
18620 }
18621 type ReplyType<'buf> = IterableDevlink<'buf>;
18622 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
18623 Self::decode_request(buf)
18624 }
18625 fn lookup(
18626 buf: &[u8],
18627 offset: usize,
18628 missing_type: Option<u16>,
18629 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
18630 Self::decode_request(buf).lookup_attr(offset, missing_type)
18631 }
18632}
18633#[doc = "Get health reporter instances.\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_port_index()](PushDevlink::push_port_index)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_port_index()](IterableDevlink::get_port_index)\n- [.get_health_reporter_name()](IterableDevlink::get_health_reporter_name)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
18634#[derive(Debug)]
18635pub struct OpHealthReporterGetDump<'r> {
18636 request: Request<'r>,
18637}
18638impl<'r> OpHealthReporterGetDump<'r> {
18639 pub fn new(mut request: Request<'r>) -> Self {
18640 Self::write_header(request.buf_mut());
18641 Self {
18642 request: request.set_dump(),
18643 }
18644 }
18645 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
18646 Self::write_header(buf);
18647 PushDevlink::new(buf)
18648 }
18649 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
18650 PushDevlink::new(self.request.buf_mut())
18651 }
18652 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
18653 PushDevlink::new(self.request.buf)
18654 }
18655 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
18656 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
18657 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
18658 }
18659 fn write_header<Prev: Pusher>(prev: &mut Prev) {
18660 let mut header = BuiltinNfgenmsg::new();
18661 header.cmd = 52u8;
18662 header.version = 1u8;
18663 prev.as_vec_mut().extend(header.as_slice());
18664 }
18665}
18666impl NetlinkRequest for OpHealthReporterGetDump<'_> {
18667 fn protocol(&self) -> Protocol {
18668 Protocol::Generic("devlink".as_bytes())
18669 }
18670 fn flags(&self) -> u16 {
18671 self.request.flags
18672 }
18673 fn payload(&self) -> &[u8] {
18674 self.request.buf()
18675 }
18676 type ReplyType<'buf> = IterableDevlink<'buf>;
18677 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
18678 Self::decode_request(buf)
18679 }
18680 fn lookup(
18681 buf: &[u8],
18682 offset: usize,
18683 missing_type: Option<u16>,
18684 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
18685 Self::decode_request(buf).lookup_attr(offset, missing_type)
18686 }
18687}
18688#[doc = "Get health reporter instances.\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_port_index()](PushDevlink::push_port_index)\n- [.push_health_reporter_name()](PushDevlink::push_health_reporter_name)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_port_index()](IterableDevlink::get_port_index)\n- [.get_health_reporter_name()](IterableDevlink::get_health_reporter_name)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
18689#[derive(Debug)]
18690pub struct OpHealthReporterGetDo<'r> {
18691 request: Request<'r>,
18692}
18693impl<'r> OpHealthReporterGetDo<'r> {
18694 pub fn new(mut request: Request<'r>) -> Self {
18695 Self::write_header(request.buf_mut());
18696 Self { request: request }
18697 }
18698 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
18699 Self::write_header(buf);
18700 PushDevlink::new(buf)
18701 }
18702 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
18703 PushDevlink::new(self.request.buf_mut())
18704 }
18705 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
18706 PushDevlink::new(self.request.buf)
18707 }
18708 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
18709 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
18710 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
18711 }
18712 fn write_header<Prev: Pusher>(prev: &mut Prev) {
18713 let mut header = BuiltinNfgenmsg::new();
18714 header.cmd = 52u8;
18715 header.version = 1u8;
18716 prev.as_vec_mut().extend(header.as_slice());
18717 }
18718}
18719impl NetlinkRequest for OpHealthReporterGetDo<'_> {
18720 fn protocol(&self) -> Protocol {
18721 Protocol::Generic("devlink".as_bytes())
18722 }
18723 fn flags(&self) -> u16 {
18724 self.request.flags
18725 }
18726 fn payload(&self) -> &[u8] {
18727 self.request.buf()
18728 }
18729 type ReplyType<'buf> = IterableDevlink<'buf>;
18730 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
18731 Self::decode_request(buf)
18732 }
18733 fn lookup(
18734 buf: &[u8],
18735 offset: usize,
18736 missing_type: Option<u16>,
18737 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
18738 Self::decode_request(buf).lookup_attr(offset, missing_type)
18739 }
18740}
18741#[doc = "Set health reporter instances.\n\nFlags: admin-perm\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_port_index()](PushDevlink::push_port_index)\n- [.push_health_reporter_name()](PushDevlink::push_health_reporter_name)\n- [.push_health_reporter_graceful_period()](PushDevlink::push_health_reporter_graceful_period)\n- [.push_health_reporter_auto_recover()](PushDevlink::push_health_reporter_auto_recover)\n- [.push_health_reporter_auto_dump()](PushDevlink::push_health_reporter_auto_dump)\n- [.push_health_reporter_burst_period()](PushDevlink::push_health_reporter_burst_period)\n- [.push_index()](PushDevlink::push_index)\n\n"]
18742#[derive(Debug)]
18743pub struct OpHealthReporterSetDo<'r> {
18744 request: Request<'r>,
18745}
18746impl<'r> OpHealthReporterSetDo<'r> {
18747 pub fn new(mut request: Request<'r>) -> Self {
18748 Self::write_header(request.buf_mut());
18749 Self { request: request }
18750 }
18751 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
18752 Self::write_header(buf);
18753 PushDevlink::new(buf)
18754 }
18755 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
18756 PushDevlink::new(self.request.buf_mut())
18757 }
18758 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
18759 PushDevlink::new(self.request.buf)
18760 }
18761 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
18762 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
18763 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
18764 }
18765 fn write_header<Prev: Pusher>(prev: &mut Prev) {
18766 let mut header = BuiltinNfgenmsg::new();
18767 header.cmd = 53u8;
18768 header.version = 1u8;
18769 prev.as_vec_mut().extend(header.as_slice());
18770 }
18771}
18772impl NetlinkRequest for OpHealthReporterSetDo<'_> {
18773 fn protocol(&self) -> Protocol {
18774 Protocol::Generic("devlink".as_bytes())
18775 }
18776 fn flags(&self) -> u16 {
18777 self.request.flags
18778 }
18779 fn payload(&self) -> &[u8] {
18780 self.request.buf()
18781 }
18782 type ReplyType<'buf> = IterableDevlink<'buf>;
18783 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
18784 Self::decode_request(buf)
18785 }
18786 fn lookup(
18787 buf: &[u8],
18788 offset: usize,
18789 missing_type: Option<u16>,
18790 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
18791 Self::decode_request(buf).lookup_attr(offset, missing_type)
18792 }
18793}
18794#[doc = "Recover health reporter instances.\n\nFlags: admin-perm\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_port_index()](PushDevlink::push_port_index)\n- [.push_health_reporter_name()](PushDevlink::push_health_reporter_name)\n- [.push_index()](PushDevlink::push_index)\n\n"]
18795#[derive(Debug)]
18796pub struct OpHealthReporterRecoverDo<'r> {
18797 request: Request<'r>,
18798}
18799impl<'r> OpHealthReporterRecoverDo<'r> {
18800 pub fn new(mut request: Request<'r>) -> Self {
18801 Self::write_header(request.buf_mut());
18802 Self { request: request }
18803 }
18804 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
18805 Self::write_header(buf);
18806 PushDevlink::new(buf)
18807 }
18808 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
18809 PushDevlink::new(self.request.buf_mut())
18810 }
18811 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
18812 PushDevlink::new(self.request.buf)
18813 }
18814 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
18815 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
18816 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
18817 }
18818 fn write_header<Prev: Pusher>(prev: &mut Prev) {
18819 let mut header = BuiltinNfgenmsg::new();
18820 header.cmd = 54u8;
18821 header.version = 1u8;
18822 prev.as_vec_mut().extend(header.as_slice());
18823 }
18824}
18825impl NetlinkRequest for OpHealthReporterRecoverDo<'_> {
18826 fn protocol(&self) -> Protocol {
18827 Protocol::Generic("devlink".as_bytes())
18828 }
18829 fn flags(&self) -> u16 {
18830 self.request.flags
18831 }
18832 fn payload(&self) -> &[u8] {
18833 self.request.buf()
18834 }
18835 type ReplyType<'buf> = IterableDevlink<'buf>;
18836 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
18837 Self::decode_request(buf)
18838 }
18839 fn lookup(
18840 buf: &[u8],
18841 offset: usize,
18842 missing_type: Option<u16>,
18843 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
18844 Self::decode_request(buf).lookup_attr(offset, missing_type)
18845 }
18846}
18847#[doc = "Diagnose health reporter instances.\n\nFlags: admin-perm\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_port_index()](PushDevlink::push_port_index)\n- [.push_health_reporter_name()](PushDevlink::push_health_reporter_name)\n- [.push_index()](PushDevlink::push_index)\n\n"]
18848#[derive(Debug)]
18849pub struct OpHealthReporterDiagnoseDo<'r> {
18850 request: Request<'r>,
18851}
18852impl<'r> OpHealthReporterDiagnoseDo<'r> {
18853 pub fn new(mut request: Request<'r>) -> Self {
18854 Self::write_header(request.buf_mut());
18855 Self { request: request }
18856 }
18857 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
18858 Self::write_header(buf);
18859 PushDevlink::new(buf)
18860 }
18861 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
18862 PushDevlink::new(self.request.buf_mut())
18863 }
18864 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
18865 PushDevlink::new(self.request.buf)
18866 }
18867 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
18868 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
18869 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
18870 }
18871 fn write_header<Prev: Pusher>(prev: &mut Prev) {
18872 let mut header = BuiltinNfgenmsg::new();
18873 header.cmd = 55u8;
18874 header.version = 1u8;
18875 prev.as_vec_mut().extend(header.as_slice());
18876 }
18877}
18878impl NetlinkRequest for OpHealthReporterDiagnoseDo<'_> {
18879 fn protocol(&self) -> Protocol {
18880 Protocol::Generic("devlink".as_bytes())
18881 }
18882 fn flags(&self) -> u16 {
18883 self.request.flags
18884 }
18885 fn payload(&self) -> &[u8] {
18886 self.request.buf()
18887 }
18888 type ReplyType<'buf> = IterableDevlink<'buf>;
18889 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
18890 Self::decode_request(buf)
18891 }
18892 fn lookup(
18893 buf: &[u8],
18894 offset: usize,
18895 missing_type: Option<u16>,
18896 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
18897 Self::decode_request(buf).lookup_attr(offset, missing_type)
18898 }
18899}
18900#[doc = "Dump health reporter instances.\n\nFlags: admin-perm\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_port_index()](PushDevlink::push_port_index)\n- [.push_health_reporter_name()](PushDevlink::push_health_reporter_name)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_fmsg()](IterableDevlink::get_fmsg)\n\n"]
18901#[derive(Debug)]
18902pub struct OpHealthReporterDumpGetDump<'r> {
18903 request: Request<'r>,
18904}
18905impl<'r> OpHealthReporterDumpGetDump<'r> {
18906 pub fn new(mut request: Request<'r>) -> Self {
18907 Self::write_header(request.buf_mut());
18908 Self {
18909 request: request.set_dump(),
18910 }
18911 }
18912 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
18913 Self::write_header(buf);
18914 PushDevlink::new(buf)
18915 }
18916 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
18917 PushDevlink::new(self.request.buf_mut())
18918 }
18919 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
18920 PushDevlink::new(self.request.buf)
18921 }
18922 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
18923 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
18924 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
18925 }
18926 fn write_header<Prev: Pusher>(prev: &mut Prev) {
18927 let mut header = BuiltinNfgenmsg::new();
18928 header.cmd = 56u8;
18929 header.version = 1u8;
18930 prev.as_vec_mut().extend(header.as_slice());
18931 }
18932}
18933impl NetlinkRequest for OpHealthReporterDumpGetDump<'_> {
18934 fn protocol(&self) -> Protocol {
18935 Protocol::Generic("devlink".as_bytes())
18936 }
18937 fn flags(&self) -> u16 {
18938 self.request.flags
18939 }
18940 fn payload(&self) -> &[u8] {
18941 self.request.buf()
18942 }
18943 type ReplyType<'buf> = IterableDevlink<'buf>;
18944 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
18945 Self::decode_request(buf)
18946 }
18947 fn lookup(
18948 buf: &[u8],
18949 offset: usize,
18950 missing_type: Option<u16>,
18951 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
18952 Self::decode_request(buf).lookup_attr(offset, missing_type)
18953 }
18954}
18955#[doc = "Clear dump of health reporter instances.\n\nFlags: admin-perm\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_port_index()](PushDevlink::push_port_index)\n- [.push_health_reporter_name()](PushDevlink::push_health_reporter_name)\n- [.push_index()](PushDevlink::push_index)\n\n"]
18956#[derive(Debug)]
18957pub struct OpHealthReporterDumpClearDo<'r> {
18958 request: Request<'r>,
18959}
18960impl<'r> OpHealthReporterDumpClearDo<'r> {
18961 pub fn new(mut request: Request<'r>) -> Self {
18962 Self::write_header(request.buf_mut());
18963 Self { request: request }
18964 }
18965 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
18966 Self::write_header(buf);
18967 PushDevlink::new(buf)
18968 }
18969 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
18970 PushDevlink::new(self.request.buf_mut())
18971 }
18972 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
18973 PushDevlink::new(self.request.buf)
18974 }
18975 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
18976 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
18977 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
18978 }
18979 fn write_header<Prev: Pusher>(prev: &mut Prev) {
18980 let mut header = BuiltinNfgenmsg::new();
18981 header.cmd = 57u8;
18982 header.version = 1u8;
18983 prev.as_vec_mut().extend(header.as_slice());
18984 }
18985}
18986impl NetlinkRequest for OpHealthReporterDumpClearDo<'_> {
18987 fn protocol(&self) -> Protocol {
18988 Protocol::Generic("devlink".as_bytes())
18989 }
18990 fn flags(&self) -> u16 {
18991 self.request.flags
18992 }
18993 fn payload(&self) -> &[u8] {
18994 self.request.buf()
18995 }
18996 type ReplyType<'buf> = IterableDevlink<'buf>;
18997 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
18998 Self::decode_request(buf)
18999 }
19000 fn lookup(
19001 buf: &[u8],
19002 offset: usize,
19003 missing_type: Option<u16>,
19004 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
19005 Self::decode_request(buf).lookup_attr(offset, missing_type)
19006 }
19007}
19008#[doc = "Flash update devlink instances.\n\nFlags: admin-perm\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_flash_update_file_name()](PushDevlink::push_flash_update_file_name)\n- [.push_flash_update_component()](PushDevlink::push_flash_update_component)\n- [.push_flash_update_overwrite_mask()](PushDevlink::push_flash_update_overwrite_mask)\n- [.push_index()](PushDevlink::push_index)\n\n"]
19009#[derive(Debug)]
19010pub struct OpFlashUpdateDo<'r> {
19011 request: Request<'r>,
19012}
19013impl<'r> OpFlashUpdateDo<'r> {
19014 pub fn new(mut request: Request<'r>) -> Self {
19015 Self::write_header(request.buf_mut());
19016 Self { request: request }
19017 }
19018 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
19019 Self::write_header(buf);
19020 PushDevlink::new(buf)
19021 }
19022 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
19023 PushDevlink::new(self.request.buf_mut())
19024 }
19025 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
19026 PushDevlink::new(self.request.buf)
19027 }
19028 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
19029 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
19030 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
19031 }
19032 fn write_header<Prev: Pusher>(prev: &mut Prev) {
19033 let mut header = BuiltinNfgenmsg::new();
19034 header.cmd = 58u8;
19035 header.version = 1u8;
19036 prev.as_vec_mut().extend(header.as_slice());
19037 }
19038}
19039impl NetlinkRequest for OpFlashUpdateDo<'_> {
19040 fn protocol(&self) -> Protocol {
19041 Protocol::Generic("devlink".as_bytes())
19042 }
19043 fn flags(&self) -> u16 {
19044 self.request.flags
19045 }
19046 fn payload(&self) -> &[u8] {
19047 self.request.buf()
19048 }
19049 type ReplyType<'buf> = IterableDevlink<'buf>;
19050 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
19051 Self::decode_request(buf)
19052 }
19053 fn lookup(
19054 buf: &[u8],
19055 offset: usize,
19056 missing_type: Option<u16>,
19057 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
19058 Self::decode_request(buf).lookup_attr(offset, missing_type)
19059 }
19060}
19061#[doc = "Get trap instances.\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_trap_name()](IterableDevlink::get_trap_name)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
19062#[derive(Debug)]
19063pub struct OpTrapGetDump<'r> {
19064 request: Request<'r>,
19065}
19066impl<'r> OpTrapGetDump<'r> {
19067 pub fn new(mut request: Request<'r>) -> Self {
19068 Self::write_header(request.buf_mut());
19069 Self {
19070 request: request.set_dump(),
19071 }
19072 }
19073 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
19074 Self::write_header(buf);
19075 PushDevlink::new(buf)
19076 }
19077 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
19078 PushDevlink::new(self.request.buf_mut())
19079 }
19080 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
19081 PushDevlink::new(self.request.buf)
19082 }
19083 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
19084 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
19085 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
19086 }
19087 fn write_header<Prev: Pusher>(prev: &mut Prev) {
19088 let mut header = BuiltinNfgenmsg::new();
19089 header.cmd = 61u8;
19090 header.version = 1u8;
19091 prev.as_vec_mut().extend(header.as_slice());
19092 }
19093}
19094impl NetlinkRequest for OpTrapGetDump<'_> {
19095 fn protocol(&self) -> Protocol {
19096 Protocol::Generic("devlink".as_bytes())
19097 }
19098 fn flags(&self) -> u16 {
19099 self.request.flags
19100 }
19101 fn payload(&self) -> &[u8] {
19102 self.request.buf()
19103 }
19104 type ReplyType<'buf> = IterableDevlink<'buf>;
19105 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
19106 Self::decode_request(buf)
19107 }
19108 fn lookup(
19109 buf: &[u8],
19110 offset: usize,
19111 missing_type: Option<u16>,
19112 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
19113 Self::decode_request(buf).lookup_attr(offset, missing_type)
19114 }
19115}
19116#[doc = "Get trap instances.\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_trap_name()](PushDevlink::push_trap_name)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_trap_name()](IterableDevlink::get_trap_name)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
19117#[derive(Debug)]
19118pub struct OpTrapGetDo<'r> {
19119 request: Request<'r>,
19120}
19121impl<'r> OpTrapGetDo<'r> {
19122 pub fn new(mut request: Request<'r>) -> Self {
19123 Self::write_header(request.buf_mut());
19124 Self { request: request }
19125 }
19126 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
19127 Self::write_header(buf);
19128 PushDevlink::new(buf)
19129 }
19130 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
19131 PushDevlink::new(self.request.buf_mut())
19132 }
19133 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
19134 PushDevlink::new(self.request.buf)
19135 }
19136 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
19137 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
19138 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
19139 }
19140 fn write_header<Prev: Pusher>(prev: &mut Prev) {
19141 let mut header = BuiltinNfgenmsg::new();
19142 header.cmd = 61u8;
19143 header.version = 1u8;
19144 prev.as_vec_mut().extend(header.as_slice());
19145 }
19146}
19147impl NetlinkRequest for OpTrapGetDo<'_> {
19148 fn protocol(&self) -> Protocol {
19149 Protocol::Generic("devlink".as_bytes())
19150 }
19151 fn flags(&self) -> u16 {
19152 self.request.flags
19153 }
19154 fn payload(&self) -> &[u8] {
19155 self.request.buf()
19156 }
19157 type ReplyType<'buf> = IterableDevlink<'buf>;
19158 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
19159 Self::decode_request(buf)
19160 }
19161 fn lookup(
19162 buf: &[u8],
19163 offset: usize,
19164 missing_type: Option<u16>,
19165 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
19166 Self::decode_request(buf).lookup_attr(offset, missing_type)
19167 }
19168}
19169#[doc = "Set trap instances.\n\nFlags: admin-perm\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_trap_name()](PushDevlink::push_trap_name)\n- [.push_trap_action()](PushDevlink::push_trap_action)\n- [.push_index()](PushDevlink::push_index)\n\n"]
19170#[derive(Debug)]
19171pub struct OpTrapSetDo<'r> {
19172 request: Request<'r>,
19173}
19174impl<'r> OpTrapSetDo<'r> {
19175 pub fn new(mut request: Request<'r>) -> Self {
19176 Self::write_header(request.buf_mut());
19177 Self { request: request }
19178 }
19179 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
19180 Self::write_header(buf);
19181 PushDevlink::new(buf)
19182 }
19183 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
19184 PushDevlink::new(self.request.buf_mut())
19185 }
19186 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
19187 PushDevlink::new(self.request.buf)
19188 }
19189 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
19190 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
19191 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
19192 }
19193 fn write_header<Prev: Pusher>(prev: &mut Prev) {
19194 let mut header = BuiltinNfgenmsg::new();
19195 header.cmd = 62u8;
19196 header.version = 1u8;
19197 prev.as_vec_mut().extend(header.as_slice());
19198 }
19199}
19200impl NetlinkRequest for OpTrapSetDo<'_> {
19201 fn protocol(&self) -> Protocol {
19202 Protocol::Generic("devlink".as_bytes())
19203 }
19204 fn flags(&self) -> u16 {
19205 self.request.flags
19206 }
19207 fn payload(&self) -> &[u8] {
19208 self.request.buf()
19209 }
19210 type ReplyType<'buf> = IterableDevlink<'buf>;
19211 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
19212 Self::decode_request(buf)
19213 }
19214 fn lookup(
19215 buf: &[u8],
19216 offset: usize,
19217 missing_type: Option<u16>,
19218 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
19219 Self::decode_request(buf).lookup_attr(offset, missing_type)
19220 }
19221}
19222#[doc = "Get trap group instances.\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_trap_group_name()](IterableDevlink::get_trap_group_name)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
19223#[derive(Debug)]
19224pub struct OpTrapGroupGetDump<'r> {
19225 request: Request<'r>,
19226}
19227impl<'r> OpTrapGroupGetDump<'r> {
19228 pub fn new(mut request: Request<'r>) -> Self {
19229 Self::write_header(request.buf_mut());
19230 Self {
19231 request: request.set_dump(),
19232 }
19233 }
19234 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
19235 Self::write_header(buf);
19236 PushDevlink::new(buf)
19237 }
19238 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
19239 PushDevlink::new(self.request.buf_mut())
19240 }
19241 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
19242 PushDevlink::new(self.request.buf)
19243 }
19244 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
19245 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
19246 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
19247 }
19248 fn write_header<Prev: Pusher>(prev: &mut Prev) {
19249 let mut header = BuiltinNfgenmsg::new();
19250 header.cmd = 65u8;
19251 header.version = 1u8;
19252 prev.as_vec_mut().extend(header.as_slice());
19253 }
19254}
19255impl NetlinkRequest for OpTrapGroupGetDump<'_> {
19256 fn protocol(&self) -> Protocol {
19257 Protocol::Generic("devlink".as_bytes())
19258 }
19259 fn flags(&self) -> u16 {
19260 self.request.flags
19261 }
19262 fn payload(&self) -> &[u8] {
19263 self.request.buf()
19264 }
19265 type ReplyType<'buf> = IterableDevlink<'buf>;
19266 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
19267 Self::decode_request(buf)
19268 }
19269 fn lookup(
19270 buf: &[u8],
19271 offset: usize,
19272 missing_type: Option<u16>,
19273 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
19274 Self::decode_request(buf).lookup_attr(offset, missing_type)
19275 }
19276}
19277#[doc = "Get trap group instances.\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_trap_group_name()](PushDevlink::push_trap_group_name)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_trap_group_name()](IterableDevlink::get_trap_group_name)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
19278#[derive(Debug)]
19279pub struct OpTrapGroupGetDo<'r> {
19280 request: Request<'r>,
19281}
19282impl<'r> OpTrapGroupGetDo<'r> {
19283 pub fn new(mut request: Request<'r>) -> Self {
19284 Self::write_header(request.buf_mut());
19285 Self { request: request }
19286 }
19287 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
19288 Self::write_header(buf);
19289 PushDevlink::new(buf)
19290 }
19291 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
19292 PushDevlink::new(self.request.buf_mut())
19293 }
19294 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
19295 PushDevlink::new(self.request.buf)
19296 }
19297 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
19298 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
19299 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
19300 }
19301 fn write_header<Prev: Pusher>(prev: &mut Prev) {
19302 let mut header = BuiltinNfgenmsg::new();
19303 header.cmd = 65u8;
19304 header.version = 1u8;
19305 prev.as_vec_mut().extend(header.as_slice());
19306 }
19307}
19308impl NetlinkRequest for OpTrapGroupGetDo<'_> {
19309 fn protocol(&self) -> Protocol {
19310 Protocol::Generic("devlink".as_bytes())
19311 }
19312 fn flags(&self) -> u16 {
19313 self.request.flags
19314 }
19315 fn payload(&self) -> &[u8] {
19316 self.request.buf()
19317 }
19318 type ReplyType<'buf> = IterableDevlink<'buf>;
19319 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
19320 Self::decode_request(buf)
19321 }
19322 fn lookup(
19323 buf: &[u8],
19324 offset: usize,
19325 missing_type: Option<u16>,
19326 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
19327 Self::decode_request(buf).lookup_attr(offset, missing_type)
19328 }
19329}
19330#[doc = "Set trap group instances.\n\nFlags: admin-perm\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_trap_action()](PushDevlink::push_trap_action)\n- [.push_trap_group_name()](PushDevlink::push_trap_group_name)\n- [.push_trap_policer_id()](PushDevlink::push_trap_policer_id)\n- [.push_index()](PushDevlink::push_index)\n\n"]
19331#[derive(Debug)]
19332pub struct OpTrapGroupSetDo<'r> {
19333 request: Request<'r>,
19334}
19335impl<'r> OpTrapGroupSetDo<'r> {
19336 pub fn new(mut request: Request<'r>) -> Self {
19337 Self::write_header(request.buf_mut());
19338 Self { request: request }
19339 }
19340 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
19341 Self::write_header(buf);
19342 PushDevlink::new(buf)
19343 }
19344 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
19345 PushDevlink::new(self.request.buf_mut())
19346 }
19347 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
19348 PushDevlink::new(self.request.buf)
19349 }
19350 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
19351 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
19352 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
19353 }
19354 fn write_header<Prev: Pusher>(prev: &mut Prev) {
19355 let mut header = BuiltinNfgenmsg::new();
19356 header.cmd = 66u8;
19357 header.version = 1u8;
19358 prev.as_vec_mut().extend(header.as_slice());
19359 }
19360}
19361impl NetlinkRequest for OpTrapGroupSetDo<'_> {
19362 fn protocol(&self) -> Protocol {
19363 Protocol::Generic("devlink".as_bytes())
19364 }
19365 fn flags(&self) -> u16 {
19366 self.request.flags
19367 }
19368 fn payload(&self) -> &[u8] {
19369 self.request.buf()
19370 }
19371 type ReplyType<'buf> = IterableDevlink<'buf>;
19372 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
19373 Self::decode_request(buf)
19374 }
19375 fn lookup(
19376 buf: &[u8],
19377 offset: usize,
19378 missing_type: Option<u16>,
19379 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
19380 Self::decode_request(buf).lookup_attr(offset, missing_type)
19381 }
19382}
19383#[doc = "Get trap policer instances.\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_trap_policer_id()](IterableDevlink::get_trap_policer_id)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
19384#[derive(Debug)]
19385pub struct OpTrapPolicerGetDump<'r> {
19386 request: Request<'r>,
19387}
19388impl<'r> OpTrapPolicerGetDump<'r> {
19389 pub fn new(mut request: Request<'r>) -> Self {
19390 Self::write_header(request.buf_mut());
19391 Self {
19392 request: request.set_dump(),
19393 }
19394 }
19395 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
19396 Self::write_header(buf);
19397 PushDevlink::new(buf)
19398 }
19399 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
19400 PushDevlink::new(self.request.buf_mut())
19401 }
19402 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
19403 PushDevlink::new(self.request.buf)
19404 }
19405 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
19406 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
19407 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
19408 }
19409 fn write_header<Prev: Pusher>(prev: &mut Prev) {
19410 let mut header = BuiltinNfgenmsg::new();
19411 header.cmd = 69u8;
19412 header.version = 1u8;
19413 prev.as_vec_mut().extend(header.as_slice());
19414 }
19415}
19416impl NetlinkRequest for OpTrapPolicerGetDump<'_> {
19417 fn protocol(&self) -> Protocol {
19418 Protocol::Generic("devlink".as_bytes())
19419 }
19420 fn flags(&self) -> u16 {
19421 self.request.flags
19422 }
19423 fn payload(&self) -> &[u8] {
19424 self.request.buf()
19425 }
19426 type ReplyType<'buf> = IterableDevlink<'buf>;
19427 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
19428 Self::decode_request(buf)
19429 }
19430 fn lookup(
19431 buf: &[u8],
19432 offset: usize,
19433 missing_type: Option<u16>,
19434 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
19435 Self::decode_request(buf).lookup_attr(offset, missing_type)
19436 }
19437}
19438#[doc = "Get trap policer instances.\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_trap_policer_id()](PushDevlink::push_trap_policer_id)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_trap_policer_id()](IterableDevlink::get_trap_policer_id)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
19439#[derive(Debug)]
19440pub struct OpTrapPolicerGetDo<'r> {
19441 request: Request<'r>,
19442}
19443impl<'r> OpTrapPolicerGetDo<'r> {
19444 pub fn new(mut request: Request<'r>) -> Self {
19445 Self::write_header(request.buf_mut());
19446 Self { request: request }
19447 }
19448 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
19449 Self::write_header(buf);
19450 PushDevlink::new(buf)
19451 }
19452 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
19453 PushDevlink::new(self.request.buf_mut())
19454 }
19455 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
19456 PushDevlink::new(self.request.buf)
19457 }
19458 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
19459 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
19460 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
19461 }
19462 fn write_header<Prev: Pusher>(prev: &mut Prev) {
19463 let mut header = BuiltinNfgenmsg::new();
19464 header.cmd = 69u8;
19465 header.version = 1u8;
19466 prev.as_vec_mut().extend(header.as_slice());
19467 }
19468}
19469impl NetlinkRequest for OpTrapPolicerGetDo<'_> {
19470 fn protocol(&self) -> Protocol {
19471 Protocol::Generic("devlink".as_bytes())
19472 }
19473 fn flags(&self) -> u16 {
19474 self.request.flags
19475 }
19476 fn payload(&self) -> &[u8] {
19477 self.request.buf()
19478 }
19479 type ReplyType<'buf> = IterableDevlink<'buf>;
19480 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
19481 Self::decode_request(buf)
19482 }
19483 fn lookup(
19484 buf: &[u8],
19485 offset: usize,
19486 missing_type: Option<u16>,
19487 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
19488 Self::decode_request(buf).lookup_attr(offset, missing_type)
19489 }
19490}
19491#[doc = "Get trap policer instances.\n\nFlags: admin-perm\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_trap_policer_id()](PushDevlink::push_trap_policer_id)\n- [.push_trap_policer_rate()](PushDevlink::push_trap_policer_rate)\n- [.push_trap_policer_burst()](PushDevlink::push_trap_policer_burst)\n- [.push_index()](PushDevlink::push_index)\n\n"]
19492#[derive(Debug)]
19493pub struct OpTrapPolicerSetDo<'r> {
19494 request: Request<'r>,
19495}
19496impl<'r> OpTrapPolicerSetDo<'r> {
19497 pub fn new(mut request: Request<'r>) -> Self {
19498 Self::write_header(request.buf_mut());
19499 Self { request: request }
19500 }
19501 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
19502 Self::write_header(buf);
19503 PushDevlink::new(buf)
19504 }
19505 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
19506 PushDevlink::new(self.request.buf_mut())
19507 }
19508 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
19509 PushDevlink::new(self.request.buf)
19510 }
19511 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
19512 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
19513 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
19514 }
19515 fn write_header<Prev: Pusher>(prev: &mut Prev) {
19516 let mut header = BuiltinNfgenmsg::new();
19517 header.cmd = 70u8;
19518 header.version = 1u8;
19519 prev.as_vec_mut().extend(header.as_slice());
19520 }
19521}
19522impl NetlinkRequest for OpTrapPolicerSetDo<'_> {
19523 fn protocol(&self) -> Protocol {
19524 Protocol::Generic("devlink".as_bytes())
19525 }
19526 fn flags(&self) -> u16 {
19527 self.request.flags
19528 }
19529 fn payload(&self) -> &[u8] {
19530 self.request.buf()
19531 }
19532 type ReplyType<'buf> = IterableDevlink<'buf>;
19533 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
19534 Self::decode_request(buf)
19535 }
19536 fn lookup(
19537 buf: &[u8],
19538 offset: usize,
19539 missing_type: Option<u16>,
19540 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
19541 Self::decode_request(buf).lookup_attr(offset, missing_type)
19542 }
19543}
19544#[doc = "Test health reporter instances.\n\nFlags: admin-perm\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_port_index()](PushDevlink::push_port_index)\n- [.push_health_reporter_name()](PushDevlink::push_health_reporter_name)\n- [.push_index()](PushDevlink::push_index)\n\n"]
19545#[derive(Debug)]
19546pub struct OpHealthReporterTestDo<'r> {
19547 request: Request<'r>,
19548}
19549impl<'r> OpHealthReporterTestDo<'r> {
19550 pub fn new(mut request: Request<'r>) -> Self {
19551 Self::write_header(request.buf_mut());
19552 Self { request: request }
19553 }
19554 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
19555 Self::write_header(buf);
19556 PushDevlink::new(buf)
19557 }
19558 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
19559 PushDevlink::new(self.request.buf_mut())
19560 }
19561 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
19562 PushDevlink::new(self.request.buf)
19563 }
19564 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
19565 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
19566 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
19567 }
19568 fn write_header<Prev: Pusher>(prev: &mut Prev) {
19569 let mut header = BuiltinNfgenmsg::new();
19570 header.cmd = 73u8;
19571 header.version = 1u8;
19572 prev.as_vec_mut().extend(header.as_slice());
19573 }
19574}
19575impl NetlinkRequest for OpHealthReporterTestDo<'_> {
19576 fn protocol(&self) -> Protocol {
19577 Protocol::Generic("devlink".as_bytes())
19578 }
19579 fn flags(&self) -> u16 {
19580 self.request.flags
19581 }
19582 fn payload(&self) -> &[u8] {
19583 self.request.buf()
19584 }
19585 type ReplyType<'buf> = IterableDevlink<'buf>;
19586 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
19587 Self::decode_request(buf)
19588 }
19589 fn lookup(
19590 buf: &[u8],
19591 offset: usize,
19592 missing_type: Option<u16>,
19593 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
19594 Self::decode_request(buf).lookup_attr(offset, missing_type)
19595 }
19596}
19597#[doc = "Get rate instances.\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_port_index()](IterableDevlink::get_port_index)\n- [.get_rate_node_name()](IterableDevlink::get_rate_node_name)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
19598#[derive(Debug)]
19599pub struct OpRateGetDump<'r> {
19600 request: Request<'r>,
19601}
19602impl<'r> OpRateGetDump<'r> {
19603 pub fn new(mut request: Request<'r>) -> Self {
19604 Self::write_header(request.buf_mut());
19605 Self {
19606 request: request.set_dump(),
19607 }
19608 }
19609 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
19610 Self::write_header(buf);
19611 PushDevlink::new(buf)
19612 }
19613 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
19614 PushDevlink::new(self.request.buf_mut())
19615 }
19616 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
19617 PushDevlink::new(self.request.buf)
19618 }
19619 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
19620 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
19621 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
19622 }
19623 fn write_header<Prev: Pusher>(prev: &mut Prev) {
19624 let mut header = BuiltinNfgenmsg::new();
19625 header.cmd = 74u8;
19626 header.version = 1u8;
19627 prev.as_vec_mut().extend(header.as_slice());
19628 }
19629}
19630impl NetlinkRequest for OpRateGetDump<'_> {
19631 fn protocol(&self) -> Protocol {
19632 Protocol::Generic("devlink".as_bytes())
19633 }
19634 fn flags(&self) -> u16 {
19635 self.request.flags
19636 }
19637 fn payload(&self) -> &[u8] {
19638 self.request.buf()
19639 }
19640 type ReplyType<'buf> = IterableDevlink<'buf>;
19641 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
19642 Self::decode_request(buf)
19643 }
19644 fn lookup(
19645 buf: &[u8],
19646 offset: usize,
19647 missing_type: Option<u16>,
19648 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
19649 Self::decode_request(buf).lookup_attr(offset, missing_type)
19650 }
19651}
19652#[doc = "Get rate instances.\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_port_index()](PushDevlink::push_port_index)\n- [.push_rate_node_name()](PushDevlink::push_rate_node_name)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_port_index()](IterableDevlink::get_port_index)\n- [.get_rate_node_name()](IterableDevlink::get_rate_node_name)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
19653#[derive(Debug)]
19654pub struct OpRateGetDo<'r> {
19655 request: Request<'r>,
19656}
19657impl<'r> OpRateGetDo<'r> {
19658 pub fn new(mut request: Request<'r>) -> Self {
19659 Self::write_header(request.buf_mut());
19660 Self { request: request }
19661 }
19662 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
19663 Self::write_header(buf);
19664 PushDevlink::new(buf)
19665 }
19666 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
19667 PushDevlink::new(self.request.buf_mut())
19668 }
19669 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
19670 PushDevlink::new(self.request.buf)
19671 }
19672 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
19673 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
19674 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
19675 }
19676 fn write_header<Prev: Pusher>(prev: &mut Prev) {
19677 let mut header = BuiltinNfgenmsg::new();
19678 header.cmd = 74u8;
19679 header.version = 1u8;
19680 prev.as_vec_mut().extend(header.as_slice());
19681 }
19682}
19683impl NetlinkRequest for OpRateGetDo<'_> {
19684 fn protocol(&self) -> Protocol {
19685 Protocol::Generic("devlink".as_bytes())
19686 }
19687 fn flags(&self) -> u16 {
19688 self.request.flags
19689 }
19690 fn payload(&self) -> &[u8] {
19691 self.request.buf()
19692 }
19693 type ReplyType<'buf> = IterableDevlink<'buf>;
19694 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
19695 Self::decode_request(buf)
19696 }
19697 fn lookup(
19698 buf: &[u8],
19699 offset: usize,
19700 missing_type: Option<u16>,
19701 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
19702 Self::decode_request(buf).lookup_attr(offset, missing_type)
19703 }
19704}
19705#[doc = "Set rate instances.\n\nFlags: admin-perm\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_rate_tx_share()](PushDevlink::push_rate_tx_share)\n- [.push_rate_tx_max()](PushDevlink::push_rate_tx_max)\n- [.push_rate_node_name()](PushDevlink::push_rate_node_name)\n- [.push_rate_parent_node_name()](PushDevlink::push_rate_parent_node_name)\n- [.push_rate_tx_priority()](PushDevlink::push_rate_tx_priority)\n- [.push_rate_tx_weight()](PushDevlink::push_rate_tx_weight)\n- [.nested_rate_tc_bws()](PushDevlink::nested_rate_tc_bws)\n- [.push_index()](PushDevlink::push_index)\n\n"]
19706#[derive(Debug)]
19707pub struct OpRateSetDo<'r> {
19708 request: Request<'r>,
19709}
19710impl<'r> OpRateSetDo<'r> {
19711 pub fn new(mut request: Request<'r>) -> Self {
19712 Self::write_header(request.buf_mut());
19713 Self { request: request }
19714 }
19715 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
19716 Self::write_header(buf);
19717 PushDevlink::new(buf)
19718 }
19719 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
19720 PushDevlink::new(self.request.buf_mut())
19721 }
19722 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
19723 PushDevlink::new(self.request.buf)
19724 }
19725 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
19726 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
19727 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
19728 }
19729 fn write_header<Prev: Pusher>(prev: &mut Prev) {
19730 let mut header = BuiltinNfgenmsg::new();
19731 header.cmd = 75u8;
19732 header.version = 1u8;
19733 prev.as_vec_mut().extend(header.as_slice());
19734 }
19735}
19736impl NetlinkRequest for OpRateSetDo<'_> {
19737 fn protocol(&self) -> Protocol {
19738 Protocol::Generic("devlink".as_bytes())
19739 }
19740 fn flags(&self) -> u16 {
19741 self.request.flags
19742 }
19743 fn payload(&self) -> &[u8] {
19744 self.request.buf()
19745 }
19746 type ReplyType<'buf> = IterableDevlink<'buf>;
19747 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
19748 Self::decode_request(buf)
19749 }
19750 fn lookup(
19751 buf: &[u8],
19752 offset: usize,
19753 missing_type: Option<u16>,
19754 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
19755 Self::decode_request(buf).lookup_attr(offset, missing_type)
19756 }
19757}
19758#[doc = "Create rate instances.\n\nFlags: admin-perm\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_rate_tx_share()](PushDevlink::push_rate_tx_share)\n- [.push_rate_tx_max()](PushDevlink::push_rate_tx_max)\n- [.push_rate_node_name()](PushDevlink::push_rate_node_name)\n- [.push_rate_parent_node_name()](PushDevlink::push_rate_parent_node_name)\n- [.push_rate_tx_priority()](PushDevlink::push_rate_tx_priority)\n- [.push_rate_tx_weight()](PushDevlink::push_rate_tx_weight)\n- [.nested_rate_tc_bws()](PushDevlink::nested_rate_tc_bws)\n- [.push_index()](PushDevlink::push_index)\n\n"]
19759#[derive(Debug)]
19760pub struct OpRateNewDo<'r> {
19761 request: Request<'r>,
19762}
19763impl<'r> OpRateNewDo<'r> {
19764 pub fn new(mut request: Request<'r>) -> Self {
19765 Self::write_header(request.buf_mut());
19766 Self { request: request }
19767 }
19768 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
19769 Self::write_header(buf);
19770 PushDevlink::new(buf)
19771 }
19772 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
19773 PushDevlink::new(self.request.buf_mut())
19774 }
19775 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
19776 PushDevlink::new(self.request.buf)
19777 }
19778 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
19779 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
19780 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
19781 }
19782 fn write_header<Prev: Pusher>(prev: &mut Prev) {
19783 let mut header = BuiltinNfgenmsg::new();
19784 header.cmd = 76u8;
19785 header.version = 1u8;
19786 prev.as_vec_mut().extend(header.as_slice());
19787 }
19788}
19789impl NetlinkRequest for OpRateNewDo<'_> {
19790 fn protocol(&self) -> Protocol {
19791 Protocol::Generic("devlink".as_bytes())
19792 }
19793 fn flags(&self) -> u16 {
19794 self.request.flags
19795 }
19796 fn payload(&self) -> &[u8] {
19797 self.request.buf()
19798 }
19799 type ReplyType<'buf> = IterableDevlink<'buf>;
19800 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
19801 Self::decode_request(buf)
19802 }
19803 fn lookup(
19804 buf: &[u8],
19805 offset: usize,
19806 missing_type: Option<u16>,
19807 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
19808 Self::decode_request(buf).lookup_attr(offset, missing_type)
19809 }
19810}
19811#[doc = "Delete rate instances.\n\nFlags: admin-perm\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_rate_node_name()](PushDevlink::push_rate_node_name)\n- [.push_index()](PushDevlink::push_index)\n\n"]
19812#[derive(Debug)]
19813pub struct OpRateDelDo<'r> {
19814 request: Request<'r>,
19815}
19816impl<'r> OpRateDelDo<'r> {
19817 pub fn new(mut request: Request<'r>) -> Self {
19818 Self::write_header(request.buf_mut());
19819 Self { request: request }
19820 }
19821 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
19822 Self::write_header(buf);
19823 PushDevlink::new(buf)
19824 }
19825 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
19826 PushDevlink::new(self.request.buf_mut())
19827 }
19828 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
19829 PushDevlink::new(self.request.buf)
19830 }
19831 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
19832 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
19833 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
19834 }
19835 fn write_header<Prev: Pusher>(prev: &mut Prev) {
19836 let mut header = BuiltinNfgenmsg::new();
19837 header.cmd = 77u8;
19838 header.version = 1u8;
19839 prev.as_vec_mut().extend(header.as_slice());
19840 }
19841}
19842impl NetlinkRequest for OpRateDelDo<'_> {
19843 fn protocol(&self) -> Protocol {
19844 Protocol::Generic("devlink".as_bytes())
19845 }
19846 fn flags(&self) -> u16 {
19847 self.request.flags
19848 }
19849 fn payload(&self) -> &[u8] {
19850 self.request.buf()
19851 }
19852 type ReplyType<'buf> = IterableDevlink<'buf>;
19853 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
19854 Self::decode_request(buf)
19855 }
19856 fn lookup(
19857 buf: &[u8],
19858 offset: usize,
19859 missing_type: Option<u16>,
19860 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
19861 Self::decode_request(buf).lookup_attr(offset, missing_type)
19862 }
19863}
19864#[doc = "Get line card instances.\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_linecard_index()](IterableDevlink::get_linecard_index)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
19865#[derive(Debug)]
19866pub struct OpLinecardGetDump<'r> {
19867 request: Request<'r>,
19868}
19869impl<'r> OpLinecardGetDump<'r> {
19870 pub fn new(mut request: Request<'r>) -> Self {
19871 Self::write_header(request.buf_mut());
19872 Self {
19873 request: request.set_dump(),
19874 }
19875 }
19876 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
19877 Self::write_header(buf);
19878 PushDevlink::new(buf)
19879 }
19880 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
19881 PushDevlink::new(self.request.buf_mut())
19882 }
19883 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
19884 PushDevlink::new(self.request.buf)
19885 }
19886 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
19887 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
19888 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
19889 }
19890 fn write_header<Prev: Pusher>(prev: &mut Prev) {
19891 let mut header = BuiltinNfgenmsg::new();
19892 header.cmd = 78u8;
19893 header.version = 1u8;
19894 prev.as_vec_mut().extend(header.as_slice());
19895 }
19896}
19897impl NetlinkRequest for OpLinecardGetDump<'_> {
19898 fn protocol(&self) -> Protocol {
19899 Protocol::Generic("devlink".as_bytes())
19900 }
19901 fn flags(&self) -> u16 {
19902 self.request.flags
19903 }
19904 fn payload(&self) -> &[u8] {
19905 self.request.buf()
19906 }
19907 type ReplyType<'buf> = IterableDevlink<'buf>;
19908 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
19909 Self::decode_request(buf)
19910 }
19911 fn lookup(
19912 buf: &[u8],
19913 offset: usize,
19914 missing_type: Option<u16>,
19915 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
19916 Self::decode_request(buf).lookup_attr(offset, missing_type)
19917 }
19918}
19919#[doc = "Get line card instances.\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_linecard_index()](PushDevlink::push_linecard_index)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_linecard_index()](IterableDevlink::get_linecard_index)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
19920#[derive(Debug)]
19921pub struct OpLinecardGetDo<'r> {
19922 request: Request<'r>,
19923}
19924impl<'r> OpLinecardGetDo<'r> {
19925 pub fn new(mut request: Request<'r>) -> Self {
19926 Self::write_header(request.buf_mut());
19927 Self { request: request }
19928 }
19929 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
19930 Self::write_header(buf);
19931 PushDevlink::new(buf)
19932 }
19933 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
19934 PushDevlink::new(self.request.buf_mut())
19935 }
19936 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
19937 PushDevlink::new(self.request.buf)
19938 }
19939 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
19940 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
19941 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
19942 }
19943 fn write_header<Prev: Pusher>(prev: &mut Prev) {
19944 let mut header = BuiltinNfgenmsg::new();
19945 header.cmd = 78u8;
19946 header.version = 1u8;
19947 prev.as_vec_mut().extend(header.as_slice());
19948 }
19949}
19950impl NetlinkRequest for OpLinecardGetDo<'_> {
19951 fn protocol(&self) -> Protocol {
19952 Protocol::Generic("devlink".as_bytes())
19953 }
19954 fn flags(&self) -> u16 {
19955 self.request.flags
19956 }
19957 fn payload(&self) -> &[u8] {
19958 self.request.buf()
19959 }
19960 type ReplyType<'buf> = IterableDevlink<'buf>;
19961 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
19962 Self::decode_request(buf)
19963 }
19964 fn lookup(
19965 buf: &[u8],
19966 offset: usize,
19967 missing_type: Option<u16>,
19968 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
19969 Self::decode_request(buf).lookup_attr(offset, missing_type)
19970 }
19971}
19972#[doc = "Set line card instances.\n\nFlags: admin-perm\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_linecard_index()](PushDevlink::push_linecard_index)\n- [.push_linecard_type()](PushDevlink::push_linecard_type)\n- [.push_index()](PushDevlink::push_index)\n\n"]
19973#[derive(Debug)]
19974pub struct OpLinecardSetDo<'r> {
19975 request: Request<'r>,
19976}
19977impl<'r> OpLinecardSetDo<'r> {
19978 pub fn new(mut request: Request<'r>) -> Self {
19979 Self::write_header(request.buf_mut());
19980 Self { request: request }
19981 }
19982 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
19983 Self::write_header(buf);
19984 PushDevlink::new(buf)
19985 }
19986 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
19987 PushDevlink::new(self.request.buf_mut())
19988 }
19989 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
19990 PushDevlink::new(self.request.buf)
19991 }
19992 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
19993 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
19994 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
19995 }
19996 fn write_header<Prev: Pusher>(prev: &mut Prev) {
19997 let mut header = BuiltinNfgenmsg::new();
19998 header.cmd = 79u8;
19999 header.version = 1u8;
20000 prev.as_vec_mut().extend(header.as_slice());
20001 }
20002}
20003impl NetlinkRequest for OpLinecardSetDo<'_> {
20004 fn protocol(&self) -> Protocol {
20005 Protocol::Generic("devlink".as_bytes())
20006 }
20007 fn flags(&self) -> u16 {
20008 self.request.flags
20009 }
20010 fn payload(&self) -> &[u8] {
20011 self.request.buf()
20012 }
20013 type ReplyType<'buf> = IterableDevlink<'buf>;
20014 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
20015 Self::decode_request(buf)
20016 }
20017 fn lookup(
20018 buf: &[u8],
20019 offset: usize,
20020 missing_type: Option<u16>,
20021 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
20022 Self::decode_request(buf).lookup_attr(offset, missing_type)
20023 }
20024}
20025#[doc = "Get device selftest instances.\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
20026#[derive(Debug)]
20027pub struct OpSelftestsGetDump<'r> {
20028 request: Request<'r>,
20029}
20030impl<'r> OpSelftestsGetDump<'r> {
20031 pub fn new(mut request: Request<'r>) -> Self {
20032 Self::write_header(request.buf_mut());
20033 Self {
20034 request: request.set_dump(),
20035 }
20036 }
20037 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
20038 Self::write_header(buf);
20039 PushDevlink::new(buf)
20040 }
20041 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
20042 PushDevlink::new(self.request.buf_mut())
20043 }
20044 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
20045 PushDevlink::new(self.request.buf)
20046 }
20047 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
20048 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
20049 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
20050 }
20051 fn write_header<Prev: Pusher>(prev: &mut Prev) {
20052 let mut header = BuiltinNfgenmsg::new();
20053 header.cmd = 82u8;
20054 header.version = 1u8;
20055 prev.as_vec_mut().extend(header.as_slice());
20056 }
20057}
20058impl NetlinkRequest for OpSelftestsGetDump<'_> {
20059 fn protocol(&self) -> Protocol {
20060 Protocol::Generic("devlink".as_bytes())
20061 }
20062 fn flags(&self) -> u16 {
20063 self.request.flags
20064 }
20065 fn payload(&self) -> &[u8] {
20066 self.request.buf()
20067 }
20068 type ReplyType<'buf> = IterableDevlink<'buf>;
20069 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
20070 Self::decode_request(buf)
20071 }
20072 fn lookup(
20073 buf: &[u8],
20074 offset: usize,
20075 missing_type: Option<u16>,
20076 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
20077 Self::decode_request(buf).lookup_attr(offset, missing_type)
20078 }
20079}
20080#[doc = "Get device selftest instances.\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
20081#[derive(Debug)]
20082pub struct OpSelftestsGetDo<'r> {
20083 request: Request<'r>,
20084}
20085impl<'r> OpSelftestsGetDo<'r> {
20086 pub fn new(mut request: Request<'r>) -> Self {
20087 Self::write_header(request.buf_mut());
20088 Self { request: request }
20089 }
20090 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
20091 Self::write_header(buf);
20092 PushDevlink::new(buf)
20093 }
20094 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
20095 PushDevlink::new(self.request.buf_mut())
20096 }
20097 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
20098 PushDevlink::new(self.request.buf)
20099 }
20100 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
20101 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
20102 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
20103 }
20104 fn write_header<Prev: Pusher>(prev: &mut Prev) {
20105 let mut header = BuiltinNfgenmsg::new();
20106 header.cmd = 82u8;
20107 header.version = 1u8;
20108 prev.as_vec_mut().extend(header.as_slice());
20109 }
20110}
20111impl NetlinkRequest for OpSelftestsGetDo<'_> {
20112 fn protocol(&self) -> Protocol {
20113 Protocol::Generic("devlink".as_bytes())
20114 }
20115 fn flags(&self) -> u16 {
20116 self.request.flags
20117 }
20118 fn payload(&self) -> &[u8] {
20119 self.request.buf()
20120 }
20121 type ReplyType<'buf> = IterableDevlink<'buf>;
20122 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
20123 Self::decode_request(buf)
20124 }
20125 fn lookup(
20126 buf: &[u8],
20127 offset: usize,
20128 missing_type: Option<u16>,
20129 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
20130 Self::decode_request(buf).lookup_attr(offset, missing_type)
20131 }
20132}
20133#[doc = "Run device selftest instances.\n\nFlags: admin-perm\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.nested_selftests()](PushDevlink::nested_selftests)\n- [.push_index()](PushDevlink::push_index)\n\n"]
20134#[derive(Debug)]
20135pub struct OpSelftestsRunDo<'r> {
20136 request: Request<'r>,
20137}
20138impl<'r> OpSelftestsRunDo<'r> {
20139 pub fn new(mut request: Request<'r>) -> Self {
20140 Self::write_header(request.buf_mut());
20141 Self { request: request }
20142 }
20143 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
20144 Self::write_header(buf);
20145 PushDevlink::new(buf)
20146 }
20147 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
20148 PushDevlink::new(self.request.buf_mut())
20149 }
20150 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
20151 PushDevlink::new(self.request.buf)
20152 }
20153 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
20154 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
20155 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
20156 }
20157 fn write_header<Prev: Pusher>(prev: &mut Prev) {
20158 let mut header = BuiltinNfgenmsg::new();
20159 header.cmd = 83u8;
20160 header.version = 1u8;
20161 prev.as_vec_mut().extend(header.as_slice());
20162 }
20163}
20164impl NetlinkRequest for OpSelftestsRunDo<'_> {
20165 fn protocol(&self) -> Protocol {
20166 Protocol::Generic("devlink".as_bytes())
20167 }
20168 fn flags(&self) -> u16 {
20169 self.request.flags
20170 }
20171 fn payload(&self) -> &[u8] {
20172 self.request.buf()
20173 }
20174 type ReplyType<'buf> = IterableDevlink<'buf>;
20175 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
20176 Self::decode_request(buf)
20177 }
20178 fn lookup(
20179 buf: &[u8],
20180 offset: usize,
20181 missing_type: Option<u16>,
20182 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
20183 Self::decode_request(buf).lookup_attr(offset, missing_type)
20184 }
20185}
20186#[doc = "Set notification messages socket filter.\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_port_index()](PushDevlink::push_port_index)\n- [.push_index()](PushDevlink::push_index)\n\n"]
20187#[derive(Debug)]
20188pub struct OpNotifyFilterSetDo<'r> {
20189 request: Request<'r>,
20190}
20191impl<'r> OpNotifyFilterSetDo<'r> {
20192 pub fn new(mut request: Request<'r>) -> Self {
20193 Self::write_header(request.buf_mut());
20194 Self { request: request }
20195 }
20196 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
20197 Self::write_header(buf);
20198 PushDevlink::new(buf)
20199 }
20200 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
20201 PushDevlink::new(self.request.buf_mut())
20202 }
20203 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
20204 PushDevlink::new(self.request.buf)
20205 }
20206 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
20207 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
20208 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
20209 }
20210 fn write_header<Prev: Pusher>(prev: &mut Prev) {
20211 let mut header = BuiltinNfgenmsg::new();
20212 header.cmd = 84u8;
20213 header.version = 1u8;
20214 prev.as_vec_mut().extend(header.as_slice());
20215 }
20216}
20217impl NetlinkRequest for OpNotifyFilterSetDo<'_> {
20218 fn protocol(&self) -> Protocol {
20219 Protocol::Generic("devlink".as_bytes())
20220 }
20221 fn flags(&self) -> u16 {
20222 self.request.flags
20223 }
20224 fn payload(&self) -> &[u8] {
20225 self.request.buf()
20226 }
20227 type ReplyType<'buf> = IterableDevlink<'buf>;
20228 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
20229 Self::decode_request(buf)
20230 }
20231 fn lookup(
20232 buf: &[u8],
20233 offset: usize,
20234 missing_type: Option<u16>,
20235 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
20236 Self::decode_request(buf).lookup_attr(offset, missing_type)
20237 }
20238}
20239use crate::traits::LookupFn;
20240use crate::utils::RequestBuf;
20241#[derive(Debug)]
20242pub struct Request<'buf> {
20243 buf: RequestBuf<'buf>,
20244 flags: u16,
20245 writeback: Option<&'buf mut Option<RequestInfo>>,
20246}
20247#[allow(unused)]
20248#[derive(Debug, Clone)]
20249pub struct RequestInfo {
20250 protocol: Protocol,
20251 flags: u16,
20252 name: &'static str,
20253 lookup: LookupFn,
20254}
20255impl Request<'static> {
20256 pub fn new() -> Self {
20257 Self::new_from_buf(Vec::new())
20258 }
20259 pub fn new_from_buf(buf: Vec<u8>) -> Self {
20260 Self {
20261 flags: 0,
20262 buf: RequestBuf::Own(buf),
20263 writeback: None,
20264 }
20265 }
20266 pub fn into_buf(self) -> Vec<u8> {
20267 match self.buf {
20268 RequestBuf::Own(buf) => buf,
20269 _ => unreachable!(),
20270 }
20271 }
20272}
20273impl<'buf> Request<'buf> {
20274 pub fn new_with_buf(buf: &'buf mut Vec<u8>) -> Self {
20275 buf.clear();
20276 Self::new_extend(buf)
20277 }
20278 pub fn new_extend(buf: &'buf mut Vec<u8>) -> Self {
20279 Self {
20280 flags: 0,
20281 buf: RequestBuf::Ref(buf),
20282 writeback: None,
20283 }
20284 }
20285 fn do_writeback(&mut self, protocol: Protocol, name: &'static str, lookup: LookupFn) {
20286 let Some(writeback) = &mut self.writeback else {
20287 return;
20288 };
20289 **writeback = Some(RequestInfo {
20290 protocol,
20291 flags: self.flags,
20292 name,
20293 lookup,
20294 })
20295 }
20296 pub fn buf(&self) -> &Vec<u8> {
20297 self.buf.buf()
20298 }
20299 pub fn buf_mut(&mut self) -> &mut Vec<u8> {
20300 self.buf.buf_mut()
20301 }
20302 #[doc = "Set `NLM_F_CREATE` flag"]
20303 pub fn set_create(mut self) -> Self {
20304 self.flags |= consts::NLM_F_CREATE as u16;
20305 self
20306 }
20307 #[doc = "Set `NLM_F_EXCL` flag"]
20308 pub fn set_excl(mut self) -> Self {
20309 self.flags |= consts::NLM_F_EXCL as u16;
20310 self
20311 }
20312 #[doc = "Set `NLM_F_REPLACE` flag"]
20313 pub fn set_replace(mut self) -> Self {
20314 self.flags |= consts::NLM_F_REPLACE as u16;
20315 self
20316 }
20317 #[doc = "Set `NLM_F_CREATE` and `NLM_F_REPLACE` flag"]
20318 pub fn set_change(self) -> Self {
20319 self.set_create().set_replace()
20320 }
20321 #[doc = "Set `NLM_F_APPEND` flag"]
20322 pub fn set_append(mut self) -> Self {
20323 self.flags |= consts::NLM_F_APPEND as u16;
20324 self
20325 }
20326 #[doc = "Set `self.flags |= flags`"]
20327 pub fn set_flags(mut self, flags: u16) -> Self {
20328 self.flags |= flags;
20329 self
20330 }
20331 #[doc = "Set `self.flags ^= self.flags & flags`"]
20332 pub fn unset_flags(mut self, flags: u16) -> Self {
20333 self.flags ^= self.flags & flags;
20334 self
20335 }
20336 #[doc = "Set `NLM_F_DUMP` flag"]
20337 fn set_dump(mut self) -> Self {
20338 self.flags |= consts::NLM_F_DUMP as u16;
20339 self
20340 }
20341 #[doc = "Get devlink instances.\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_reload_failed()](IterableDevlink::get_reload_failed)\n- [.get_dev_stats()](IterableDevlink::get_dev_stats)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
20342 pub fn op_get_dump(self) -> OpGetDump<'buf> {
20343 let mut res = OpGetDump::new(self);
20344 res.request
20345 .do_writeback(res.protocol(), "op-get-dump", OpGetDump::lookup);
20346 res
20347 }
20348 #[doc = "Get devlink instances.\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_reload_failed()](IterableDevlink::get_reload_failed)\n- [.get_dev_stats()](IterableDevlink::get_dev_stats)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
20349 pub fn op_get_do(self) -> OpGetDo<'buf> {
20350 let mut res = OpGetDo::new(self);
20351 res.request
20352 .do_writeback(res.protocol(), "op-get-do", OpGetDo::lookup);
20353 res
20354 }
20355 #[doc = "Get devlink port instances.\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_port_index()](IterableDevlink::get_port_index)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
20356 pub fn op_port_get_dump(self) -> OpPortGetDump<'buf> {
20357 let mut res = OpPortGetDump::new(self);
20358 res.request
20359 .do_writeback(res.protocol(), "op-port-get-dump", OpPortGetDump::lookup);
20360 res
20361 }
20362 #[doc = "Get devlink port instances.\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_port_index()](PushDevlink::push_port_index)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_port_index()](IterableDevlink::get_port_index)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
20363 pub fn op_port_get_do(self) -> OpPortGetDo<'buf> {
20364 let mut res = OpPortGetDo::new(self);
20365 res.request
20366 .do_writeback(res.protocol(), "op-port-get-do", OpPortGetDo::lookup);
20367 res
20368 }
20369 #[doc = "Set devlink port instances.\n\nFlags: admin-perm\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_port_index()](PushDevlink::push_port_index)\n- [.push_port_type()](PushDevlink::push_port_type)\n- [.nested_port_function()](PushDevlink::nested_port_function)\n- [.push_index()](PushDevlink::push_index)\n\n"]
20370 pub fn op_port_set_do(self) -> OpPortSetDo<'buf> {
20371 let mut res = OpPortSetDo::new(self);
20372 res.request
20373 .do_writeback(res.protocol(), "op-port-set-do", OpPortSetDo::lookup);
20374 res
20375 }
20376 #[doc = "Create devlink port instances.\n\nFlags: admin-perm\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_port_index()](PushDevlink::push_port_index)\n- [.push_port_flavour()](PushDevlink::push_port_flavour)\n- [.push_port_pci_pf_number()](PushDevlink::push_port_pci_pf_number)\n- [.push_port_controller_number()](PushDevlink::push_port_controller_number)\n- [.push_port_pci_sf_number()](PushDevlink::push_port_pci_sf_number)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_port_index()](IterableDevlink::get_port_index)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
20377 pub fn op_port_new_do(self) -> OpPortNewDo<'buf> {
20378 let mut res = OpPortNewDo::new(self);
20379 res.request
20380 .do_writeback(res.protocol(), "op-port-new-do", OpPortNewDo::lookup);
20381 res
20382 }
20383 #[doc = "Delete devlink port instances.\n\nFlags: admin-perm\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_port_index()](PushDevlink::push_port_index)\n- [.push_index()](PushDevlink::push_index)\n\n"]
20384 pub fn op_port_del_do(self) -> OpPortDelDo<'buf> {
20385 let mut res = OpPortDelDo::new(self);
20386 res.request
20387 .do_writeback(res.protocol(), "op-port-del-do", OpPortDelDo::lookup);
20388 res
20389 }
20390 #[doc = "Split devlink port instances.\n\nFlags: admin-perm\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_port_index()](PushDevlink::push_port_index)\n- [.push_port_split_count()](PushDevlink::push_port_split_count)\n- [.push_index()](PushDevlink::push_index)\n\n"]
20391 pub fn op_port_split_do(self) -> OpPortSplitDo<'buf> {
20392 let mut res = OpPortSplitDo::new(self);
20393 res.request
20394 .do_writeback(res.protocol(), "op-port-split-do", OpPortSplitDo::lookup);
20395 res
20396 }
20397 #[doc = "Unplit devlink port instances.\n\nFlags: admin-perm\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_port_index()](PushDevlink::push_port_index)\n- [.push_index()](PushDevlink::push_index)\n\n"]
20398 pub fn op_port_unsplit_do(self) -> OpPortUnsplitDo<'buf> {
20399 let mut res = OpPortUnsplitDo::new(self);
20400 res.request.do_writeback(
20401 res.protocol(),
20402 "op-port-unsplit-do",
20403 OpPortUnsplitDo::lookup,
20404 );
20405 res
20406 }
20407 #[doc = "Get shared buffer instances.\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_sb_index()](IterableDevlink::get_sb_index)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
20408 pub fn op_sb_get_dump(self) -> OpSbGetDump<'buf> {
20409 let mut res = OpSbGetDump::new(self);
20410 res.request
20411 .do_writeback(res.protocol(), "op-sb-get-dump", OpSbGetDump::lookup);
20412 res
20413 }
20414 #[doc = "Get shared buffer instances.\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_sb_index()](PushDevlink::push_sb_index)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_sb_index()](IterableDevlink::get_sb_index)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
20415 pub fn op_sb_get_do(self) -> OpSbGetDo<'buf> {
20416 let mut res = OpSbGetDo::new(self);
20417 res.request
20418 .do_writeback(res.protocol(), "op-sb-get-do", OpSbGetDo::lookup);
20419 res
20420 }
20421 #[doc = "Get shared buffer pool instances.\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_sb_index()](IterableDevlink::get_sb_index)\n- [.get_sb_pool_index()](IterableDevlink::get_sb_pool_index)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
20422 pub fn op_sb_pool_get_dump(self) -> OpSbPoolGetDump<'buf> {
20423 let mut res = OpSbPoolGetDump::new(self);
20424 res.request.do_writeback(
20425 res.protocol(),
20426 "op-sb-pool-get-dump",
20427 OpSbPoolGetDump::lookup,
20428 );
20429 res
20430 }
20431 #[doc = "Get shared buffer pool instances.\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_sb_index()](PushDevlink::push_sb_index)\n- [.push_sb_pool_index()](PushDevlink::push_sb_pool_index)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_sb_index()](IterableDevlink::get_sb_index)\n- [.get_sb_pool_index()](IterableDevlink::get_sb_pool_index)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
20432 pub fn op_sb_pool_get_do(self) -> OpSbPoolGetDo<'buf> {
20433 let mut res = OpSbPoolGetDo::new(self);
20434 res.request
20435 .do_writeback(res.protocol(), "op-sb-pool-get-do", OpSbPoolGetDo::lookup);
20436 res
20437 }
20438 #[doc = "Set shared buffer pool instances.\n\nFlags: admin-perm\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_sb_index()](PushDevlink::push_sb_index)\n- [.push_sb_pool_index()](PushDevlink::push_sb_pool_index)\n- [.push_sb_pool_size()](PushDevlink::push_sb_pool_size)\n- [.push_sb_pool_threshold_type()](PushDevlink::push_sb_pool_threshold_type)\n- [.push_index()](PushDevlink::push_index)\n\n"]
20439 pub fn op_sb_pool_set_do(self) -> OpSbPoolSetDo<'buf> {
20440 let mut res = OpSbPoolSetDo::new(self);
20441 res.request
20442 .do_writeback(res.protocol(), "op-sb-pool-set-do", OpSbPoolSetDo::lookup);
20443 res
20444 }
20445 #[doc = "Get shared buffer port-pool combinations and threshold.\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_port_index()](IterableDevlink::get_port_index)\n- [.get_sb_index()](IterableDevlink::get_sb_index)\n- [.get_sb_pool_index()](IterableDevlink::get_sb_pool_index)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
20446 pub fn op_sb_port_pool_get_dump(self) -> OpSbPortPoolGetDump<'buf> {
20447 let mut res = OpSbPortPoolGetDump::new(self);
20448 res.request.do_writeback(
20449 res.protocol(),
20450 "op-sb-port-pool-get-dump",
20451 OpSbPortPoolGetDump::lookup,
20452 );
20453 res
20454 }
20455 #[doc = "Get shared buffer port-pool combinations and threshold.\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_port_index()](PushDevlink::push_port_index)\n- [.push_sb_index()](PushDevlink::push_sb_index)\n- [.push_sb_pool_index()](PushDevlink::push_sb_pool_index)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_port_index()](IterableDevlink::get_port_index)\n- [.get_sb_index()](IterableDevlink::get_sb_index)\n- [.get_sb_pool_index()](IterableDevlink::get_sb_pool_index)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
20456 pub fn op_sb_port_pool_get_do(self) -> OpSbPortPoolGetDo<'buf> {
20457 let mut res = OpSbPortPoolGetDo::new(self);
20458 res.request.do_writeback(
20459 res.protocol(),
20460 "op-sb-port-pool-get-do",
20461 OpSbPortPoolGetDo::lookup,
20462 );
20463 res
20464 }
20465 #[doc = "Set shared buffer port-pool combinations and threshold.\n\nFlags: admin-perm\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_port_index()](PushDevlink::push_port_index)\n- [.push_sb_index()](PushDevlink::push_sb_index)\n- [.push_sb_pool_index()](PushDevlink::push_sb_pool_index)\n- [.push_sb_threshold()](PushDevlink::push_sb_threshold)\n- [.push_index()](PushDevlink::push_index)\n\n"]
20466 pub fn op_sb_port_pool_set_do(self) -> OpSbPortPoolSetDo<'buf> {
20467 let mut res = OpSbPortPoolSetDo::new(self);
20468 res.request.do_writeback(
20469 res.protocol(),
20470 "op-sb-port-pool-set-do",
20471 OpSbPortPoolSetDo::lookup,
20472 );
20473 res
20474 }
20475 #[doc = "Get shared buffer port-TC to pool bindings and threshold.\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_port_index()](IterableDevlink::get_port_index)\n- [.get_sb_index()](IterableDevlink::get_sb_index)\n- [.get_sb_pool_type()](IterableDevlink::get_sb_pool_type)\n- [.get_sb_tc_index()](IterableDevlink::get_sb_tc_index)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
20476 pub fn op_sb_tc_pool_bind_get_dump(self) -> OpSbTcPoolBindGetDump<'buf> {
20477 let mut res = OpSbTcPoolBindGetDump::new(self);
20478 res.request.do_writeback(
20479 res.protocol(),
20480 "op-sb-tc-pool-bind-get-dump",
20481 OpSbTcPoolBindGetDump::lookup,
20482 );
20483 res
20484 }
20485 #[doc = "Get shared buffer port-TC to pool bindings and threshold.\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_port_index()](PushDevlink::push_port_index)\n- [.push_sb_index()](PushDevlink::push_sb_index)\n- [.push_sb_pool_type()](PushDevlink::push_sb_pool_type)\n- [.push_sb_tc_index()](PushDevlink::push_sb_tc_index)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_port_index()](IterableDevlink::get_port_index)\n- [.get_sb_index()](IterableDevlink::get_sb_index)\n- [.get_sb_pool_type()](IterableDevlink::get_sb_pool_type)\n- [.get_sb_tc_index()](IterableDevlink::get_sb_tc_index)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
20486 pub fn op_sb_tc_pool_bind_get_do(self) -> OpSbTcPoolBindGetDo<'buf> {
20487 let mut res = OpSbTcPoolBindGetDo::new(self);
20488 res.request.do_writeback(
20489 res.protocol(),
20490 "op-sb-tc-pool-bind-get-do",
20491 OpSbTcPoolBindGetDo::lookup,
20492 );
20493 res
20494 }
20495 #[doc = "Set shared buffer port-TC to pool bindings and threshold.\n\nFlags: admin-perm\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_port_index()](PushDevlink::push_port_index)\n- [.push_sb_index()](PushDevlink::push_sb_index)\n- [.push_sb_pool_index()](PushDevlink::push_sb_pool_index)\n- [.push_sb_pool_type()](PushDevlink::push_sb_pool_type)\n- [.push_sb_threshold()](PushDevlink::push_sb_threshold)\n- [.push_sb_tc_index()](PushDevlink::push_sb_tc_index)\n- [.push_index()](PushDevlink::push_index)\n\n"]
20496 pub fn op_sb_tc_pool_bind_set_do(self) -> OpSbTcPoolBindSetDo<'buf> {
20497 let mut res = OpSbTcPoolBindSetDo::new(self);
20498 res.request.do_writeback(
20499 res.protocol(),
20500 "op-sb-tc-pool-bind-set-do",
20501 OpSbTcPoolBindSetDo::lookup,
20502 );
20503 res
20504 }
20505 #[doc = "Take occupancy snapshot of shared buffer.\n\nFlags: admin-perm\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_sb_index()](PushDevlink::push_sb_index)\n- [.push_index()](PushDevlink::push_index)\n\n"]
20506 pub fn op_sb_occ_snapshot_do(self) -> OpSbOccSnapshotDo<'buf> {
20507 let mut res = OpSbOccSnapshotDo::new(self);
20508 res.request.do_writeback(
20509 res.protocol(),
20510 "op-sb-occ-snapshot-do",
20511 OpSbOccSnapshotDo::lookup,
20512 );
20513 res
20514 }
20515 #[doc = "Clear occupancy watermarks of shared buffer.\n\nFlags: admin-perm\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_sb_index()](PushDevlink::push_sb_index)\n- [.push_index()](PushDevlink::push_index)\n\n"]
20516 pub fn op_sb_occ_max_clear_do(self) -> OpSbOccMaxClearDo<'buf> {
20517 let mut res = OpSbOccMaxClearDo::new(self);
20518 res.request.do_writeback(
20519 res.protocol(),
20520 "op-sb-occ-max-clear-do",
20521 OpSbOccMaxClearDo::lookup,
20522 );
20523 res
20524 }
20525 #[doc = "Get eswitch attributes.\n\nFlags: admin-perm\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_eswitch_mode()](IterableDevlink::get_eswitch_mode)\n- [.get_eswitch_inline_mode()](IterableDevlink::get_eswitch_inline_mode)\n- [.get_eswitch_encap_mode()](IterableDevlink::get_eswitch_encap_mode)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
20526 pub fn op_eswitch_get_do(self) -> OpEswitchGetDo<'buf> {
20527 let mut res = OpEswitchGetDo::new(self);
20528 res.request
20529 .do_writeback(res.protocol(), "op-eswitch-get-do", OpEswitchGetDo::lookup);
20530 res
20531 }
20532 #[doc = "Set eswitch attributes.\n\nFlags: admin-perm\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_eswitch_mode()](PushDevlink::push_eswitch_mode)\n- [.push_eswitch_inline_mode()](PushDevlink::push_eswitch_inline_mode)\n- [.push_eswitch_encap_mode()](PushDevlink::push_eswitch_encap_mode)\n- [.push_index()](PushDevlink::push_index)\n\n"]
20533 pub fn op_eswitch_set_do(self) -> OpEswitchSetDo<'buf> {
20534 let mut res = OpEswitchSetDo::new(self);
20535 res.request
20536 .do_writeback(res.protocol(), "op-eswitch-set-do", OpEswitchSetDo::lookup);
20537 res
20538 }
20539 #[doc = "Get dpipe table attributes.\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_dpipe_table_name()](PushDevlink::push_dpipe_table_name)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_dpipe_tables()](IterableDevlink::get_dpipe_tables)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
20540 pub fn op_dpipe_table_get_do(self) -> OpDpipeTableGetDo<'buf> {
20541 let mut res = OpDpipeTableGetDo::new(self);
20542 res.request.do_writeback(
20543 res.protocol(),
20544 "op-dpipe-table-get-do",
20545 OpDpipeTableGetDo::lookup,
20546 );
20547 res
20548 }
20549 #[doc = "Get dpipe entries attributes.\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_dpipe_table_name()](PushDevlink::push_dpipe_table_name)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_dpipe_entries()](IterableDevlink::get_dpipe_entries)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
20550 pub fn op_dpipe_entries_get_do(self) -> OpDpipeEntriesGetDo<'buf> {
20551 let mut res = OpDpipeEntriesGetDo::new(self);
20552 res.request.do_writeback(
20553 res.protocol(),
20554 "op-dpipe-entries-get-do",
20555 OpDpipeEntriesGetDo::lookup,
20556 );
20557 res
20558 }
20559 #[doc = "Get dpipe headers attributes.\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_dpipe_headers()](IterableDevlink::get_dpipe_headers)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
20560 pub fn op_dpipe_headers_get_do(self) -> OpDpipeHeadersGetDo<'buf> {
20561 let mut res = OpDpipeHeadersGetDo::new(self);
20562 res.request.do_writeback(
20563 res.protocol(),
20564 "op-dpipe-headers-get-do",
20565 OpDpipeHeadersGetDo::lookup,
20566 );
20567 res
20568 }
20569 #[doc = "Set dpipe counter attributes.\n\nFlags: admin-perm\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_dpipe_table_name()](PushDevlink::push_dpipe_table_name)\n- [.push_dpipe_table_counters_enabled()](PushDevlink::push_dpipe_table_counters_enabled)\n- [.push_index()](PushDevlink::push_index)\n\n"]
20570 pub fn op_dpipe_table_counters_set_do(self) -> OpDpipeTableCountersSetDo<'buf> {
20571 let mut res = OpDpipeTableCountersSetDo::new(self);
20572 res.request.do_writeback(
20573 res.protocol(),
20574 "op-dpipe-table-counters-set-do",
20575 OpDpipeTableCountersSetDo::lookup,
20576 );
20577 res
20578 }
20579 #[doc = "Set resource attributes.\n\nFlags: admin-perm\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_resource_id()](PushDevlink::push_resource_id)\n- [.push_resource_size()](PushDevlink::push_resource_size)\n- [.push_index()](PushDevlink::push_index)\n\n"]
20580 pub fn op_resource_set_do(self) -> OpResourceSetDo<'buf> {
20581 let mut res = OpResourceSetDo::new(self);
20582 res.request.do_writeback(
20583 res.protocol(),
20584 "op-resource-set-do",
20585 OpResourceSetDo::lookup,
20586 );
20587 res
20588 }
20589 #[doc = "Get resource attributes.\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_index()](PushDevlink::push_index)\n- [.push_resource_scope_mask()](PushDevlink::push_resource_scope_mask)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_port_index()](IterableDevlink::get_port_index)\n- [.get_resource_list()](IterableDevlink::get_resource_list)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
20590 pub fn op_resource_dump_dump(self) -> OpResourceDumpDump<'buf> {
20591 let mut res = OpResourceDumpDump::new(self);
20592 res.request.do_writeback(
20593 res.protocol(),
20594 "op-resource-dump-dump",
20595 OpResourceDumpDump::lookup,
20596 );
20597 res
20598 }
20599 #[doc = "Get resource attributes.\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_port_index()](PushDevlink::push_port_index)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_port_index()](IterableDevlink::get_port_index)\n- [.get_resource_list()](IterableDevlink::get_resource_list)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
20600 pub fn op_resource_dump_do(self) -> OpResourceDumpDo<'buf> {
20601 let mut res = OpResourceDumpDo::new(self);
20602 res.request.do_writeback(
20603 res.protocol(),
20604 "op-resource-dump-do",
20605 OpResourceDumpDo::lookup,
20606 );
20607 res
20608 }
20609 #[doc = "Reload devlink.\n\nFlags: admin-perm\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_netns_fd()](PushDevlink::push_netns_fd)\n- [.push_netns_pid()](PushDevlink::push_netns_pid)\n- [.push_netns_id()](PushDevlink::push_netns_id)\n- [.push_reload_action()](PushDevlink::push_reload_action)\n- [.push_reload_limits()](PushDevlink::push_reload_limits)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_reload_actions_performed()](IterableDevlink::get_reload_actions_performed)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
20610 pub fn op_reload_do(self) -> OpReloadDo<'buf> {
20611 let mut res = OpReloadDo::new(self);
20612 res.request
20613 .do_writeback(res.protocol(), "op-reload-do", OpReloadDo::lookup);
20614 res
20615 }
20616 #[doc = "Get param instances.\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_param_name()](IterableDevlink::get_param_name)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
20617 pub fn op_param_get_dump(self) -> OpParamGetDump<'buf> {
20618 let mut res = OpParamGetDump::new(self);
20619 res.request
20620 .do_writeback(res.protocol(), "op-param-get-dump", OpParamGetDump::lookup);
20621 res
20622 }
20623 #[doc = "Get param instances.\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_param_name()](PushDevlink::push_param_name)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_param_name()](IterableDevlink::get_param_name)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
20624 pub fn op_param_get_do(self) -> OpParamGetDo<'buf> {
20625 let mut res = OpParamGetDo::new(self);
20626 res.request
20627 .do_writeback(res.protocol(), "op-param-get-do", OpParamGetDo::lookup);
20628 res
20629 }
20630 #[doc = "Set param instances.\n\nFlags: admin-perm\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_param_name()](PushDevlink::push_param_name)\n- [.push_param_type()](PushDevlink::push_param_type)\n- [.push_param_value_cmode()](PushDevlink::push_param_value_cmode)\n- [.push_param_reset_default()](PushDevlink::push_param_reset_default)\n- [.push_index()](PushDevlink::push_index)\n\n"]
20631 pub fn op_param_set_do(self) -> OpParamSetDo<'buf> {
20632 let mut res = OpParamSetDo::new(self);
20633 res.request
20634 .do_writeback(res.protocol(), "op-param-set-do", OpParamSetDo::lookup);
20635 res
20636 }
20637 #[doc = "Get region instances.\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_port_index()](IterableDevlink::get_port_index)\n- [.get_region_name()](IterableDevlink::get_region_name)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
20638 pub fn op_region_get_dump(self) -> OpRegionGetDump<'buf> {
20639 let mut res = OpRegionGetDump::new(self);
20640 res.request.do_writeback(
20641 res.protocol(),
20642 "op-region-get-dump",
20643 OpRegionGetDump::lookup,
20644 );
20645 res
20646 }
20647 #[doc = "Get region instances.\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_port_index()](PushDevlink::push_port_index)\n- [.push_region_name()](PushDevlink::push_region_name)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_port_index()](IterableDevlink::get_port_index)\n- [.get_region_name()](IterableDevlink::get_region_name)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
20648 pub fn op_region_get_do(self) -> OpRegionGetDo<'buf> {
20649 let mut res = OpRegionGetDo::new(self);
20650 res.request
20651 .do_writeback(res.protocol(), "op-region-get-do", OpRegionGetDo::lookup);
20652 res
20653 }
20654 #[doc = "Create region snapshot.\n\nFlags: admin-perm\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_port_index()](PushDevlink::push_port_index)\n- [.push_region_name()](PushDevlink::push_region_name)\n- [.push_region_snapshot_id()](PushDevlink::push_region_snapshot_id)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_port_index()](IterableDevlink::get_port_index)\n- [.get_region_name()](IterableDevlink::get_region_name)\n- [.get_region_snapshot_id()](IterableDevlink::get_region_snapshot_id)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
20655 pub fn op_region_new_do(self) -> OpRegionNewDo<'buf> {
20656 let mut res = OpRegionNewDo::new(self);
20657 res.request
20658 .do_writeback(res.protocol(), "op-region-new-do", OpRegionNewDo::lookup);
20659 res
20660 }
20661 #[doc = "Delete region snapshot.\n\nFlags: admin-perm\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_port_index()](PushDevlink::push_port_index)\n- [.push_region_name()](PushDevlink::push_region_name)\n- [.push_region_snapshot_id()](PushDevlink::push_region_snapshot_id)\n- [.push_index()](PushDevlink::push_index)\n\n"]
20662 pub fn op_region_del_do(self) -> OpRegionDelDo<'buf> {
20663 let mut res = OpRegionDelDo::new(self);
20664 res.request
20665 .do_writeback(res.protocol(), "op-region-del-do", OpRegionDelDo::lookup);
20666 res
20667 }
20668 #[doc = "Read region data.\n\nFlags: admin-perm\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_port_index()](PushDevlink::push_port_index)\n- [.push_region_name()](PushDevlink::push_region_name)\n- [.push_region_snapshot_id()](PushDevlink::push_region_snapshot_id)\n- [.push_region_chunk_addr()](PushDevlink::push_region_chunk_addr)\n- [.push_region_chunk_len()](PushDevlink::push_region_chunk_len)\n- [.push_region_direct()](PushDevlink::push_region_direct)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_port_index()](IterableDevlink::get_port_index)\n- [.get_region_name()](IterableDevlink::get_region_name)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
20669 pub fn op_region_read_dump(self) -> OpRegionReadDump<'buf> {
20670 let mut res = OpRegionReadDump::new(self);
20671 res.request.do_writeback(
20672 res.protocol(),
20673 "op-region-read-dump",
20674 OpRegionReadDump::lookup,
20675 );
20676 res
20677 }
20678 #[doc = "Get port param instances.\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_port_index()](IterableDevlink::get_port_index)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
20679 pub fn op_port_param_get_dump(self) -> OpPortParamGetDump<'buf> {
20680 let mut res = OpPortParamGetDump::new(self);
20681 res.request.do_writeback(
20682 res.protocol(),
20683 "op-port-param-get-dump",
20684 OpPortParamGetDump::lookup,
20685 );
20686 res
20687 }
20688 #[doc = "Get port param instances.\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_port_index()](PushDevlink::push_port_index)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_port_index()](IterableDevlink::get_port_index)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
20689 pub fn op_port_param_get_do(self) -> OpPortParamGetDo<'buf> {
20690 let mut res = OpPortParamGetDo::new(self);
20691 res.request.do_writeback(
20692 res.protocol(),
20693 "op-port-param-get-do",
20694 OpPortParamGetDo::lookup,
20695 );
20696 res
20697 }
20698 #[doc = "Set port param instances.\n\nFlags: admin-perm\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_port_index()](PushDevlink::push_port_index)\n- [.push_index()](PushDevlink::push_index)\n\n"]
20699 pub fn op_port_param_set_do(self) -> OpPortParamSetDo<'buf> {
20700 let mut res = OpPortParamSetDo::new(self);
20701 res.request.do_writeback(
20702 res.protocol(),
20703 "op-port-param-set-do",
20704 OpPortParamSetDo::lookup,
20705 );
20706 res
20707 }
20708 #[doc = "Get device information, like driver name, hardware and firmware versions\netc.\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_info_driver_name()](IterableDevlink::get_info_driver_name)\n- [.get_info_serial_number()](IterableDevlink::get_info_serial_number)\n- [.get_info_version_fixed()](IterableDevlink::get_info_version_fixed)\n- [.get_info_version_running()](IterableDevlink::get_info_version_running)\n- [.get_info_version_stored()](IterableDevlink::get_info_version_stored)\n- [.get_info_board_serial_number()](IterableDevlink::get_info_board_serial_number)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
20709 pub fn op_info_get_dump(self) -> OpInfoGetDump<'buf> {
20710 let mut res = OpInfoGetDump::new(self);
20711 res.request
20712 .do_writeback(res.protocol(), "op-info-get-dump", OpInfoGetDump::lookup);
20713 res
20714 }
20715 #[doc = "Get device information, like driver name, hardware and firmware versions\netc.\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_info_driver_name()](IterableDevlink::get_info_driver_name)\n- [.get_info_serial_number()](IterableDevlink::get_info_serial_number)\n- [.get_info_version_fixed()](IterableDevlink::get_info_version_fixed)\n- [.get_info_version_running()](IterableDevlink::get_info_version_running)\n- [.get_info_version_stored()](IterableDevlink::get_info_version_stored)\n- [.get_info_board_serial_number()](IterableDevlink::get_info_board_serial_number)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
20716 pub fn op_info_get_do(self) -> OpInfoGetDo<'buf> {
20717 let mut res = OpInfoGetDo::new(self);
20718 res.request
20719 .do_writeback(res.protocol(), "op-info-get-do", OpInfoGetDo::lookup);
20720 res
20721 }
20722 #[doc = "Get health reporter instances.\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_port_index()](PushDevlink::push_port_index)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_port_index()](IterableDevlink::get_port_index)\n- [.get_health_reporter_name()](IterableDevlink::get_health_reporter_name)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
20723 pub fn op_health_reporter_get_dump(self) -> OpHealthReporterGetDump<'buf> {
20724 let mut res = OpHealthReporterGetDump::new(self);
20725 res.request.do_writeback(
20726 res.protocol(),
20727 "op-health-reporter-get-dump",
20728 OpHealthReporterGetDump::lookup,
20729 );
20730 res
20731 }
20732 #[doc = "Get health reporter instances.\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_port_index()](PushDevlink::push_port_index)\n- [.push_health_reporter_name()](PushDevlink::push_health_reporter_name)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_port_index()](IterableDevlink::get_port_index)\n- [.get_health_reporter_name()](IterableDevlink::get_health_reporter_name)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
20733 pub fn op_health_reporter_get_do(self) -> OpHealthReporterGetDo<'buf> {
20734 let mut res = OpHealthReporterGetDo::new(self);
20735 res.request.do_writeback(
20736 res.protocol(),
20737 "op-health-reporter-get-do",
20738 OpHealthReporterGetDo::lookup,
20739 );
20740 res
20741 }
20742 #[doc = "Set health reporter instances.\n\nFlags: admin-perm\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_port_index()](PushDevlink::push_port_index)\n- [.push_health_reporter_name()](PushDevlink::push_health_reporter_name)\n- [.push_health_reporter_graceful_period()](PushDevlink::push_health_reporter_graceful_period)\n- [.push_health_reporter_auto_recover()](PushDevlink::push_health_reporter_auto_recover)\n- [.push_health_reporter_auto_dump()](PushDevlink::push_health_reporter_auto_dump)\n- [.push_health_reporter_burst_period()](PushDevlink::push_health_reporter_burst_period)\n- [.push_index()](PushDevlink::push_index)\n\n"]
20743 pub fn op_health_reporter_set_do(self) -> OpHealthReporterSetDo<'buf> {
20744 let mut res = OpHealthReporterSetDo::new(self);
20745 res.request.do_writeback(
20746 res.protocol(),
20747 "op-health-reporter-set-do",
20748 OpHealthReporterSetDo::lookup,
20749 );
20750 res
20751 }
20752 #[doc = "Recover health reporter instances.\n\nFlags: admin-perm\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_port_index()](PushDevlink::push_port_index)\n- [.push_health_reporter_name()](PushDevlink::push_health_reporter_name)\n- [.push_index()](PushDevlink::push_index)\n\n"]
20753 pub fn op_health_reporter_recover_do(self) -> OpHealthReporterRecoverDo<'buf> {
20754 let mut res = OpHealthReporterRecoverDo::new(self);
20755 res.request.do_writeback(
20756 res.protocol(),
20757 "op-health-reporter-recover-do",
20758 OpHealthReporterRecoverDo::lookup,
20759 );
20760 res
20761 }
20762 #[doc = "Diagnose health reporter instances.\n\nFlags: admin-perm\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_port_index()](PushDevlink::push_port_index)\n- [.push_health_reporter_name()](PushDevlink::push_health_reporter_name)\n- [.push_index()](PushDevlink::push_index)\n\n"]
20763 pub fn op_health_reporter_diagnose_do(self) -> OpHealthReporterDiagnoseDo<'buf> {
20764 let mut res = OpHealthReporterDiagnoseDo::new(self);
20765 res.request.do_writeback(
20766 res.protocol(),
20767 "op-health-reporter-diagnose-do",
20768 OpHealthReporterDiagnoseDo::lookup,
20769 );
20770 res
20771 }
20772 #[doc = "Dump health reporter instances.\n\nFlags: admin-perm\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_port_index()](PushDevlink::push_port_index)\n- [.push_health_reporter_name()](PushDevlink::push_health_reporter_name)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_fmsg()](IterableDevlink::get_fmsg)\n\n"]
20773 pub fn op_health_reporter_dump_get_dump(self) -> OpHealthReporterDumpGetDump<'buf> {
20774 let mut res = OpHealthReporterDumpGetDump::new(self);
20775 res.request.do_writeback(
20776 res.protocol(),
20777 "op-health-reporter-dump-get-dump",
20778 OpHealthReporterDumpGetDump::lookup,
20779 );
20780 res
20781 }
20782 #[doc = "Clear dump of health reporter instances.\n\nFlags: admin-perm\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_port_index()](PushDevlink::push_port_index)\n- [.push_health_reporter_name()](PushDevlink::push_health_reporter_name)\n- [.push_index()](PushDevlink::push_index)\n\n"]
20783 pub fn op_health_reporter_dump_clear_do(self) -> OpHealthReporterDumpClearDo<'buf> {
20784 let mut res = OpHealthReporterDumpClearDo::new(self);
20785 res.request.do_writeback(
20786 res.protocol(),
20787 "op-health-reporter-dump-clear-do",
20788 OpHealthReporterDumpClearDo::lookup,
20789 );
20790 res
20791 }
20792 #[doc = "Flash update devlink instances.\n\nFlags: admin-perm\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_flash_update_file_name()](PushDevlink::push_flash_update_file_name)\n- [.push_flash_update_component()](PushDevlink::push_flash_update_component)\n- [.push_flash_update_overwrite_mask()](PushDevlink::push_flash_update_overwrite_mask)\n- [.push_index()](PushDevlink::push_index)\n\n"]
20793 pub fn op_flash_update_do(self) -> OpFlashUpdateDo<'buf> {
20794 let mut res = OpFlashUpdateDo::new(self);
20795 res.request.do_writeback(
20796 res.protocol(),
20797 "op-flash-update-do",
20798 OpFlashUpdateDo::lookup,
20799 );
20800 res
20801 }
20802 #[doc = "Get trap instances.\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_trap_name()](IterableDevlink::get_trap_name)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
20803 pub fn op_trap_get_dump(self) -> OpTrapGetDump<'buf> {
20804 let mut res = OpTrapGetDump::new(self);
20805 res.request
20806 .do_writeback(res.protocol(), "op-trap-get-dump", OpTrapGetDump::lookup);
20807 res
20808 }
20809 #[doc = "Get trap instances.\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_trap_name()](PushDevlink::push_trap_name)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_trap_name()](IterableDevlink::get_trap_name)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
20810 pub fn op_trap_get_do(self) -> OpTrapGetDo<'buf> {
20811 let mut res = OpTrapGetDo::new(self);
20812 res.request
20813 .do_writeback(res.protocol(), "op-trap-get-do", OpTrapGetDo::lookup);
20814 res
20815 }
20816 #[doc = "Set trap instances.\n\nFlags: admin-perm\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_trap_name()](PushDevlink::push_trap_name)\n- [.push_trap_action()](PushDevlink::push_trap_action)\n- [.push_index()](PushDevlink::push_index)\n\n"]
20817 pub fn op_trap_set_do(self) -> OpTrapSetDo<'buf> {
20818 let mut res = OpTrapSetDo::new(self);
20819 res.request
20820 .do_writeback(res.protocol(), "op-trap-set-do", OpTrapSetDo::lookup);
20821 res
20822 }
20823 #[doc = "Get trap group instances.\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_trap_group_name()](IterableDevlink::get_trap_group_name)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
20824 pub fn op_trap_group_get_dump(self) -> OpTrapGroupGetDump<'buf> {
20825 let mut res = OpTrapGroupGetDump::new(self);
20826 res.request.do_writeback(
20827 res.protocol(),
20828 "op-trap-group-get-dump",
20829 OpTrapGroupGetDump::lookup,
20830 );
20831 res
20832 }
20833 #[doc = "Get trap group instances.\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_trap_group_name()](PushDevlink::push_trap_group_name)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_trap_group_name()](IterableDevlink::get_trap_group_name)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
20834 pub fn op_trap_group_get_do(self) -> OpTrapGroupGetDo<'buf> {
20835 let mut res = OpTrapGroupGetDo::new(self);
20836 res.request.do_writeback(
20837 res.protocol(),
20838 "op-trap-group-get-do",
20839 OpTrapGroupGetDo::lookup,
20840 );
20841 res
20842 }
20843 #[doc = "Set trap group instances.\n\nFlags: admin-perm\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_trap_action()](PushDevlink::push_trap_action)\n- [.push_trap_group_name()](PushDevlink::push_trap_group_name)\n- [.push_trap_policer_id()](PushDevlink::push_trap_policer_id)\n- [.push_index()](PushDevlink::push_index)\n\n"]
20844 pub fn op_trap_group_set_do(self) -> OpTrapGroupSetDo<'buf> {
20845 let mut res = OpTrapGroupSetDo::new(self);
20846 res.request.do_writeback(
20847 res.protocol(),
20848 "op-trap-group-set-do",
20849 OpTrapGroupSetDo::lookup,
20850 );
20851 res
20852 }
20853 #[doc = "Get trap policer instances.\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_trap_policer_id()](IterableDevlink::get_trap_policer_id)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
20854 pub fn op_trap_policer_get_dump(self) -> OpTrapPolicerGetDump<'buf> {
20855 let mut res = OpTrapPolicerGetDump::new(self);
20856 res.request.do_writeback(
20857 res.protocol(),
20858 "op-trap-policer-get-dump",
20859 OpTrapPolicerGetDump::lookup,
20860 );
20861 res
20862 }
20863 #[doc = "Get trap policer instances.\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_trap_policer_id()](PushDevlink::push_trap_policer_id)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_trap_policer_id()](IterableDevlink::get_trap_policer_id)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
20864 pub fn op_trap_policer_get_do(self) -> OpTrapPolicerGetDo<'buf> {
20865 let mut res = OpTrapPolicerGetDo::new(self);
20866 res.request.do_writeback(
20867 res.protocol(),
20868 "op-trap-policer-get-do",
20869 OpTrapPolicerGetDo::lookup,
20870 );
20871 res
20872 }
20873 #[doc = "Get trap policer instances.\n\nFlags: admin-perm\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_trap_policer_id()](PushDevlink::push_trap_policer_id)\n- [.push_trap_policer_rate()](PushDevlink::push_trap_policer_rate)\n- [.push_trap_policer_burst()](PushDevlink::push_trap_policer_burst)\n- [.push_index()](PushDevlink::push_index)\n\n"]
20874 pub fn op_trap_policer_set_do(self) -> OpTrapPolicerSetDo<'buf> {
20875 let mut res = OpTrapPolicerSetDo::new(self);
20876 res.request.do_writeback(
20877 res.protocol(),
20878 "op-trap-policer-set-do",
20879 OpTrapPolicerSetDo::lookup,
20880 );
20881 res
20882 }
20883 #[doc = "Test health reporter instances.\n\nFlags: admin-perm\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_port_index()](PushDevlink::push_port_index)\n- [.push_health_reporter_name()](PushDevlink::push_health_reporter_name)\n- [.push_index()](PushDevlink::push_index)\n\n"]
20884 pub fn op_health_reporter_test_do(self) -> OpHealthReporterTestDo<'buf> {
20885 let mut res = OpHealthReporterTestDo::new(self);
20886 res.request.do_writeback(
20887 res.protocol(),
20888 "op-health-reporter-test-do",
20889 OpHealthReporterTestDo::lookup,
20890 );
20891 res
20892 }
20893 #[doc = "Get rate instances.\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_port_index()](IterableDevlink::get_port_index)\n- [.get_rate_node_name()](IterableDevlink::get_rate_node_name)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
20894 pub fn op_rate_get_dump(self) -> OpRateGetDump<'buf> {
20895 let mut res = OpRateGetDump::new(self);
20896 res.request
20897 .do_writeback(res.protocol(), "op-rate-get-dump", OpRateGetDump::lookup);
20898 res
20899 }
20900 #[doc = "Get rate instances.\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_port_index()](PushDevlink::push_port_index)\n- [.push_rate_node_name()](PushDevlink::push_rate_node_name)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_port_index()](IterableDevlink::get_port_index)\n- [.get_rate_node_name()](IterableDevlink::get_rate_node_name)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
20901 pub fn op_rate_get_do(self) -> OpRateGetDo<'buf> {
20902 let mut res = OpRateGetDo::new(self);
20903 res.request
20904 .do_writeback(res.protocol(), "op-rate-get-do", OpRateGetDo::lookup);
20905 res
20906 }
20907 #[doc = "Set rate instances.\n\nFlags: admin-perm\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_rate_tx_share()](PushDevlink::push_rate_tx_share)\n- [.push_rate_tx_max()](PushDevlink::push_rate_tx_max)\n- [.push_rate_node_name()](PushDevlink::push_rate_node_name)\n- [.push_rate_parent_node_name()](PushDevlink::push_rate_parent_node_name)\n- [.push_rate_tx_priority()](PushDevlink::push_rate_tx_priority)\n- [.push_rate_tx_weight()](PushDevlink::push_rate_tx_weight)\n- [.nested_rate_tc_bws()](PushDevlink::nested_rate_tc_bws)\n- [.push_index()](PushDevlink::push_index)\n\n"]
20908 pub fn op_rate_set_do(self) -> OpRateSetDo<'buf> {
20909 let mut res = OpRateSetDo::new(self);
20910 res.request
20911 .do_writeback(res.protocol(), "op-rate-set-do", OpRateSetDo::lookup);
20912 res
20913 }
20914 #[doc = "Create rate instances.\n\nFlags: admin-perm\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_rate_tx_share()](PushDevlink::push_rate_tx_share)\n- [.push_rate_tx_max()](PushDevlink::push_rate_tx_max)\n- [.push_rate_node_name()](PushDevlink::push_rate_node_name)\n- [.push_rate_parent_node_name()](PushDevlink::push_rate_parent_node_name)\n- [.push_rate_tx_priority()](PushDevlink::push_rate_tx_priority)\n- [.push_rate_tx_weight()](PushDevlink::push_rate_tx_weight)\n- [.nested_rate_tc_bws()](PushDevlink::nested_rate_tc_bws)\n- [.push_index()](PushDevlink::push_index)\n\n"]
20915 pub fn op_rate_new_do(self) -> OpRateNewDo<'buf> {
20916 let mut res = OpRateNewDo::new(self);
20917 res.request
20918 .do_writeback(res.protocol(), "op-rate-new-do", OpRateNewDo::lookup);
20919 res
20920 }
20921 #[doc = "Delete rate instances.\n\nFlags: admin-perm\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_rate_node_name()](PushDevlink::push_rate_node_name)\n- [.push_index()](PushDevlink::push_index)\n\n"]
20922 pub fn op_rate_del_do(self) -> OpRateDelDo<'buf> {
20923 let mut res = OpRateDelDo::new(self);
20924 res.request
20925 .do_writeback(res.protocol(), "op-rate-del-do", OpRateDelDo::lookup);
20926 res
20927 }
20928 #[doc = "Get line card instances.\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_linecard_index()](IterableDevlink::get_linecard_index)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
20929 pub fn op_linecard_get_dump(self) -> OpLinecardGetDump<'buf> {
20930 let mut res = OpLinecardGetDump::new(self);
20931 res.request.do_writeback(
20932 res.protocol(),
20933 "op-linecard-get-dump",
20934 OpLinecardGetDump::lookup,
20935 );
20936 res
20937 }
20938 #[doc = "Get line card instances.\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_linecard_index()](PushDevlink::push_linecard_index)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_linecard_index()](IterableDevlink::get_linecard_index)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
20939 pub fn op_linecard_get_do(self) -> OpLinecardGetDo<'buf> {
20940 let mut res = OpLinecardGetDo::new(self);
20941 res.request.do_writeback(
20942 res.protocol(),
20943 "op-linecard-get-do",
20944 OpLinecardGetDo::lookup,
20945 );
20946 res
20947 }
20948 #[doc = "Set line card instances.\n\nFlags: admin-perm\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_linecard_index()](PushDevlink::push_linecard_index)\n- [.push_linecard_type()](PushDevlink::push_linecard_type)\n- [.push_index()](PushDevlink::push_index)\n\n"]
20949 pub fn op_linecard_set_do(self) -> OpLinecardSetDo<'buf> {
20950 let mut res = OpLinecardSetDo::new(self);
20951 res.request.do_writeback(
20952 res.protocol(),
20953 "op-linecard-set-do",
20954 OpLinecardSetDo::lookup,
20955 );
20956 res
20957 }
20958 #[doc = "Get device selftest instances.\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
20959 pub fn op_selftests_get_dump(self) -> OpSelftestsGetDump<'buf> {
20960 let mut res = OpSelftestsGetDump::new(self);
20961 res.request.do_writeback(
20962 res.protocol(),
20963 "op-selftests-get-dump",
20964 OpSelftestsGetDump::lookup,
20965 );
20966 res
20967 }
20968 #[doc = "Get device selftest instances.\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_index()](PushDevlink::push_index)\n\nReply attributes:\n- [.get_bus_name()](IterableDevlink::get_bus_name)\n- [.get_dev_name()](IterableDevlink::get_dev_name)\n- [.get_index()](IterableDevlink::get_index)\n\n"]
20969 pub fn op_selftests_get_do(self) -> OpSelftestsGetDo<'buf> {
20970 let mut res = OpSelftestsGetDo::new(self);
20971 res.request.do_writeback(
20972 res.protocol(),
20973 "op-selftests-get-do",
20974 OpSelftestsGetDo::lookup,
20975 );
20976 res
20977 }
20978 #[doc = "Run device selftest instances.\n\nFlags: admin-perm\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.nested_selftests()](PushDevlink::nested_selftests)\n- [.push_index()](PushDevlink::push_index)\n\n"]
20979 pub fn op_selftests_run_do(self) -> OpSelftestsRunDo<'buf> {
20980 let mut res = OpSelftestsRunDo::new(self);
20981 res.request.do_writeback(
20982 res.protocol(),
20983 "op-selftests-run-do",
20984 OpSelftestsRunDo::lookup,
20985 );
20986 res
20987 }
20988 #[doc = "Set notification messages socket filter.\n\nRequest attributes:\n- [.push_bus_name()](PushDevlink::push_bus_name)\n- [.push_dev_name()](PushDevlink::push_dev_name)\n- [.push_port_index()](PushDevlink::push_port_index)\n- [.push_index()](PushDevlink::push_index)\n\n"]
20989 pub fn op_notify_filter_set_do(self) -> OpNotifyFilterSetDo<'buf> {
20990 let mut res = OpNotifyFilterSetDo::new(self);
20991 res.request.do_writeback(
20992 res.protocol(),
20993 "op-notify-filter-set-do",
20994 OpNotifyFilterSetDo::lookup,
20995 );
20996 res
20997 }
20998}
20999#[cfg(test)]
21000mod generated_tests {
21001 use super::*;
21002 #[test]
21003 fn tests() {
21004 let _ = IterableDevlink::get_bus_name;
21005 let _ = IterableDevlink::get_dev_name;
21006 let _ = IterableDevlink::get_dev_stats;
21007 let _ = IterableDevlink::get_dpipe_entries;
21008 let _ = IterableDevlink::get_dpipe_headers;
21009 let _ = IterableDevlink::get_dpipe_tables;
21010 let _ = IterableDevlink::get_eswitch_encap_mode;
21011 let _ = IterableDevlink::get_eswitch_inline_mode;
21012 let _ = IterableDevlink::get_eswitch_mode;
21013 let _ = IterableDevlink::get_fmsg;
21014 let _ = IterableDevlink::get_health_reporter_name;
21015 let _ = IterableDevlink::get_index;
21016 let _ = IterableDevlink::get_info_board_serial_number;
21017 let _ = IterableDevlink::get_info_driver_name;
21018 let _ = IterableDevlink::get_info_serial_number;
21019 let _ = IterableDevlink::get_info_version_fixed;
21020 let _ = IterableDevlink::get_info_version_running;
21021 let _ = IterableDevlink::get_info_version_stored;
21022 let _ = IterableDevlink::get_linecard_index;
21023 let _ = IterableDevlink::get_param_name;
21024 let _ = IterableDevlink::get_port_index;
21025 let _ = IterableDevlink::get_rate_node_name;
21026 let _ = IterableDevlink::get_region_name;
21027 let _ = IterableDevlink::get_region_snapshot_id;
21028 let _ = IterableDevlink::get_reload_actions_performed;
21029 let _ = IterableDevlink::get_reload_failed;
21030 let _ = IterableDevlink::get_resource_list;
21031 let _ = IterableDevlink::get_sb_index;
21032 let _ = IterableDevlink::get_sb_pool_index;
21033 let _ = IterableDevlink::get_sb_pool_type;
21034 let _ = IterableDevlink::get_sb_tc_index;
21035 let _ = IterableDevlink::get_trap_group_name;
21036 let _ = IterableDevlink::get_trap_name;
21037 let _ = IterableDevlink::get_trap_policer_id;
21038 let _ = PushDevlink::<&mut Vec<u8>>::nested_port_function;
21039 let _ = PushDevlink::<&mut Vec<u8>>::nested_rate_tc_bws;
21040 let _ = PushDevlink::<&mut Vec<u8>>::nested_selftests;
21041 let _ = PushDevlink::<&mut Vec<u8>>::push_bus_name;
21042 let _ = PushDevlink::<&mut Vec<u8>>::push_dev_name;
21043 let _ = PushDevlink::<&mut Vec<u8>>::push_dpipe_table_counters_enabled;
21044 let _ = PushDevlink::<&mut Vec<u8>>::push_dpipe_table_name;
21045 let _ = PushDevlink::<&mut Vec<u8>>::push_eswitch_encap_mode;
21046 let _ = PushDevlink::<&mut Vec<u8>>::push_eswitch_inline_mode;
21047 let _ = PushDevlink::<&mut Vec<u8>>::push_eswitch_mode;
21048 let _ = PushDevlink::<&mut Vec<u8>>::push_flash_update_component;
21049 let _ = PushDevlink::<&mut Vec<u8>>::push_flash_update_file_name;
21050 let _ = PushDevlink::<&mut Vec<u8>>::push_flash_update_overwrite_mask;
21051 let _ = PushDevlink::<&mut Vec<u8>>::push_health_reporter_auto_dump;
21052 let _ = PushDevlink::<&mut Vec<u8>>::push_health_reporter_auto_recover;
21053 let _ = PushDevlink::<&mut Vec<u8>>::push_health_reporter_burst_period;
21054 let _ = PushDevlink::<&mut Vec<u8>>::push_health_reporter_graceful_period;
21055 let _ = PushDevlink::<&mut Vec<u8>>::push_health_reporter_name;
21056 let _ = PushDevlink::<&mut Vec<u8>>::push_index;
21057 let _ = PushDevlink::<&mut Vec<u8>>::push_linecard_index;
21058 let _ = PushDevlink::<&mut Vec<u8>>::push_linecard_type;
21059 let _ = PushDevlink::<&mut Vec<u8>>::push_netns_fd;
21060 let _ = PushDevlink::<&mut Vec<u8>>::push_netns_id;
21061 let _ = PushDevlink::<&mut Vec<u8>>::push_netns_pid;
21062 let _ = PushDevlink::<&mut Vec<u8>>::push_param_name;
21063 let _ = PushDevlink::<&mut Vec<u8>>::push_param_reset_default;
21064 let _ = PushDevlink::<&mut Vec<u8>>::push_param_type;
21065 let _ = PushDevlink::<&mut Vec<u8>>::push_param_value_cmode;
21066 let _ = PushDevlink::<&mut Vec<u8>>::push_port_controller_number;
21067 let _ = PushDevlink::<&mut Vec<u8>>::push_port_flavour;
21068 let _ = PushDevlink::<&mut Vec<u8>>::push_port_index;
21069 let _ = PushDevlink::<&mut Vec<u8>>::push_port_pci_pf_number;
21070 let _ = PushDevlink::<&mut Vec<u8>>::push_port_pci_sf_number;
21071 let _ = PushDevlink::<&mut Vec<u8>>::push_port_split_count;
21072 let _ = PushDevlink::<&mut Vec<u8>>::push_port_type;
21073 let _ = PushDevlink::<&mut Vec<u8>>::push_rate_node_name;
21074 let _ = PushDevlink::<&mut Vec<u8>>::push_rate_parent_node_name;
21075 let _ = PushDevlink::<&mut Vec<u8>>::push_rate_tx_max;
21076 let _ = PushDevlink::<&mut Vec<u8>>::push_rate_tx_priority;
21077 let _ = PushDevlink::<&mut Vec<u8>>::push_rate_tx_share;
21078 let _ = PushDevlink::<&mut Vec<u8>>::push_rate_tx_weight;
21079 let _ = PushDevlink::<&mut Vec<u8>>::push_region_chunk_addr;
21080 let _ = PushDevlink::<&mut Vec<u8>>::push_region_chunk_len;
21081 let _ = PushDevlink::<&mut Vec<u8>>::push_region_direct;
21082 let _ = PushDevlink::<&mut Vec<u8>>::push_region_name;
21083 let _ = PushDevlink::<&mut Vec<u8>>::push_region_snapshot_id;
21084 let _ = PushDevlink::<&mut Vec<u8>>::push_reload_action;
21085 let _ = PushDevlink::<&mut Vec<u8>>::push_reload_limits;
21086 let _ = PushDevlink::<&mut Vec<u8>>::push_resource_id;
21087 let _ = PushDevlink::<&mut Vec<u8>>::push_resource_scope_mask;
21088 let _ = PushDevlink::<&mut Vec<u8>>::push_resource_size;
21089 let _ = PushDevlink::<&mut Vec<u8>>::push_sb_index;
21090 let _ = PushDevlink::<&mut Vec<u8>>::push_sb_pool_index;
21091 let _ = PushDevlink::<&mut Vec<u8>>::push_sb_pool_size;
21092 let _ = PushDevlink::<&mut Vec<u8>>::push_sb_pool_threshold_type;
21093 let _ = PushDevlink::<&mut Vec<u8>>::push_sb_pool_type;
21094 let _ = PushDevlink::<&mut Vec<u8>>::push_sb_tc_index;
21095 let _ = PushDevlink::<&mut Vec<u8>>::push_sb_threshold;
21096 let _ = PushDevlink::<&mut Vec<u8>>::push_trap_action;
21097 let _ = PushDevlink::<&mut Vec<u8>>::push_trap_group_name;
21098 let _ = PushDevlink::<&mut Vec<u8>>::push_trap_name;
21099 let _ = PushDevlink::<&mut Vec<u8>>::push_trap_policer_burst;
21100 let _ = PushDevlink::<&mut Vec<u8>>::push_trap_policer_id;
21101 let _ = PushDevlink::<&mut Vec<u8>>::push_trap_policer_rate;
21102 }
21103}