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}
388impl VarAttrType {
389 pub fn from_value(value: u64) -> Option<Self> {
390 Some(match value {
391 1 => Self::U8,
392 2 => Self::U16,
393 3 => Self::U32,
394 4 => Self::U64,
395 5 => Self::String,
396 6 => Self::Flag,
397 10 => Self::NulString,
398 11 => Self::Binary,
399 _ => return None,
400 })
401 }
402}
403pub const RATE_TC_INDEX_MAX: u64 = 7u64;
404#[derive(Clone)]
405pub enum Devlink<'a> {
406 BusName(&'a CStr),
407 DevName(&'a CStr),
408 PortIndex(u32),
409 #[doc = "Associated type: [`PortType`] (enum)"]
410 PortType(u16),
411 PortDesiredType(u16),
412 PortNetdevIfindex(u32),
413 PortNetdevName(&'a CStr),
414 PortIbdevName(&'a CStr),
415 PortSplitCount(u32),
416 PortSplitGroup(u32),
417 SbIndex(u32),
418 SbSize(u32),
419 SbIngressPoolCount(u16),
420 SbEgressPoolCount(u16),
421 SbIngressTcCount(u16),
422 SbEgressTcCount(u16),
423 SbPoolIndex(u16),
424 #[doc = "Associated type: [`SbPoolType`] (enum)"]
425 SbPoolType(u8),
426 SbPoolSize(u32),
427 #[doc = "Associated type: [`SbThresholdType`] (enum)"]
428 SbPoolThresholdType(u8),
429 SbThreshold(u32),
430 SbTcIndex(u16),
431 SbOccCur(u32),
432 SbOccMax(u32),
433 #[doc = "Associated type: [`EswitchMode`] (enum)"]
434 EswitchMode(u16),
435 #[doc = "Associated type: [`EswitchInlineMode`] (enum)"]
436 EswitchInlineMode(u8),
437 DpipeTables(IterableDlDpipeTables<'a>),
438 #[doc = "Attribute may repeat multiple times (treat it as array)"]
439 DpipeTable(IterableDlDpipeTable<'a>),
440 DpipeTableName(&'a CStr),
441 DpipeTableSize(u64),
442 DpipeTableMatches(IterableDlDpipeTableMatches<'a>),
443 DpipeTableActions(IterableDlDpipeTableActions<'a>),
444 DpipeTableCountersEnabled(u8),
445 DpipeEntries(IterableDlDpipeEntries<'a>),
446 #[doc = "Attribute may repeat multiple times (treat it as array)"]
447 DpipeEntry(IterableDlDpipeEntry<'a>),
448 DpipeEntryIndex(u64),
449 DpipeEntryMatchValues(IterableDlDpipeEntryMatchValues<'a>),
450 DpipeEntryActionValues(IterableDlDpipeEntryActionValues<'a>),
451 DpipeEntryCounter(u64),
452 #[doc = "Attribute may repeat multiple times (treat it as array)"]
453 DpipeMatch(IterableDlDpipeMatch<'a>),
454 #[doc = "Attribute may repeat multiple times (treat it as array)"]
455 DpipeMatchValue(IterableDlDpipeMatchValue<'a>),
456 #[doc = "Associated type: [`DpipeMatchType`] (enum)"]
457 DpipeMatchType(u32),
458 #[doc = "Attribute may repeat multiple times (treat it as array)"]
459 DpipeAction(IterableDlDpipeAction<'a>),
460 #[doc = "Attribute may repeat multiple times (treat it as array)"]
461 DpipeActionValue(IterableDlDpipeActionValue<'a>),
462 #[doc = "Associated type: [`DpipeActionType`] (enum)"]
463 DpipeActionType(u32),
464 DpipeValue(&'a [u8]),
465 DpipeValueMask(&'a [u8]),
466 DpipeValueMapping(u32),
467 DpipeHeaders(IterableDlDpipeHeaders<'a>),
468 #[doc = "Attribute may repeat multiple times (treat it as array)"]
469 DpipeHeader(IterableDlDpipeHeader<'a>),
470 DpipeHeaderName(&'a CStr),
471 #[doc = "Associated type: [`DpipeHeaderId`] (enum)"]
472 DpipeHeaderId(u32),
473 DpipeHeaderFields(IterableDlDpipeHeaderFields<'a>),
474 DpipeHeaderGlobal(u8),
475 DpipeHeaderIndex(u32),
476 #[doc = "Attribute may repeat multiple times (treat it as array)"]
477 DpipeField(IterableDlDpipeField<'a>),
478 DpipeFieldName(&'a CStr),
479 DpipeFieldId(u32),
480 DpipeFieldBitwidth(u32),
481 #[doc = "Associated type: [`DpipeFieldMappingType`] (enum)"]
482 DpipeFieldMappingType(u32),
483 Pad(&'a [u8]),
484 #[doc = "Associated type: [`EswitchEncapMode`] (enum)"]
485 EswitchEncapMode(u8),
486 ResourceList(IterableDlResourceList<'a>),
487 #[doc = "Attribute may repeat multiple times (treat it as array)"]
488 Resource(IterableDlResource<'a>),
489 ResourceName(&'a CStr),
490 ResourceId(u64),
491 ResourceSize(u64),
492 ResourceSizeNew(u64),
493 ResourceSizeValid(u8),
494 ResourceSizeMin(u64),
495 ResourceSizeMax(u64),
496 ResourceSizeGran(u64),
497 #[doc = "Associated type: [`ResourceUnit`] (enum)"]
498 ResourceUnit(u8),
499 ResourceOcc(u64),
500 DpipeTableResourceId(u64),
501 DpipeTableResourceUnits(u64),
502 #[doc = "Associated type: [`PortFlavour`] (enum)"]
503 PortFlavour(u16),
504 PortNumber(u32),
505 PortSplitSubportNumber(u32),
506 Param(IterableDlParam<'a>),
507 ParamName(&'a CStr),
508 ParamGeneric(()),
509 #[doc = "Associated type: [`VarAttrType`] (enum)"]
510 ParamType(u8),
511 #[doc = "Associated type: [`ParamCmode`] (enum)"]
512 ParamValueCmode(u8),
513 RegionName(&'a CStr),
514 RegionSize(u64),
515 RegionSnapshots(IterableDlRegionSnapshots<'a>),
516 RegionSnapshot(IterableDlRegionSnapshot<'a>),
517 RegionSnapshotId(u32),
518 RegionChunks(IterableDlRegionChunks<'a>),
519 RegionChunk(IterableDlRegionChunk<'a>),
520 RegionChunkData(&'a [u8]),
521 RegionChunkAddr(u64),
522 RegionChunkLen(u64),
523 InfoDriverName(&'a CStr),
524 InfoSerialNumber(&'a CStr),
525 #[doc = "Attribute may repeat multiple times (treat it as array)"]
526 InfoVersionFixed(IterableDlInfoVersion<'a>),
527 #[doc = "Attribute may repeat multiple times (treat it as array)"]
528 InfoVersionRunning(IterableDlInfoVersion<'a>),
529 #[doc = "Attribute may repeat multiple times (treat it as array)"]
530 InfoVersionStored(IterableDlInfoVersion<'a>),
531 InfoVersionName(&'a CStr),
532 InfoVersionValue(&'a CStr),
533 SbPoolCellSize(u32),
534 Fmsg(IterableDlFmsg<'a>),
535 FmsgObjNestStart(()),
536 FmsgPairNestStart(()),
537 FmsgArrNestStart(()),
538 FmsgNestEnd(()),
539 FmsgObjName(&'a CStr),
540 #[doc = "Associated type: [`VarAttrType`] (enum)"]
541 FmsgObjValueType(u8),
542 HealthReporter(IterableDlHealthReporter<'a>),
543 HealthReporterName(&'a CStr),
544 HealthReporterState(u8),
545 HealthReporterErrCount(u64),
546 HealthReporterRecoverCount(u64),
547 HealthReporterDumpTs(u64),
548 HealthReporterGracefulPeriod(u64),
549 HealthReporterAutoRecover(u8),
550 FlashUpdateFileName(&'a CStr),
551 FlashUpdateComponent(&'a CStr),
552 FlashUpdateStatusMsg(&'a CStr),
553 FlashUpdateStatusDone(u64),
554 FlashUpdateStatusTotal(u64),
555 PortPciPfNumber(u16),
556 PortPciVfNumber(u16),
557 Stats(IterableDlAttrStats<'a>),
558 TrapName(&'a CStr),
559 #[doc = "Associated type: [`TrapAction`] (enum)"]
560 TrapAction(u8),
561 #[doc = "Associated type: [`TrapType`] (enum)"]
562 TrapType(u8),
563 TrapGeneric(()),
564 TrapMetadata(IterableDlTrapMetadata<'a>),
565 TrapGroupName(&'a CStr),
566 ReloadFailed(u8),
567 HealthReporterDumpTsNs(u64),
568 NetnsFd(u32),
569 NetnsPid(u32),
570 NetnsId(u32),
571 HealthReporterAutoDump(u8),
572 TrapPolicerId(u32),
573 TrapPolicerRate(u64),
574 TrapPolicerBurst(u64),
575 PortFunction(IterableDlPortFunction<'a>),
576 InfoBoardSerialNumber(&'a CStr),
577 PortLanes(u32),
578 PortSplittable(u8),
579 PortExternal(u8),
580 PortControllerNumber(u32),
581 FlashUpdateStatusTimeout(u64),
582 #[doc = "Associated type: [`FlashOverwrite`] (1 bit per enumeration)"]
583 FlashUpdateOverwriteMask(BuiltinBitfield32),
584 #[doc = "Associated type: [`ReloadAction`] (enum)"]
585 ReloadAction(u8),
586 #[doc = "Associated type: [`ReloadAction`] (1 bit per enumeration)"]
587 ReloadActionsPerformed(BuiltinBitfield32),
588 #[doc = "Associated type: [`ReloadAction`] (1 bit per enumeration)"]
589 ReloadLimits(BuiltinBitfield32),
590 DevStats(IterableDlDevStats<'a>),
591 ReloadStats(IterableDlReloadStats<'a>),
592 #[doc = "Attribute may repeat multiple times (treat it as array)"]
593 ReloadStatsEntry(IterableDlReloadStatsEntry<'a>),
594 ReloadStatsLimit(u8),
595 ReloadStatsValue(u32),
596 RemoteReloadStats(IterableDlReloadStats<'a>),
597 #[doc = "Attribute may repeat multiple times (treat it as array)"]
598 ReloadActionInfo(IterableDlReloadActInfo<'a>),
599 #[doc = "Attribute may repeat multiple times (treat it as array)"]
600 ReloadActionStats(IterableDlReloadActStats<'a>),
601 PortPciSfNumber(u32),
602 #[doc = "Associated type: [`RateType`] (enum)"]
603 RateType(u16),
604 RateTxShare(u64),
605 RateTxMax(u64),
606 RateNodeName(&'a CStr),
607 RateParentNodeName(&'a CStr),
608 RegionMaxSnapshots(u32),
609 LinecardIndex(u32),
610 LinecardState(u8),
611 LinecardType(&'a CStr),
612 LinecardSupportedTypes(IterableDlLinecardSupportedTypes<'a>),
613 Selftests(IterableDlSelftestId<'a>),
614 RateTxPriority(u32),
615 RateTxWeight(u32),
616 RegionDirect(()),
617 #[doc = "Attribute may repeat multiple times (treat it as array)"]
618 RateTcBws(IterableDlRateTcBws<'a>),
619 #[doc = "Time (in msec) for recoveries before starting the grace period.\n"]
620 HealthReporterBurstPeriod(u64),
621 #[doc = "Request restoring parameter to its default value.\n"]
622 ParamResetDefault(()),
623 #[doc = "Unique devlink instance index.\n"]
624 Index(u32),
625 #[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)"]
626 ResourceScopeMask(u32),
627}
628impl<'a> IterableDevlink<'a> {
629 pub fn get_bus_name(&self) -> Result<&'a CStr, ErrorContext> {
630 let mut iter = self.clone();
631 iter.pos = 0;
632 for attr in iter {
633 if let Ok(Devlink::BusName(val)) = attr {
634 return Ok(val);
635 }
636 }
637 Err(ErrorContext::new_missing(
638 "Devlink",
639 "BusName",
640 self.orig_loc,
641 self.buf.as_ptr() as usize,
642 ))
643 }
644 pub fn get_dev_name(&self) -> Result<&'a CStr, ErrorContext> {
645 let mut iter = self.clone();
646 iter.pos = 0;
647 for attr in iter {
648 if let Ok(Devlink::DevName(val)) = attr {
649 return Ok(val);
650 }
651 }
652 Err(ErrorContext::new_missing(
653 "Devlink",
654 "DevName",
655 self.orig_loc,
656 self.buf.as_ptr() as usize,
657 ))
658 }
659 pub fn get_port_index(&self) -> Result<u32, ErrorContext> {
660 let mut iter = self.clone();
661 iter.pos = 0;
662 for attr in iter {
663 if let Ok(Devlink::PortIndex(val)) = attr {
664 return Ok(val);
665 }
666 }
667 Err(ErrorContext::new_missing(
668 "Devlink",
669 "PortIndex",
670 self.orig_loc,
671 self.buf.as_ptr() as usize,
672 ))
673 }
674 #[doc = "Associated type: [`PortType`] (enum)"]
675 pub fn get_port_type(&self) -> Result<u16, ErrorContext> {
676 let mut iter = self.clone();
677 iter.pos = 0;
678 for attr in iter {
679 if let Ok(Devlink::PortType(val)) = attr {
680 return Ok(val);
681 }
682 }
683 Err(ErrorContext::new_missing(
684 "Devlink",
685 "PortType",
686 self.orig_loc,
687 self.buf.as_ptr() as usize,
688 ))
689 }
690 pub fn get_port_desired_type(&self) -> Result<u16, ErrorContext> {
691 let mut iter = self.clone();
692 iter.pos = 0;
693 for attr in iter {
694 if let Ok(Devlink::PortDesiredType(val)) = attr {
695 return Ok(val);
696 }
697 }
698 Err(ErrorContext::new_missing(
699 "Devlink",
700 "PortDesiredType",
701 self.orig_loc,
702 self.buf.as_ptr() as usize,
703 ))
704 }
705 pub fn get_port_netdev_ifindex(&self) -> Result<u32, ErrorContext> {
706 let mut iter = self.clone();
707 iter.pos = 0;
708 for attr in iter {
709 if let Ok(Devlink::PortNetdevIfindex(val)) = attr {
710 return Ok(val);
711 }
712 }
713 Err(ErrorContext::new_missing(
714 "Devlink",
715 "PortNetdevIfindex",
716 self.orig_loc,
717 self.buf.as_ptr() as usize,
718 ))
719 }
720 pub fn get_port_netdev_name(&self) -> Result<&'a CStr, ErrorContext> {
721 let mut iter = self.clone();
722 iter.pos = 0;
723 for attr in iter {
724 if let Ok(Devlink::PortNetdevName(val)) = attr {
725 return Ok(val);
726 }
727 }
728 Err(ErrorContext::new_missing(
729 "Devlink",
730 "PortNetdevName",
731 self.orig_loc,
732 self.buf.as_ptr() as usize,
733 ))
734 }
735 pub fn get_port_ibdev_name(&self) -> Result<&'a CStr, ErrorContext> {
736 let mut iter = self.clone();
737 iter.pos = 0;
738 for attr in iter {
739 if let Ok(Devlink::PortIbdevName(val)) = attr {
740 return Ok(val);
741 }
742 }
743 Err(ErrorContext::new_missing(
744 "Devlink",
745 "PortIbdevName",
746 self.orig_loc,
747 self.buf.as_ptr() as usize,
748 ))
749 }
750 pub fn get_port_split_count(&self) -> Result<u32, ErrorContext> {
751 let mut iter = self.clone();
752 iter.pos = 0;
753 for attr in iter {
754 if let Ok(Devlink::PortSplitCount(val)) = attr {
755 return Ok(val);
756 }
757 }
758 Err(ErrorContext::new_missing(
759 "Devlink",
760 "PortSplitCount",
761 self.orig_loc,
762 self.buf.as_ptr() as usize,
763 ))
764 }
765 pub fn get_port_split_group(&self) -> Result<u32, ErrorContext> {
766 let mut iter = self.clone();
767 iter.pos = 0;
768 for attr in iter {
769 if let Ok(Devlink::PortSplitGroup(val)) = attr {
770 return Ok(val);
771 }
772 }
773 Err(ErrorContext::new_missing(
774 "Devlink",
775 "PortSplitGroup",
776 self.orig_loc,
777 self.buf.as_ptr() as usize,
778 ))
779 }
780 pub fn get_sb_index(&self) -> Result<u32, ErrorContext> {
781 let mut iter = self.clone();
782 iter.pos = 0;
783 for attr in iter {
784 if let Ok(Devlink::SbIndex(val)) = attr {
785 return Ok(val);
786 }
787 }
788 Err(ErrorContext::new_missing(
789 "Devlink",
790 "SbIndex",
791 self.orig_loc,
792 self.buf.as_ptr() as usize,
793 ))
794 }
795 pub fn get_sb_size(&self) -> Result<u32, ErrorContext> {
796 let mut iter = self.clone();
797 iter.pos = 0;
798 for attr in iter {
799 if let Ok(Devlink::SbSize(val)) = attr {
800 return Ok(val);
801 }
802 }
803 Err(ErrorContext::new_missing(
804 "Devlink",
805 "SbSize",
806 self.orig_loc,
807 self.buf.as_ptr() as usize,
808 ))
809 }
810 pub fn get_sb_ingress_pool_count(&self) -> Result<u16, ErrorContext> {
811 let mut iter = self.clone();
812 iter.pos = 0;
813 for attr in iter {
814 if let Ok(Devlink::SbIngressPoolCount(val)) = attr {
815 return Ok(val);
816 }
817 }
818 Err(ErrorContext::new_missing(
819 "Devlink",
820 "SbIngressPoolCount",
821 self.orig_loc,
822 self.buf.as_ptr() as usize,
823 ))
824 }
825 pub fn get_sb_egress_pool_count(&self) -> Result<u16, ErrorContext> {
826 let mut iter = self.clone();
827 iter.pos = 0;
828 for attr in iter {
829 if let Ok(Devlink::SbEgressPoolCount(val)) = attr {
830 return Ok(val);
831 }
832 }
833 Err(ErrorContext::new_missing(
834 "Devlink",
835 "SbEgressPoolCount",
836 self.orig_loc,
837 self.buf.as_ptr() as usize,
838 ))
839 }
840 pub fn get_sb_ingress_tc_count(&self) -> Result<u16, ErrorContext> {
841 let mut iter = self.clone();
842 iter.pos = 0;
843 for attr in iter {
844 if let Ok(Devlink::SbIngressTcCount(val)) = attr {
845 return Ok(val);
846 }
847 }
848 Err(ErrorContext::new_missing(
849 "Devlink",
850 "SbIngressTcCount",
851 self.orig_loc,
852 self.buf.as_ptr() as usize,
853 ))
854 }
855 pub fn get_sb_egress_tc_count(&self) -> Result<u16, ErrorContext> {
856 let mut iter = self.clone();
857 iter.pos = 0;
858 for attr in iter {
859 if let Ok(Devlink::SbEgressTcCount(val)) = attr {
860 return Ok(val);
861 }
862 }
863 Err(ErrorContext::new_missing(
864 "Devlink",
865 "SbEgressTcCount",
866 self.orig_loc,
867 self.buf.as_ptr() as usize,
868 ))
869 }
870 pub fn get_sb_pool_index(&self) -> Result<u16, ErrorContext> {
871 let mut iter = self.clone();
872 iter.pos = 0;
873 for attr in iter {
874 if let Ok(Devlink::SbPoolIndex(val)) = attr {
875 return Ok(val);
876 }
877 }
878 Err(ErrorContext::new_missing(
879 "Devlink",
880 "SbPoolIndex",
881 self.orig_loc,
882 self.buf.as_ptr() as usize,
883 ))
884 }
885 #[doc = "Associated type: [`SbPoolType`] (enum)"]
886 pub fn get_sb_pool_type(&self) -> Result<u8, ErrorContext> {
887 let mut iter = self.clone();
888 iter.pos = 0;
889 for attr in iter {
890 if let Ok(Devlink::SbPoolType(val)) = attr {
891 return Ok(val);
892 }
893 }
894 Err(ErrorContext::new_missing(
895 "Devlink",
896 "SbPoolType",
897 self.orig_loc,
898 self.buf.as_ptr() as usize,
899 ))
900 }
901 pub fn get_sb_pool_size(&self) -> Result<u32, ErrorContext> {
902 let mut iter = self.clone();
903 iter.pos = 0;
904 for attr in iter {
905 if let Ok(Devlink::SbPoolSize(val)) = attr {
906 return Ok(val);
907 }
908 }
909 Err(ErrorContext::new_missing(
910 "Devlink",
911 "SbPoolSize",
912 self.orig_loc,
913 self.buf.as_ptr() as usize,
914 ))
915 }
916 #[doc = "Associated type: [`SbThresholdType`] (enum)"]
917 pub fn get_sb_pool_threshold_type(&self) -> Result<u8, ErrorContext> {
918 let mut iter = self.clone();
919 iter.pos = 0;
920 for attr in iter {
921 if let Ok(Devlink::SbPoolThresholdType(val)) = attr {
922 return Ok(val);
923 }
924 }
925 Err(ErrorContext::new_missing(
926 "Devlink",
927 "SbPoolThresholdType",
928 self.orig_loc,
929 self.buf.as_ptr() as usize,
930 ))
931 }
932 pub fn get_sb_threshold(&self) -> Result<u32, ErrorContext> {
933 let mut iter = self.clone();
934 iter.pos = 0;
935 for attr in iter {
936 if let Ok(Devlink::SbThreshold(val)) = attr {
937 return Ok(val);
938 }
939 }
940 Err(ErrorContext::new_missing(
941 "Devlink",
942 "SbThreshold",
943 self.orig_loc,
944 self.buf.as_ptr() as usize,
945 ))
946 }
947 pub fn get_sb_tc_index(&self) -> Result<u16, ErrorContext> {
948 let mut iter = self.clone();
949 iter.pos = 0;
950 for attr in iter {
951 if let Ok(Devlink::SbTcIndex(val)) = attr {
952 return Ok(val);
953 }
954 }
955 Err(ErrorContext::new_missing(
956 "Devlink",
957 "SbTcIndex",
958 self.orig_loc,
959 self.buf.as_ptr() as usize,
960 ))
961 }
962 pub fn get_sb_occ_cur(&self) -> Result<u32, ErrorContext> {
963 let mut iter = self.clone();
964 iter.pos = 0;
965 for attr in iter {
966 if let Ok(Devlink::SbOccCur(val)) = attr {
967 return Ok(val);
968 }
969 }
970 Err(ErrorContext::new_missing(
971 "Devlink",
972 "SbOccCur",
973 self.orig_loc,
974 self.buf.as_ptr() as usize,
975 ))
976 }
977 pub fn get_sb_occ_max(&self) -> Result<u32, ErrorContext> {
978 let mut iter = self.clone();
979 iter.pos = 0;
980 for attr in iter {
981 if let Ok(Devlink::SbOccMax(val)) = attr {
982 return Ok(val);
983 }
984 }
985 Err(ErrorContext::new_missing(
986 "Devlink",
987 "SbOccMax",
988 self.orig_loc,
989 self.buf.as_ptr() as usize,
990 ))
991 }
992 #[doc = "Associated type: [`EswitchMode`] (enum)"]
993 pub fn get_eswitch_mode(&self) -> Result<u16, ErrorContext> {
994 let mut iter = self.clone();
995 iter.pos = 0;
996 for attr in iter {
997 if let Ok(Devlink::EswitchMode(val)) = attr {
998 return Ok(val);
999 }
1000 }
1001 Err(ErrorContext::new_missing(
1002 "Devlink",
1003 "EswitchMode",
1004 self.orig_loc,
1005 self.buf.as_ptr() as usize,
1006 ))
1007 }
1008 #[doc = "Associated type: [`EswitchInlineMode`] (enum)"]
1009 pub fn get_eswitch_inline_mode(&self) -> Result<u8, ErrorContext> {
1010 let mut iter = self.clone();
1011 iter.pos = 0;
1012 for attr in iter {
1013 if let Ok(Devlink::EswitchInlineMode(val)) = attr {
1014 return Ok(val);
1015 }
1016 }
1017 Err(ErrorContext::new_missing(
1018 "Devlink",
1019 "EswitchInlineMode",
1020 self.orig_loc,
1021 self.buf.as_ptr() as usize,
1022 ))
1023 }
1024 pub fn get_dpipe_tables(&self) -> Result<IterableDlDpipeTables<'a>, ErrorContext> {
1025 let mut iter = self.clone();
1026 iter.pos = 0;
1027 for attr in iter {
1028 if let Ok(Devlink::DpipeTables(val)) = attr {
1029 return Ok(val);
1030 }
1031 }
1032 Err(ErrorContext::new_missing(
1033 "Devlink",
1034 "DpipeTables",
1035 self.orig_loc,
1036 self.buf.as_ptr() as usize,
1037 ))
1038 }
1039 #[doc = "Attribute may repeat multiple times (treat it as array)"]
1040 pub fn get_dpipe_table(
1041 &self,
1042 ) -> MultiAttrIterable<Self, Devlink<'a>, IterableDlDpipeTable<'a>> {
1043 MultiAttrIterable::new(self.clone(), |variant| {
1044 if let Devlink::DpipeTable(val) = variant {
1045 Some(val)
1046 } else {
1047 None
1048 }
1049 })
1050 }
1051 pub fn get_dpipe_table_name(&self) -> Result<&'a CStr, ErrorContext> {
1052 let mut iter = self.clone();
1053 iter.pos = 0;
1054 for attr in iter {
1055 if let Ok(Devlink::DpipeTableName(val)) = attr {
1056 return Ok(val);
1057 }
1058 }
1059 Err(ErrorContext::new_missing(
1060 "Devlink",
1061 "DpipeTableName",
1062 self.orig_loc,
1063 self.buf.as_ptr() as usize,
1064 ))
1065 }
1066 pub fn get_dpipe_table_size(&self) -> Result<u64, ErrorContext> {
1067 let mut iter = self.clone();
1068 iter.pos = 0;
1069 for attr in iter {
1070 if let Ok(Devlink::DpipeTableSize(val)) = attr {
1071 return Ok(val);
1072 }
1073 }
1074 Err(ErrorContext::new_missing(
1075 "Devlink",
1076 "DpipeTableSize",
1077 self.orig_loc,
1078 self.buf.as_ptr() as usize,
1079 ))
1080 }
1081 pub fn get_dpipe_table_matches(&self) -> Result<IterableDlDpipeTableMatches<'a>, ErrorContext> {
1082 let mut iter = self.clone();
1083 iter.pos = 0;
1084 for attr in iter {
1085 if let Ok(Devlink::DpipeTableMatches(val)) = attr {
1086 return Ok(val);
1087 }
1088 }
1089 Err(ErrorContext::new_missing(
1090 "Devlink",
1091 "DpipeTableMatches",
1092 self.orig_loc,
1093 self.buf.as_ptr() as usize,
1094 ))
1095 }
1096 pub fn get_dpipe_table_actions(&self) -> Result<IterableDlDpipeTableActions<'a>, ErrorContext> {
1097 let mut iter = self.clone();
1098 iter.pos = 0;
1099 for attr in iter {
1100 if let Ok(Devlink::DpipeTableActions(val)) = attr {
1101 return Ok(val);
1102 }
1103 }
1104 Err(ErrorContext::new_missing(
1105 "Devlink",
1106 "DpipeTableActions",
1107 self.orig_loc,
1108 self.buf.as_ptr() as usize,
1109 ))
1110 }
1111 pub fn get_dpipe_table_counters_enabled(&self) -> Result<u8, ErrorContext> {
1112 let mut iter = self.clone();
1113 iter.pos = 0;
1114 for attr in iter {
1115 if let Ok(Devlink::DpipeTableCountersEnabled(val)) = attr {
1116 return Ok(val);
1117 }
1118 }
1119 Err(ErrorContext::new_missing(
1120 "Devlink",
1121 "DpipeTableCountersEnabled",
1122 self.orig_loc,
1123 self.buf.as_ptr() as usize,
1124 ))
1125 }
1126 pub fn get_dpipe_entries(&self) -> Result<IterableDlDpipeEntries<'a>, ErrorContext> {
1127 let mut iter = self.clone();
1128 iter.pos = 0;
1129 for attr in iter {
1130 if let Ok(Devlink::DpipeEntries(val)) = attr {
1131 return Ok(val);
1132 }
1133 }
1134 Err(ErrorContext::new_missing(
1135 "Devlink",
1136 "DpipeEntries",
1137 self.orig_loc,
1138 self.buf.as_ptr() as usize,
1139 ))
1140 }
1141 #[doc = "Attribute may repeat multiple times (treat it as array)"]
1142 pub fn get_dpipe_entry(
1143 &self,
1144 ) -> MultiAttrIterable<Self, Devlink<'a>, IterableDlDpipeEntry<'a>> {
1145 MultiAttrIterable::new(self.clone(), |variant| {
1146 if let Devlink::DpipeEntry(val) = variant {
1147 Some(val)
1148 } else {
1149 None
1150 }
1151 })
1152 }
1153 pub fn get_dpipe_entry_index(&self) -> Result<u64, ErrorContext> {
1154 let mut iter = self.clone();
1155 iter.pos = 0;
1156 for attr in iter {
1157 if let Ok(Devlink::DpipeEntryIndex(val)) = attr {
1158 return Ok(val);
1159 }
1160 }
1161 Err(ErrorContext::new_missing(
1162 "Devlink",
1163 "DpipeEntryIndex",
1164 self.orig_loc,
1165 self.buf.as_ptr() as usize,
1166 ))
1167 }
1168 pub fn get_dpipe_entry_match_values(
1169 &self,
1170 ) -> Result<IterableDlDpipeEntryMatchValues<'a>, ErrorContext> {
1171 let mut iter = self.clone();
1172 iter.pos = 0;
1173 for attr in iter {
1174 if let Ok(Devlink::DpipeEntryMatchValues(val)) = attr {
1175 return Ok(val);
1176 }
1177 }
1178 Err(ErrorContext::new_missing(
1179 "Devlink",
1180 "DpipeEntryMatchValues",
1181 self.orig_loc,
1182 self.buf.as_ptr() as usize,
1183 ))
1184 }
1185 pub fn get_dpipe_entry_action_values(
1186 &self,
1187 ) -> Result<IterableDlDpipeEntryActionValues<'a>, ErrorContext> {
1188 let mut iter = self.clone();
1189 iter.pos = 0;
1190 for attr in iter {
1191 if let Ok(Devlink::DpipeEntryActionValues(val)) = attr {
1192 return Ok(val);
1193 }
1194 }
1195 Err(ErrorContext::new_missing(
1196 "Devlink",
1197 "DpipeEntryActionValues",
1198 self.orig_loc,
1199 self.buf.as_ptr() as usize,
1200 ))
1201 }
1202 pub fn get_dpipe_entry_counter(&self) -> Result<u64, ErrorContext> {
1203 let mut iter = self.clone();
1204 iter.pos = 0;
1205 for attr in iter {
1206 if let Ok(Devlink::DpipeEntryCounter(val)) = attr {
1207 return Ok(val);
1208 }
1209 }
1210 Err(ErrorContext::new_missing(
1211 "Devlink",
1212 "DpipeEntryCounter",
1213 self.orig_loc,
1214 self.buf.as_ptr() as usize,
1215 ))
1216 }
1217 #[doc = "Attribute may repeat multiple times (treat it as array)"]
1218 pub fn get_dpipe_match(
1219 &self,
1220 ) -> MultiAttrIterable<Self, Devlink<'a>, IterableDlDpipeMatch<'a>> {
1221 MultiAttrIterable::new(self.clone(), |variant| {
1222 if let Devlink::DpipeMatch(val) = variant {
1223 Some(val)
1224 } else {
1225 None
1226 }
1227 })
1228 }
1229 #[doc = "Attribute may repeat multiple times (treat it as array)"]
1230 pub fn get_dpipe_match_value(
1231 &self,
1232 ) -> MultiAttrIterable<Self, Devlink<'a>, IterableDlDpipeMatchValue<'a>> {
1233 MultiAttrIterable::new(self.clone(), |variant| {
1234 if let Devlink::DpipeMatchValue(val) = variant {
1235 Some(val)
1236 } else {
1237 None
1238 }
1239 })
1240 }
1241 #[doc = "Associated type: [`DpipeMatchType`] (enum)"]
1242 pub fn get_dpipe_match_type(&self) -> Result<u32, ErrorContext> {
1243 let mut iter = self.clone();
1244 iter.pos = 0;
1245 for attr in iter {
1246 if let Ok(Devlink::DpipeMatchType(val)) = attr {
1247 return Ok(val);
1248 }
1249 }
1250 Err(ErrorContext::new_missing(
1251 "Devlink",
1252 "DpipeMatchType",
1253 self.orig_loc,
1254 self.buf.as_ptr() as usize,
1255 ))
1256 }
1257 #[doc = "Attribute may repeat multiple times (treat it as array)"]
1258 pub fn get_dpipe_action(
1259 &self,
1260 ) -> MultiAttrIterable<Self, Devlink<'a>, IterableDlDpipeAction<'a>> {
1261 MultiAttrIterable::new(self.clone(), |variant| {
1262 if let Devlink::DpipeAction(val) = variant {
1263 Some(val)
1264 } else {
1265 None
1266 }
1267 })
1268 }
1269 #[doc = "Attribute may repeat multiple times (treat it as array)"]
1270 pub fn get_dpipe_action_value(
1271 &self,
1272 ) -> MultiAttrIterable<Self, Devlink<'a>, IterableDlDpipeActionValue<'a>> {
1273 MultiAttrIterable::new(self.clone(), |variant| {
1274 if let Devlink::DpipeActionValue(val) = variant {
1275 Some(val)
1276 } else {
1277 None
1278 }
1279 })
1280 }
1281 #[doc = "Associated type: [`DpipeActionType`] (enum)"]
1282 pub fn get_dpipe_action_type(&self) -> Result<u32, ErrorContext> {
1283 let mut iter = self.clone();
1284 iter.pos = 0;
1285 for attr in iter {
1286 if let Ok(Devlink::DpipeActionType(val)) = attr {
1287 return Ok(val);
1288 }
1289 }
1290 Err(ErrorContext::new_missing(
1291 "Devlink",
1292 "DpipeActionType",
1293 self.orig_loc,
1294 self.buf.as_ptr() as usize,
1295 ))
1296 }
1297 pub fn get_dpipe_value(&self) -> Result<&'a [u8], ErrorContext> {
1298 let mut iter = self.clone();
1299 iter.pos = 0;
1300 for attr in iter {
1301 if let Ok(Devlink::DpipeValue(val)) = attr {
1302 return Ok(val);
1303 }
1304 }
1305 Err(ErrorContext::new_missing(
1306 "Devlink",
1307 "DpipeValue",
1308 self.orig_loc,
1309 self.buf.as_ptr() as usize,
1310 ))
1311 }
1312 pub fn get_dpipe_value_mask(&self) -> Result<&'a [u8], ErrorContext> {
1313 let mut iter = self.clone();
1314 iter.pos = 0;
1315 for attr in iter {
1316 if let Ok(Devlink::DpipeValueMask(val)) = attr {
1317 return Ok(val);
1318 }
1319 }
1320 Err(ErrorContext::new_missing(
1321 "Devlink",
1322 "DpipeValueMask",
1323 self.orig_loc,
1324 self.buf.as_ptr() as usize,
1325 ))
1326 }
1327 pub fn get_dpipe_value_mapping(&self) -> Result<u32, ErrorContext> {
1328 let mut iter = self.clone();
1329 iter.pos = 0;
1330 for attr in iter {
1331 if let Ok(Devlink::DpipeValueMapping(val)) = attr {
1332 return Ok(val);
1333 }
1334 }
1335 Err(ErrorContext::new_missing(
1336 "Devlink",
1337 "DpipeValueMapping",
1338 self.orig_loc,
1339 self.buf.as_ptr() as usize,
1340 ))
1341 }
1342 pub fn get_dpipe_headers(&self) -> Result<IterableDlDpipeHeaders<'a>, ErrorContext> {
1343 let mut iter = self.clone();
1344 iter.pos = 0;
1345 for attr in iter {
1346 if let Ok(Devlink::DpipeHeaders(val)) = attr {
1347 return Ok(val);
1348 }
1349 }
1350 Err(ErrorContext::new_missing(
1351 "Devlink",
1352 "DpipeHeaders",
1353 self.orig_loc,
1354 self.buf.as_ptr() as usize,
1355 ))
1356 }
1357 #[doc = "Attribute may repeat multiple times (treat it as array)"]
1358 pub fn get_dpipe_header(
1359 &self,
1360 ) -> MultiAttrIterable<Self, Devlink<'a>, IterableDlDpipeHeader<'a>> {
1361 MultiAttrIterable::new(self.clone(), |variant| {
1362 if let Devlink::DpipeHeader(val) = variant {
1363 Some(val)
1364 } else {
1365 None
1366 }
1367 })
1368 }
1369 pub fn get_dpipe_header_name(&self) -> Result<&'a CStr, ErrorContext> {
1370 let mut iter = self.clone();
1371 iter.pos = 0;
1372 for attr in iter {
1373 if let Ok(Devlink::DpipeHeaderName(val)) = attr {
1374 return Ok(val);
1375 }
1376 }
1377 Err(ErrorContext::new_missing(
1378 "Devlink",
1379 "DpipeHeaderName",
1380 self.orig_loc,
1381 self.buf.as_ptr() as usize,
1382 ))
1383 }
1384 #[doc = "Associated type: [`DpipeHeaderId`] (enum)"]
1385 pub fn get_dpipe_header_id(&self) -> Result<u32, ErrorContext> {
1386 let mut iter = self.clone();
1387 iter.pos = 0;
1388 for attr in iter {
1389 if let Ok(Devlink::DpipeHeaderId(val)) = attr {
1390 return Ok(val);
1391 }
1392 }
1393 Err(ErrorContext::new_missing(
1394 "Devlink",
1395 "DpipeHeaderId",
1396 self.orig_loc,
1397 self.buf.as_ptr() as usize,
1398 ))
1399 }
1400 pub fn get_dpipe_header_fields(&self) -> Result<IterableDlDpipeHeaderFields<'a>, ErrorContext> {
1401 let mut iter = self.clone();
1402 iter.pos = 0;
1403 for attr in iter {
1404 if let Ok(Devlink::DpipeHeaderFields(val)) = attr {
1405 return Ok(val);
1406 }
1407 }
1408 Err(ErrorContext::new_missing(
1409 "Devlink",
1410 "DpipeHeaderFields",
1411 self.orig_loc,
1412 self.buf.as_ptr() as usize,
1413 ))
1414 }
1415 pub fn get_dpipe_header_global(&self) -> Result<u8, ErrorContext> {
1416 let mut iter = self.clone();
1417 iter.pos = 0;
1418 for attr in iter {
1419 if let Ok(Devlink::DpipeHeaderGlobal(val)) = attr {
1420 return Ok(val);
1421 }
1422 }
1423 Err(ErrorContext::new_missing(
1424 "Devlink",
1425 "DpipeHeaderGlobal",
1426 self.orig_loc,
1427 self.buf.as_ptr() as usize,
1428 ))
1429 }
1430 pub fn get_dpipe_header_index(&self) -> Result<u32, ErrorContext> {
1431 let mut iter = self.clone();
1432 iter.pos = 0;
1433 for attr in iter {
1434 if let Ok(Devlink::DpipeHeaderIndex(val)) = attr {
1435 return Ok(val);
1436 }
1437 }
1438 Err(ErrorContext::new_missing(
1439 "Devlink",
1440 "DpipeHeaderIndex",
1441 self.orig_loc,
1442 self.buf.as_ptr() as usize,
1443 ))
1444 }
1445 #[doc = "Attribute may repeat multiple times (treat it as array)"]
1446 pub fn get_dpipe_field(
1447 &self,
1448 ) -> MultiAttrIterable<Self, Devlink<'a>, IterableDlDpipeField<'a>> {
1449 MultiAttrIterable::new(self.clone(), |variant| {
1450 if let Devlink::DpipeField(val) = variant {
1451 Some(val)
1452 } else {
1453 None
1454 }
1455 })
1456 }
1457 pub fn get_dpipe_field_name(&self) -> Result<&'a CStr, ErrorContext> {
1458 let mut iter = self.clone();
1459 iter.pos = 0;
1460 for attr in iter {
1461 if let Ok(Devlink::DpipeFieldName(val)) = attr {
1462 return Ok(val);
1463 }
1464 }
1465 Err(ErrorContext::new_missing(
1466 "Devlink",
1467 "DpipeFieldName",
1468 self.orig_loc,
1469 self.buf.as_ptr() as usize,
1470 ))
1471 }
1472 pub fn get_dpipe_field_id(&self) -> Result<u32, ErrorContext> {
1473 let mut iter = self.clone();
1474 iter.pos = 0;
1475 for attr in iter {
1476 if let Ok(Devlink::DpipeFieldId(val)) = attr {
1477 return Ok(val);
1478 }
1479 }
1480 Err(ErrorContext::new_missing(
1481 "Devlink",
1482 "DpipeFieldId",
1483 self.orig_loc,
1484 self.buf.as_ptr() as usize,
1485 ))
1486 }
1487 pub fn get_dpipe_field_bitwidth(&self) -> Result<u32, ErrorContext> {
1488 let mut iter = self.clone();
1489 iter.pos = 0;
1490 for attr in iter {
1491 if let Ok(Devlink::DpipeFieldBitwidth(val)) = attr {
1492 return Ok(val);
1493 }
1494 }
1495 Err(ErrorContext::new_missing(
1496 "Devlink",
1497 "DpipeFieldBitwidth",
1498 self.orig_loc,
1499 self.buf.as_ptr() as usize,
1500 ))
1501 }
1502 #[doc = "Associated type: [`DpipeFieldMappingType`] (enum)"]
1503 pub fn get_dpipe_field_mapping_type(&self) -> Result<u32, ErrorContext> {
1504 let mut iter = self.clone();
1505 iter.pos = 0;
1506 for attr in iter {
1507 if let Ok(Devlink::DpipeFieldMappingType(val)) = attr {
1508 return Ok(val);
1509 }
1510 }
1511 Err(ErrorContext::new_missing(
1512 "Devlink",
1513 "DpipeFieldMappingType",
1514 self.orig_loc,
1515 self.buf.as_ptr() as usize,
1516 ))
1517 }
1518 pub fn get_pad(&self) -> Result<&'a [u8], ErrorContext> {
1519 let mut iter = self.clone();
1520 iter.pos = 0;
1521 for attr in iter {
1522 if let Ok(Devlink::Pad(val)) = attr {
1523 return Ok(val);
1524 }
1525 }
1526 Err(ErrorContext::new_missing(
1527 "Devlink",
1528 "Pad",
1529 self.orig_loc,
1530 self.buf.as_ptr() as usize,
1531 ))
1532 }
1533 #[doc = "Associated type: [`EswitchEncapMode`] (enum)"]
1534 pub fn get_eswitch_encap_mode(&self) -> Result<u8, ErrorContext> {
1535 let mut iter = self.clone();
1536 iter.pos = 0;
1537 for attr in iter {
1538 if let Ok(Devlink::EswitchEncapMode(val)) = attr {
1539 return Ok(val);
1540 }
1541 }
1542 Err(ErrorContext::new_missing(
1543 "Devlink",
1544 "EswitchEncapMode",
1545 self.orig_loc,
1546 self.buf.as_ptr() as usize,
1547 ))
1548 }
1549 pub fn get_resource_list(&self) -> Result<IterableDlResourceList<'a>, ErrorContext> {
1550 let mut iter = self.clone();
1551 iter.pos = 0;
1552 for attr in iter {
1553 if let Ok(Devlink::ResourceList(val)) = attr {
1554 return Ok(val);
1555 }
1556 }
1557 Err(ErrorContext::new_missing(
1558 "Devlink",
1559 "ResourceList",
1560 self.orig_loc,
1561 self.buf.as_ptr() as usize,
1562 ))
1563 }
1564 #[doc = "Attribute may repeat multiple times (treat it as array)"]
1565 pub fn get_resource(&self) -> MultiAttrIterable<Self, Devlink<'a>, IterableDlResource<'a>> {
1566 MultiAttrIterable::new(self.clone(), |variant| {
1567 if let Devlink::Resource(val) = variant {
1568 Some(val)
1569 } else {
1570 None
1571 }
1572 })
1573 }
1574 pub fn get_resource_name(&self) -> Result<&'a CStr, ErrorContext> {
1575 let mut iter = self.clone();
1576 iter.pos = 0;
1577 for attr in iter {
1578 if let Ok(Devlink::ResourceName(val)) = attr {
1579 return Ok(val);
1580 }
1581 }
1582 Err(ErrorContext::new_missing(
1583 "Devlink",
1584 "ResourceName",
1585 self.orig_loc,
1586 self.buf.as_ptr() as usize,
1587 ))
1588 }
1589 pub fn get_resource_id(&self) -> Result<u64, ErrorContext> {
1590 let mut iter = self.clone();
1591 iter.pos = 0;
1592 for attr in iter {
1593 if let Ok(Devlink::ResourceId(val)) = attr {
1594 return Ok(val);
1595 }
1596 }
1597 Err(ErrorContext::new_missing(
1598 "Devlink",
1599 "ResourceId",
1600 self.orig_loc,
1601 self.buf.as_ptr() as usize,
1602 ))
1603 }
1604 pub fn get_resource_size(&self) -> Result<u64, ErrorContext> {
1605 let mut iter = self.clone();
1606 iter.pos = 0;
1607 for attr in iter {
1608 if let Ok(Devlink::ResourceSize(val)) = attr {
1609 return Ok(val);
1610 }
1611 }
1612 Err(ErrorContext::new_missing(
1613 "Devlink",
1614 "ResourceSize",
1615 self.orig_loc,
1616 self.buf.as_ptr() as usize,
1617 ))
1618 }
1619 pub fn get_resource_size_new(&self) -> Result<u64, ErrorContext> {
1620 let mut iter = self.clone();
1621 iter.pos = 0;
1622 for attr in iter {
1623 if let Ok(Devlink::ResourceSizeNew(val)) = attr {
1624 return Ok(val);
1625 }
1626 }
1627 Err(ErrorContext::new_missing(
1628 "Devlink",
1629 "ResourceSizeNew",
1630 self.orig_loc,
1631 self.buf.as_ptr() as usize,
1632 ))
1633 }
1634 pub fn get_resource_size_valid(&self) -> Result<u8, ErrorContext> {
1635 let mut iter = self.clone();
1636 iter.pos = 0;
1637 for attr in iter {
1638 if let Ok(Devlink::ResourceSizeValid(val)) = attr {
1639 return Ok(val);
1640 }
1641 }
1642 Err(ErrorContext::new_missing(
1643 "Devlink",
1644 "ResourceSizeValid",
1645 self.orig_loc,
1646 self.buf.as_ptr() as usize,
1647 ))
1648 }
1649 pub fn get_resource_size_min(&self) -> Result<u64, ErrorContext> {
1650 let mut iter = self.clone();
1651 iter.pos = 0;
1652 for attr in iter {
1653 if let Ok(Devlink::ResourceSizeMin(val)) = attr {
1654 return Ok(val);
1655 }
1656 }
1657 Err(ErrorContext::new_missing(
1658 "Devlink",
1659 "ResourceSizeMin",
1660 self.orig_loc,
1661 self.buf.as_ptr() as usize,
1662 ))
1663 }
1664 pub fn get_resource_size_max(&self) -> Result<u64, ErrorContext> {
1665 let mut iter = self.clone();
1666 iter.pos = 0;
1667 for attr in iter {
1668 if let Ok(Devlink::ResourceSizeMax(val)) = attr {
1669 return Ok(val);
1670 }
1671 }
1672 Err(ErrorContext::new_missing(
1673 "Devlink",
1674 "ResourceSizeMax",
1675 self.orig_loc,
1676 self.buf.as_ptr() as usize,
1677 ))
1678 }
1679 pub fn get_resource_size_gran(&self) -> Result<u64, ErrorContext> {
1680 let mut iter = self.clone();
1681 iter.pos = 0;
1682 for attr in iter {
1683 if let Ok(Devlink::ResourceSizeGran(val)) = attr {
1684 return Ok(val);
1685 }
1686 }
1687 Err(ErrorContext::new_missing(
1688 "Devlink",
1689 "ResourceSizeGran",
1690 self.orig_loc,
1691 self.buf.as_ptr() as usize,
1692 ))
1693 }
1694 #[doc = "Associated type: [`ResourceUnit`] (enum)"]
1695 pub fn get_resource_unit(&self) -> Result<u8, ErrorContext> {
1696 let mut iter = self.clone();
1697 iter.pos = 0;
1698 for attr in iter {
1699 if let Ok(Devlink::ResourceUnit(val)) = attr {
1700 return Ok(val);
1701 }
1702 }
1703 Err(ErrorContext::new_missing(
1704 "Devlink",
1705 "ResourceUnit",
1706 self.orig_loc,
1707 self.buf.as_ptr() as usize,
1708 ))
1709 }
1710 pub fn get_resource_occ(&self) -> Result<u64, ErrorContext> {
1711 let mut iter = self.clone();
1712 iter.pos = 0;
1713 for attr in iter {
1714 if let Ok(Devlink::ResourceOcc(val)) = attr {
1715 return Ok(val);
1716 }
1717 }
1718 Err(ErrorContext::new_missing(
1719 "Devlink",
1720 "ResourceOcc",
1721 self.orig_loc,
1722 self.buf.as_ptr() as usize,
1723 ))
1724 }
1725 pub fn get_dpipe_table_resource_id(&self) -> Result<u64, ErrorContext> {
1726 let mut iter = self.clone();
1727 iter.pos = 0;
1728 for attr in iter {
1729 if let Ok(Devlink::DpipeTableResourceId(val)) = attr {
1730 return Ok(val);
1731 }
1732 }
1733 Err(ErrorContext::new_missing(
1734 "Devlink",
1735 "DpipeTableResourceId",
1736 self.orig_loc,
1737 self.buf.as_ptr() as usize,
1738 ))
1739 }
1740 pub fn get_dpipe_table_resource_units(&self) -> Result<u64, ErrorContext> {
1741 let mut iter = self.clone();
1742 iter.pos = 0;
1743 for attr in iter {
1744 if let Ok(Devlink::DpipeTableResourceUnits(val)) = attr {
1745 return Ok(val);
1746 }
1747 }
1748 Err(ErrorContext::new_missing(
1749 "Devlink",
1750 "DpipeTableResourceUnits",
1751 self.orig_loc,
1752 self.buf.as_ptr() as usize,
1753 ))
1754 }
1755 #[doc = "Associated type: [`PortFlavour`] (enum)"]
1756 pub fn get_port_flavour(&self) -> Result<u16, ErrorContext> {
1757 let mut iter = self.clone();
1758 iter.pos = 0;
1759 for attr in iter {
1760 if let Ok(Devlink::PortFlavour(val)) = attr {
1761 return Ok(val);
1762 }
1763 }
1764 Err(ErrorContext::new_missing(
1765 "Devlink",
1766 "PortFlavour",
1767 self.orig_loc,
1768 self.buf.as_ptr() as usize,
1769 ))
1770 }
1771 pub fn get_port_number(&self) -> Result<u32, ErrorContext> {
1772 let mut iter = self.clone();
1773 iter.pos = 0;
1774 for attr in iter {
1775 if let Ok(Devlink::PortNumber(val)) = attr {
1776 return Ok(val);
1777 }
1778 }
1779 Err(ErrorContext::new_missing(
1780 "Devlink",
1781 "PortNumber",
1782 self.orig_loc,
1783 self.buf.as_ptr() as usize,
1784 ))
1785 }
1786 pub fn get_port_split_subport_number(&self) -> Result<u32, ErrorContext> {
1787 let mut iter = self.clone();
1788 iter.pos = 0;
1789 for attr in iter {
1790 if let Ok(Devlink::PortSplitSubportNumber(val)) = attr {
1791 return Ok(val);
1792 }
1793 }
1794 Err(ErrorContext::new_missing(
1795 "Devlink",
1796 "PortSplitSubportNumber",
1797 self.orig_loc,
1798 self.buf.as_ptr() as usize,
1799 ))
1800 }
1801 pub fn get_param(&self) -> Result<IterableDlParam<'a>, ErrorContext> {
1802 let mut iter = self.clone();
1803 iter.pos = 0;
1804 for attr in iter {
1805 if let Ok(Devlink::Param(val)) = attr {
1806 return Ok(val);
1807 }
1808 }
1809 Err(ErrorContext::new_missing(
1810 "Devlink",
1811 "Param",
1812 self.orig_loc,
1813 self.buf.as_ptr() as usize,
1814 ))
1815 }
1816 pub fn get_param_name(&self) -> Result<&'a CStr, ErrorContext> {
1817 let mut iter = self.clone();
1818 iter.pos = 0;
1819 for attr in iter {
1820 if let Ok(Devlink::ParamName(val)) = attr {
1821 return Ok(val);
1822 }
1823 }
1824 Err(ErrorContext::new_missing(
1825 "Devlink",
1826 "ParamName",
1827 self.orig_loc,
1828 self.buf.as_ptr() as usize,
1829 ))
1830 }
1831 pub fn get_param_generic(&self) -> Result<(), ErrorContext> {
1832 let mut iter = self.clone();
1833 iter.pos = 0;
1834 for attr in iter {
1835 if let Ok(Devlink::ParamGeneric(val)) = attr {
1836 return Ok(val);
1837 }
1838 }
1839 Err(ErrorContext::new_missing(
1840 "Devlink",
1841 "ParamGeneric",
1842 self.orig_loc,
1843 self.buf.as_ptr() as usize,
1844 ))
1845 }
1846 #[doc = "Associated type: [`VarAttrType`] (enum)"]
1847 pub fn get_param_type(&self) -> Result<u8, ErrorContext> {
1848 let mut iter = self.clone();
1849 iter.pos = 0;
1850 for attr in iter {
1851 if let Ok(Devlink::ParamType(val)) = attr {
1852 return Ok(val);
1853 }
1854 }
1855 Err(ErrorContext::new_missing(
1856 "Devlink",
1857 "ParamType",
1858 self.orig_loc,
1859 self.buf.as_ptr() as usize,
1860 ))
1861 }
1862 #[doc = "Associated type: [`ParamCmode`] (enum)"]
1863 pub fn get_param_value_cmode(&self) -> Result<u8, ErrorContext> {
1864 let mut iter = self.clone();
1865 iter.pos = 0;
1866 for attr in iter {
1867 if let Ok(Devlink::ParamValueCmode(val)) = attr {
1868 return Ok(val);
1869 }
1870 }
1871 Err(ErrorContext::new_missing(
1872 "Devlink",
1873 "ParamValueCmode",
1874 self.orig_loc,
1875 self.buf.as_ptr() as usize,
1876 ))
1877 }
1878 pub fn get_region_name(&self) -> Result<&'a CStr, ErrorContext> {
1879 let mut iter = self.clone();
1880 iter.pos = 0;
1881 for attr in iter {
1882 if let Ok(Devlink::RegionName(val)) = attr {
1883 return Ok(val);
1884 }
1885 }
1886 Err(ErrorContext::new_missing(
1887 "Devlink",
1888 "RegionName",
1889 self.orig_loc,
1890 self.buf.as_ptr() as usize,
1891 ))
1892 }
1893 pub fn get_region_size(&self) -> Result<u64, ErrorContext> {
1894 let mut iter = self.clone();
1895 iter.pos = 0;
1896 for attr in iter {
1897 if let Ok(Devlink::RegionSize(val)) = attr {
1898 return Ok(val);
1899 }
1900 }
1901 Err(ErrorContext::new_missing(
1902 "Devlink",
1903 "RegionSize",
1904 self.orig_loc,
1905 self.buf.as_ptr() as usize,
1906 ))
1907 }
1908 pub fn get_region_snapshots(&self) -> Result<IterableDlRegionSnapshots<'a>, ErrorContext> {
1909 let mut iter = self.clone();
1910 iter.pos = 0;
1911 for attr in iter {
1912 if let Ok(Devlink::RegionSnapshots(val)) = attr {
1913 return Ok(val);
1914 }
1915 }
1916 Err(ErrorContext::new_missing(
1917 "Devlink",
1918 "RegionSnapshots",
1919 self.orig_loc,
1920 self.buf.as_ptr() as usize,
1921 ))
1922 }
1923 pub fn get_region_snapshot(&self) -> Result<IterableDlRegionSnapshot<'a>, ErrorContext> {
1924 let mut iter = self.clone();
1925 iter.pos = 0;
1926 for attr in iter {
1927 if let Ok(Devlink::RegionSnapshot(val)) = attr {
1928 return Ok(val);
1929 }
1930 }
1931 Err(ErrorContext::new_missing(
1932 "Devlink",
1933 "RegionSnapshot",
1934 self.orig_loc,
1935 self.buf.as_ptr() as usize,
1936 ))
1937 }
1938 pub fn get_region_snapshot_id(&self) -> Result<u32, ErrorContext> {
1939 let mut iter = self.clone();
1940 iter.pos = 0;
1941 for attr in iter {
1942 if let Ok(Devlink::RegionSnapshotId(val)) = attr {
1943 return Ok(val);
1944 }
1945 }
1946 Err(ErrorContext::new_missing(
1947 "Devlink",
1948 "RegionSnapshotId",
1949 self.orig_loc,
1950 self.buf.as_ptr() as usize,
1951 ))
1952 }
1953 pub fn get_region_chunks(&self) -> Result<IterableDlRegionChunks<'a>, ErrorContext> {
1954 let mut iter = self.clone();
1955 iter.pos = 0;
1956 for attr in iter {
1957 if let Ok(Devlink::RegionChunks(val)) = attr {
1958 return Ok(val);
1959 }
1960 }
1961 Err(ErrorContext::new_missing(
1962 "Devlink",
1963 "RegionChunks",
1964 self.orig_loc,
1965 self.buf.as_ptr() as usize,
1966 ))
1967 }
1968 pub fn get_region_chunk(&self) -> Result<IterableDlRegionChunk<'a>, ErrorContext> {
1969 let mut iter = self.clone();
1970 iter.pos = 0;
1971 for attr in iter {
1972 if let Ok(Devlink::RegionChunk(val)) = attr {
1973 return Ok(val);
1974 }
1975 }
1976 Err(ErrorContext::new_missing(
1977 "Devlink",
1978 "RegionChunk",
1979 self.orig_loc,
1980 self.buf.as_ptr() as usize,
1981 ))
1982 }
1983 pub fn get_region_chunk_data(&self) -> Result<&'a [u8], ErrorContext> {
1984 let mut iter = self.clone();
1985 iter.pos = 0;
1986 for attr in iter {
1987 if let Ok(Devlink::RegionChunkData(val)) = attr {
1988 return Ok(val);
1989 }
1990 }
1991 Err(ErrorContext::new_missing(
1992 "Devlink",
1993 "RegionChunkData",
1994 self.orig_loc,
1995 self.buf.as_ptr() as usize,
1996 ))
1997 }
1998 pub fn get_region_chunk_addr(&self) -> Result<u64, ErrorContext> {
1999 let mut iter = self.clone();
2000 iter.pos = 0;
2001 for attr in iter {
2002 if let Ok(Devlink::RegionChunkAddr(val)) = attr {
2003 return Ok(val);
2004 }
2005 }
2006 Err(ErrorContext::new_missing(
2007 "Devlink",
2008 "RegionChunkAddr",
2009 self.orig_loc,
2010 self.buf.as_ptr() as usize,
2011 ))
2012 }
2013 pub fn get_region_chunk_len(&self) -> Result<u64, ErrorContext> {
2014 let mut iter = self.clone();
2015 iter.pos = 0;
2016 for attr in iter {
2017 if let Ok(Devlink::RegionChunkLen(val)) = attr {
2018 return Ok(val);
2019 }
2020 }
2021 Err(ErrorContext::new_missing(
2022 "Devlink",
2023 "RegionChunkLen",
2024 self.orig_loc,
2025 self.buf.as_ptr() as usize,
2026 ))
2027 }
2028 pub fn get_info_driver_name(&self) -> Result<&'a CStr, ErrorContext> {
2029 let mut iter = self.clone();
2030 iter.pos = 0;
2031 for attr in iter {
2032 if let Ok(Devlink::InfoDriverName(val)) = attr {
2033 return Ok(val);
2034 }
2035 }
2036 Err(ErrorContext::new_missing(
2037 "Devlink",
2038 "InfoDriverName",
2039 self.orig_loc,
2040 self.buf.as_ptr() as usize,
2041 ))
2042 }
2043 pub fn get_info_serial_number(&self) -> Result<&'a CStr, ErrorContext> {
2044 let mut iter = self.clone();
2045 iter.pos = 0;
2046 for attr in iter {
2047 if let Ok(Devlink::InfoSerialNumber(val)) = attr {
2048 return Ok(val);
2049 }
2050 }
2051 Err(ErrorContext::new_missing(
2052 "Devlink",
2053 "InfoSerialNumber",
2054 self.orig_loc,
2055 self.buf.as_ptr() as usize,
2056 ))
2057 }
2058 #[doc = "Attribute may repeat multiple times (treat it as array)"]
2059 pub fn get_info_version_fixed(
2060 &self,
2061 ) -> MultiAttrIterable<Self, Devlink<'a>, IterableDlInfoVersion<'a>> {
2062 MultiAttrIterable::new(self.clone(), |variant| {
2063 if let Devlink::InfoVersionFixed(val) = variant {
2064 Some(val)
2065 } else {
2066 None
2067 }
2068 })
2069 }
2070 #[doc = "Attribute may repeat multiple times (treat it as array)"]
2071 pub fn get_info_version_running(
2072 &self,
2073 ) -> MultiAttrIterable<Self, Devlink<'a>, IterableDlInfoVersion<'a>> {
2074 MultiAttrIterable::new(self.clone(), |variant| {
2075 if let Devlink::InfoVersionRunning(val) = variant {
2076 Some(val)
2077 } else {
2078 None
2079 }
2080 })
2081 }
2082 #[doc = "Attribute may repeat multiple times (treat it as array)"]
2083 pub fn get_info_version_stored(
2084 &self,
2085 ) -> MultiAttrIterable<Self, Devlink<'a>, IterableDlInfoVersion<'a>> {
2086 MultiAttrIterable::new(self.clone(), |variant| {
2087 if let Devlink::InfoVersionStored(val) = variant {
2088 Some(val)
2089 } else {
2090 None
2091 }
2092 })
2093 }
2094 pub fn get_info_version_name(&self) -> Result<&'a CStr, ErrorContext> {
2095 let mut iter = self.clone();
2096 iter.pos = 0;
2097 for attr in iter {
2098 if let Ok(Devlink::InfoVersionName(val)) = attr {
2099 return Ok(val);
2100 }
2101 }
2102 Err(ErrorContext::new_missing(
2103 "Devlink",
2104 "InfoVersionName",
2105 self.orig_loc,
2106 self.buf.as_ptr() as usize,
2107 ))
2108 }
2109 pub fn get_info_version_value(&self) -> Result<&'a CStr, ErrorContext> {
2110 let mut iter = self.clone();
2111 iter.pos = 0;
2112 for attr in iter {
2113 if let Ok(Devlink::InfoVersionValue(val)) = attr {
2114 return Ok(val);
2115 }
2116 }
2117 Err(ErrorContext::new_missing(
2118 "Devlink",
2119 "InfoVersionValue",
2120 self.orig_loc,
2121 self.buf.as_ptr() as usize,
2122 ))
2123 }
2124 pub fn get_sb_pool_cell_size(&self) -> Result<u32, ErrorContext> {
2125 let mut iter = self.clone();
2126 iter.pos = 0;
2127 for attr in iter {
2128 if let Ok(Devlink::SbPoolCellSize(val)) = attr {
2129 return Ok(val);
2130 }
2131 }
2132 Err(ErrorContext::new_missing(
2133 "Devlink",
2134 "SbPoolCellSize",
2135 self.orig_loc,
2136 self.buf.as_ptr() as usize,
2137 ))
2138 }
2139 pub fn get_fmsg(&self) -> Result<IterableDlFmsg<'a>, ErrorContext> {
2140 let mut iter = self.clone();
2141 iter.pos = 0;
2142 for attr in iter {
2143 if let Ok(Devlink::Fmsg(val)) = attr {
2144 return Ok(val);
2145 }
2146 }
2147 Err(ErrorContext::new_missing(
2148 "Devlink",
2149 "Fmsg",
2150 self.orig_loc,
2151 self.buf.as_ptr() as usize,
2152 ))
2153 }
2154 pub fn get_fmsg_obj_nest_start(&self) -> Result<(), ErrorContext> {
2155 let mut iter = self.clone();
2156 iter.pos = 0;
2157 for attr in iter {
2158 if let Ok(Devlink::FmsgObjNestStart(val)) = attr {
2159 return Ok(val);
2160 }
2161 }
2162 Err(ErrorContext::new_missing(
2163 "Devlink",
2164 "FmsgObjNestStart",
2165 self.orig_loc,
2166 self.buf.as_ptr() as usize,
2167 ))
2168 }
2169 pub fn get_fmsg_pair_nest_start(&self) -> Result<(), ErrorContext> {
2170 let mut iter = self.clone();
2171 iter.pos = 0;
2172 for attr in iter {
2173 if let Ok(Devlink::FmsgPairNestStart(val)) = attr {
2174 return Ok(val);
2175 }
2176 }
2177 Err(ErrorContext::new_missing(
2178 "Devlink",
2179 "FmsgPairNestStart",
2180 self.orig_loc,
2181 self.buf.as_ptr() as usize,
2182 ))
2183 }
2184 pub fn get_fmsg_arr_nest_start(&self) -> Result<(), ErrorContext> {
2185 let mut iter = self.clone();
2186 iter.pos = 0;
2187 for attr in iter {
2188 if let Ok(Devlink::FmsgArrNestStart(val)) = attr {
2189 return Ok(val);
2190 }
2191 }
2192 Err(ErrorContext::new_missing(
2193 "Devlink",
2194 "FmsgArrNestStart",
2195 self.orig_loc,
2196 self.buf.as_ptr() as usize,
2197 ))
2198 }
2199 pub fn get_fmsg_nest_end(&self) -> Result<(), ErrorContext> {
2200 let mut iter = self.clone();
2201 iter.pos = 0;
2202 for attr in iter {
2203 if let Ok(Devlink::FmsgNestEnd(val)) = attr {
2204 return Ok(val);
2205 }
2206 }
2207 Err(ErrorContext::new_missing(
2208 "Devlink",
2209 "FmsgNestEnd",
2210 self.orig_loc,
2211 self.buf.as_ptr() as usize,
2212 ))
2213 }
2214 pub fn get_fmsg_obj_name(&self) -> Result<&'a CStr, ErrorContext> {
2215 let mut iter = self.clone();
2216 iter.pos = 0;
2217 for attr in iter {
2218 if let Ok(Devlink::FmsgObjName(val)) = attr {
2219 return Ok(val);
2220 }
2221 }
2222 Err(ErrorContext::new_missing(
2223 "Devlink",
2224 "FmsgObjName",
2225 self.orig_loc,
2226 self.buf.as_ptr() as usize,
2227 ))
2228 }
2229 #[doc = "Associated type: [`VarAttrType`] (enum)"]
2230 pub fn get_fmsg_obj_value_type(&self) -> Result<u8, ErrorContext> {
2231 let mut iter = self.clone();
2232 iter.pos = 0;
2233 for attr in iter {
2234 if let Ok(Devlink::FmsgObjValueType(val)) = attr {
2235 return Ok(val);
2236 }
2237 }
2238 Err(ErrorContext::new_missing(
2239 "Devlink",
2240 "FmsgObjValueType",
2241 self.orig_loc,
2242 self.buf.as_ptr() as usize,
2243 ))
2244 }
2245 pub fn get_health_reporter(&self) -> Result<IterableDlHealthReporter<'a>, ErrorContext> {
2246 let mut iter = self.clone();
2247 iter.pos = 0;
2248 for attr in iter {
2249 if let Ok(Devlink::HealthReporter(val)) = attr {
2250 return Ok(val);
2251 }
2252 }
2253 Err(ErrorContext::new_missing(
2254 "Devlink",
2255 "HealthReporter",
2256 self.orig_loc,
2257 self.buf.as_ptr() as usize,
2258 ))
2259 }
2260 pub fn get_health_reporter_name(&self) -> Result<&'a CStr, ErrorContext> {
2261 let mut iter = self.clone();
2262 iter.pos = 0;
2263 for attr in iter {
2264 if let Ok(Devlink::HealthReporterName(val)) = attr {
2265 return Ok(val);
2266 }
2267 }
2268 Err(ErrorContext::new_missing(
2269 "Devlink",
2270 "HealthReporterName",
2271 self.orig_loc,
2272 self.buf.as_ptr() as usize,
2273 ))
2274 }
2275 pub fn get_health_reporter_state(&self) -> Result<u8, ErrorContext> {
2276 let mut iter = self.clone();
2277 iter.pos = 0;
2278 for attr in iter {
2279 if let Ok(Devlink::HealthReporterState(val)) = attr {
2280 return Ok(val);
2281 }
2282 }
2283 Err(ErrorContext::new_missing(
2284 "Devlink",
2285 "HealthReporterState",
2286 self.orig_loc,
2287 self.buf.as_ptr() as usize,
2288 ))
2289 }
2290 pub fn get_health_reporter_err_count(&self) -> Result<u64, ErrorContext> {
2291 let mut iter = self.clone();
2292 iter.pos = 0;
2293 for attr in iter {
2294 if let Ok(Devlink::HealthReporterErrCount(val)) = attr {
2295 return Ok(val);
2296 }
2297 }
2298 Err(ErrorContext::new_missing(
2299 "Devlink",
2300 "HealthReporterErrCount",
2301 self.orig_loc,
2302 self.buf.as_ptr() as usize,
2303 ))
2304 }
2305 pub fn get_health_reporter_recover_count(&self) -> Result<u64, ErrorContext> {
2306 let mut iter = self.clone();
2307 iter.pos = 0;
2308 for attr in iter {
2309 if let Ok(Devlink::HealthReporterRecoverCount(val)) = attr {
2310 return Ok(val);
2311 }
2312 }
2313 Err(ErrorContext::new_missing(
2314 "Devlink",
2315 "HealthReporterRecoverCount",
2316 self.orig_loc,
2317 self.buf.as_ptr() as usize,
2318 ))
2319 }
2320 pub fn get_health_reporter_dump_ts(&self) -> Result<u64, ErrorContext> {
2321 let mut iter = self.clone();
2322 iter.pos = 0;
2323 for attr in iter {
2324 if let Ok(Devlink::HealthReporterDumpTs(val)) = attr {
2325 return Ok(val);
2326 }
2327 }
2328 Err(ErrorContext::new_missing(
2329 "Devlink",
2330 "HealthReporterDumpTs",
2331 self.orig_loc,
2332 self.buf.as_ptr() as usize,
2333 ))
2334 }
2335 pub fn get_health_reporter_graceful_period(&self) -> Result<u64, ErrorContext> {
2336 let mut iter = self.clone();
2337 iter.pos = 0;
2338 for attr in iter {
2339 if let Ok(Devlink::HealthReporterGracefulPeriod(val)) = attr {
2340 return Ok(val);
2341 }
2342 }
2343 Err(ErrorContext::new_missing(
2344 "Devlink",
2345 "HealthReporterGracefulPeriod",
2346 self.orig_loc,
2347 self.buf.as_ptr() as usize,
2348 ))
2349 }
2350 pub fn get_health_reporter_auto_recover(&self) -> Result<u8, ErrorContext> {
2351 let mut iter = self.clone();
2352 iter.pos = 0;
2353 for attr in iter {
2354 if let Ok(Devlink::HealthReporterAutoRecover(val)) = attr {
2355 return Ok(val);
2356 }
2357 }
2358 Err(ErrorContext::new_missing(
2359 "Devlink",
2360 "HealthReporterAutoRecover",
2361 self.orig_loc,
2362 self.buf.as_ptr() as usize,
2363 ))
2364 }
2365 pub fn get_flash_update_file_name(&self) -> Result<&'a CStr, ErrorContext> {
2366 let mut iter = self.clone();
2367 iter.pos = 0;
2368 for attr in iter {
2369 if let Ok(Devlink::FlashUpdateFileName(val)) = attr {
2370 return Ok(val);
2371 }
2372 }
2373 Err(ErrorContext::new_missing(
2374 "Devlink",
2375 "FlashUpdateFileName",
2376 self.orig_loc,
2377 self.buf.as_ptr() as usize,
2378 ))
2379 }
2380 pub fn get_flash_update_component(&self) -> Result<&'a CStr, ErrorContext> {
2381 let mut iter = self.clone();
2382 iter.pos = 0;
2383 for attr in iter {
2384 if let Ok(Devlink::FlashUpdateComponent(val)) = attr {
2385 return Ok(val);
2386 }
2387 }
2388 Err(ErrorContext::new_missing(
2389 "Devlink",
2390 "FlashUpdateComponent",
2391 self.orig_loc,
2392 self.buf.as_ptr() as usize,
2393 ))
2394 }
2395 pub fn get_flash_update_status_msg(&self) -> Result<&'a CStr, ErrorContext> {
2396 let mut iter = self.clone();
2397 iter.pos = 0;
2398 for attr in iter {
2399 if let Ok(Devlink::FlashUpdateStatusMsg(val)) = attr {
2400 return Ok(val);
2401 }
2402 }
2403 Err(ErrorContext::new_missing(
2404 "Devlink",
2405 "FlashUpdateStatusMsg",
2406 self.orig_loc,
2407 self.buf.as_ptr() as usize,
2408 ))
2409 }
2410 pub fn get_flash_update_status_done(&self) -> Result<u64, ErrorContext> {
2411 let mut iter = self.clone();
2412 iter.pos = 0;
2413 for attr in iter {
2414 if let Ok(Devlink::FlashUpdateStatusDone(val)) = attr {
2415 return Ok(val);
2416 }
2417 }
2418 Err(ErrorContext::new_missing(
2419 "Devlink",
2420 "FlashUpdateStatusDone",
2421 self.orig_loc,
2422 self.buf.as_ptr() as usize,
2423 ))
2424 }
2425 pub fn get_flash_update_status_total(&self) -> Result<u64, ErrorContext> {
2426 let mut iter = self.clone();
2427 iter.pos = 0;
2428 for attr in iter {
2429 if let Ok(Devlink::FlashUpdateStatusTotal(val)) = attr {
2430 return Ok(val);
2431 }
2432 }
2433 Err(ErrorContext::new_missing(
2434 "Devlink",
2435 "FlashUpdateStatusTotal",
2436 self.orig_loc,
2437 self.buf.as_ptr() as usize,
2438 ))
2439 }
2440 pub fn get_port_pci_pf_number(&self) -> Result<u16, ErrorContext> {
2441 let mut iter = self.clone();
2442 iter.pos = 0;
2443 for attr in iter {
2444 if let Ok(Devlink::PortPciPfNumber(val)) = attr {
2445 return Ok(val);
2446 }
2447 }
2448 Err(ErrorContext::new_missing(
2449 "Devlink",
2450 "PortPciPfNumber",
2451 self.orig_loc,
2452 self.buf.as_ptr() as usize,
2453 ))
2454 }
2455 pub fn get_port_pci_vf_number(&self) -> Result<u16, ErrorContext> {
2456 let mut iter = self.clone();
2457 iter.pos = 0;
2458 for attr in iter {
2459 if let Ok(Devlink::PortPciVfNumber(val)) = attr {
2460 return Ok(val);
2461 }
2462 }
2463 Err(ErrorContext::new_missing(
2464 "Devlink",
2465 "PortPciVfNumber",
2466 self.orig_loc,
2467 self.buf.as_ptr() as usize,
2468 ))
2469 }
2470 pub fn get_stats(&self) -> Result<IterableDlAttrStats<'a>, ErrorContext> {
2471 let mut iter = self.clone();
2472 iter.pos = 0;
2473 for attr in iter {
2474 if let Ok(Devlink::Stats(val)) = attr {
2475 return Ok(val);
2476 }
2477 }
2478 Err(ErrorContext::new_missing(
2479 "Devlink",
2480 "Stats",
2481 self.orig_loc,
2482 self.buf.as_ptr() as usize,
2483 ))
2484 }
2485 pub fn get_trap_name(&self) -> Result<&'a CStr, ErrorContext> {
2486 let mut iter = self.clone();
2487 iter.pos = 0;
2488 for attr in iter {
2489 if let Ok(Devlink::TrapName(val)) = attr {
2490 return Ok(val);
2491 }
2492 }
2493 Err(ErrorContext::new_missing(
2494 "Devlink",
2495 "TrapName",
2496 self.orig_loc,
2497 self.buf.as_ptr() as usize,
2498 ))
2499 }
2500 #[doc = "Associated type: [`TrapAction`] (enum)"]
2501 pub fn get_trap_action(&self) -> Result<u8, ErrorContext> {
2502 let mut iter = self.clone();
2503 iter.pos = 0;
2504 for attr in iter {
2505 if let Ok(Devlink::TrapAction(val)) = attr {
2506 return Ok(val);
2507 }
2508 }
2509 Err(ErrorContext::new_missing(
2510 "Devlink",
2511 "TrapAction",
2512 self.orig_loc,
2513 self.buf.as_ptr() as usize,
2514 ))
2515 }
2516 #[doc = "Associated type: [`TrapType`] (enum)"]
2517 pub fn get_trap_type(&self) -> Result<u8, ErrorContext> {
2518 let mut iter = self.clone();
2519 iter.pos = 0;
2520 for attr in iter {
2521 if let Ok(Devlink::TrapType(val)) = attr {
2522 return Ok(val);
2523 }
2524 }
2525 Err(ErrorContext::new_missing(
2526 "Devlink",
2527 "TrapType",
2528 self.orig_loc,
2529 self.buf.as_ptr() as usize,
2530 ))
2531 }
2532 pub fn get_trap_generic(&self) -> Result<(), ErrorContext> {
2533 let mut iter = self.clone();
2534 iter.pos = 0;
2535 for attr in iter {
2536 if let Ok(Devlink::TrapGeneric(val)) = attr {
2537 return Ok(val);
2538 }
2539 }
2540 Err(ErrorContext::new_missing(
2541 "Devlink",
2542 "TrapGeneric",
2543 self.orig_loc,
2544 self.buf.as_ptr() as usize,
2545 ))
2546 }
2547 pub fn get_trap_metadata(&self) -> Result<IterableDlTrapMetadata<'a>, ErrorContext> {
2548 let mut iter = self.clone();
2549 iter.pos = 0;
2550 for attr in iter {
2551 if let Ok(Devlink::TrapMetadata(val)) = attr {
2552 return Ok(val);
2553 }
2554 }
2555 Err(ErrorContext::new_missing(
2556 "Devlink",
2557 "TrapMetadata",
2558 self.orig_loc,
2559 self.buf.as_ptr() as usize,
2560 ))
2561 }
2562 pub fn get_trap_group_name(&self) -> Result<&'a CStr, ErrorContext> {
2563 let mut iter = self.clone();
2564 iter.pos = 0;
2565 for attr in iter {
2566 if let Ok(Devlink::TrapGroupName(val)) = attr {
2567 return Ok(val);
2568 }
2569 }
2570 Err(ErrorContext::new_missing(
2571 "Devlink",
2572 "TrapGroupName",
2573 self.orig_loc,
2574 self.buf.as_ptr() as usize,
2575 ))
2576 }
2577 pub fn get_reload_failed(&self) -> Result<u8, ErrorContext> {
2578 let mut iter = self.clone();
2579 iter.pos = 0;
2580 for attr in iter {
2581 if let Ok(Devlink::ReloadFailed(val)) = attr {
2582 return Ok(val);
2583 }
2584 }
2585 Err(ErrorContext::new_missing(
2586 "Devlink",
2587 "ReloadFailed",
2588 self.orig_loc,
2589 self.buf.as_ptr() as usize,
2590 ))
2591 }
2592 pub fn get_health_reporter_dump_ts_ns(&self) -> Result<u64, ErrorContext> {
2593 let mut iter = self.clone();
2594 iter.pos = 0;
2595 for attr in iter {
2596 if let Ok(Devlink::HealthReporterDumpTsNs(val)) = attr {
2597 return Ok(val);
2598 }
2599 }
2600 Err(ErrorContext::new_missing(
2601 "Devlink",
2602 "HealthReporterDumpTsNs",
2603 self.orig_loc,
2604 self.buf.as_ptr() as usize,
2605 ))
2606 }
2607 pub fn get_netns_fd(&self) -> Result<u32, ErrorContext> {
2608 let mut iter = self.clone();
2609 iter.pos = 0;
2610 for attr in iter {
2611 if let Ok(Devlink::NetnsFd(val)) = attr {
2612 return Ok(val);
2613 }
2614 }
2615 Err(ErrorContext::new_missing(
2616 "Devlink",
2617 "NetnsFd",
2618 self.orig_loc,
2619 self.buf.as_ptr() as usize,
2620 ))
2621 }
2622 pub fn get_netns_pid(&self) -> Result<u32, ErrorContext> {
2623 let mut iter = self.clone();
2624 iter.pos = 0;
2625 for attr in iter {
2626 if let Ok(Devlink::NetnsPid(val)) = attr {
2627 return Ok(val);
2628 }
2629 }
2630 Err(ErrorContext::new_missing(
2631 "Devlink",
2632 "NetnsPid",
2633 self.orig_loc,
2634 self.buf.as_ptr() as usize,
2635 ))
2636 }
2637 pub fn get_netns_id(&self) -> Result<u32, ErrorContext> {
2638 let mut iter = self.clone();
2639 iter.pos = 0;
2640 for attr in iter {
2641 if let Ok(Devlink::NetnsId(val)) = attr {
2642 return Ok(val);
2643 }
2644 }
2645 Err(ErrorContext::new_missing(
2646 "Devlink",
2647 "NetnsId",
2648 self.orig_loc,
2649 self.buf.as_ptr() as usize,
2650 ))
2651 }
2652 pub fn get_health_reporter_auto_dump(&self) -> Result<u8, ErrorContext> {
2653 let mut iter = self.clone();
2654 iter.pos = 0;
2655 for attr in iter {
2656 if let Ok(Devlink::HealthReporterAutoDump(val)) = attr {
2657 return Ok(val);
2658 }
2659 }
2660 Err(ErrorContext::new_missing(
2661 "Devlink",
2662 "HealthReporterAutoDump",
2663 self.orig_loc,
2664 self.buf.as_ptr() as usize,
2665 ))
2666 }
2667 pub fn get_trap_policer_id(&self) -> Result<u32, ErrorContext> {
2668 let mut iter = self.clone();
2669 iter.pos = 0;
2670 for attr in iter {
2671 if let Ok(Devlink::TrapPolicerId(val)) = attr {
2672 return Ok(val);
2673 }
2674 }
2675 Err(ErrorContext::new_missing(
2676 "Devlink",
2677 "TrapPolicerId",
2678 self.orig_loc,
2679 self.buf.as_ptr() as usize,
2680 ))
2681 }
2682 pub fn get_trap_policer_rate(&self) -> Result<u64, ErrorContext> {
2683 let mut iter = self.clone();
2684 iter.pos = 0;
2685 for attr in iter {
2686 if let Ok(Devlink::TrapPolicerRate(val)) = attr {
2687 return Ok(val);
2688 }
2689 }
2690 Err(ErrorContext::new_missing(
2691 "Devlink",
2692 "TrapPolicerRate",
2693 self.orig_loc,
2694 self.buf.as_ptr() as usize,
2695 ))
2696 }
2697 pub fn get_trap_policer_burst(&self) -> Result<u64, ErrorContext> {
2698 let mut iter = self.clone();
2699 iter.pos = 0;
2700 for attr in iter {
2701 if let Ok(Devlink::TrapPolicerBurst(val)) = attr {
2702 return Ok(val);
2703 }
2704 }
2705 Err(ErrorContext::new_missing(
2706 "Devlink",
2707 "TrapPolicerBurst",
2708 self.orig_loc,
2709 self.buf.as_ptr() as usize,
2710 ))
2711 }
2712 pub fn get_port_function(&self) -> Result<IterableDlPortFunction<'a>, ErrorContext> {
2713 let mut iter = self.clone();
2714 iter.pos = 0;
2715 for attr in iter {
2716 if let Ok(Devlink::PortFunction(val)) = attr {
2717 return Ok(val);
2718 }
2719 }
2720 Err(ErrorContext::new_missing(
2721 "Devlink",
2722 "PortFunction",
2723 self.orig_loc,
2724 self.buf.as_ptr() as usize,
2725 ))
2726 }
2727 pub fn get_info_board_serial_number(&self) -> Result<&'a CStr, ErrorContext> {
2728 let mut iter = self.clone();
2729 iter.pos = 0;
2730 for attr in iter {
2731 if let Ok(Devlink::InfoBoardSerialNumber(val)) = attr {
2732 return Ok(val);
2733 }
2734 }
2735 Err(ErrorContext::new_missing(
2736 "Devlink",
2737 "InfoBoardSerialNumber",
2738 self.orig_loc,
2739 self.buf.as_ptr() as usize,
2740 ))
2741 }
2742 pub fn get_port_lanes(&self) -> Result<u32, ErrorContext> {
2743 let mut iter = self.clone();
2744 iter.pos = 0;
2745 for attr in iter {
2746 if let Ok(Devlink::PortLanes(val)) = attr {
2747 return Ok(val);
2748 }
2749 }
2750 Err(ErrorContext::new_missing(
2751 "Devlink",
2752 "PortLanes",
2753 self.orig_loc,
2754 self.buf.as_ptr() as usize,
2755 ))
2756 }
2757 pub fn get_port_splittable(&self) -> Result<u8, ErrorContext> {
2758 let mut iter = self.clone();
2759 iter.pos = 0;
2760 for attr in iter {
2761 if let Ok(Devlink::PortSplittable(val)) = attr {
2762 return Ok(val);
2763 }
2764 }
2765 Err(ErrorContext::new_missing(
2766 "Devlink",
2767 "PortSplittable",
2768 self.orig_loc,
2769 self.buf.as_ptr() as usize,
2770 ))
2771 }
2772 pub fn get_port_external(&self) -> Result<u8, ErrorContext> {
2773 let mut iter = self.clone();
2774 iter.pos = 0;
2775 for attr in iter {
2776 if let Ok(Devlink::PortExternal(val)) = attr {
2777 return Ok(val);
2778 }
2779 }
2780 Err(ErrorContext::new_missing(
2781 "Devlink",
2782 "PortExternal",
2783 self.orig_loc,
2784 self.buf.as_ptr() as usize,
2785 ))
2786 }
2787 pub fn get_port_controller_number(&self) -> Result<u32, ErrorContext> {
2788 let mut iter = self.clone();
2789 iter.pos = 0;
2790 for attr in iter {
2791 if let Ok(Devlink::PortControllerNumber(val)) = attr {
2792 return Ok(val);
2793 }
2794 }
2795 Err(ErrorContext::new_missing(
2796 "Devlink",
2797 "PortControllerNumber",
2798 self.orig_loc,
2799 self.buf.as_ptr() as usize,
2800 ))
2801 }
2802 pub fn get_flash_update_status_timeout(&self) -> Result<u64, ErrorContext> {
2803 let mut iter = self.clone();
2804 iter.pos = 0;
2805 for attr in iter {
2806 if let Ok(Devlink::FlashUpdateStatusTimeout(val)) = attr {
2807 return Ok(val);
2808 }
2809 }
2810 Err(ErrorContext::new_missing(
2811 "Devlink",
2812 "FlashUpdateStatusTimeout",
2813 self.orig_loc,
2814 self.buf.as_ptr() as usize,
2815 ))
2816 }
2817 #[doc = "Associated type: [`FlashOverwrite`] (1 bit per enumeration)"]
2818 pub fn get_flash_update_overwrite_mask(&self) -> Result<BuiltinBitfield32, ErrorContext> {
2819 let mut iter = self.clone();
2820 iter.pos = 0;
2821 for attr in iter {
2822 if let Ok(Devlink::FlashUpdateOverwriteMask(val)) = attr {
2823 return Ok(val);
2824 }
2825 }
2826 Err(ErrorContext::new_missing(
2827 "Devlink",
2828 "FlashUpdateOverwriteMask",
2829 self.orig_loc,
2830 self.buf.as_ptr() as usize,
2831 ))
2832 }
2833 #[doc = "Associated type: [`ReloadAction`] (enum)"]
2834 pub fn get_reload_action(&self) -> Result<u8, ErrorContext> {
2835 let mut iter = self.clone();
2836 iter.pos = 0;
2837 for attr in iter {
2838 if let Ok(Devlink::ReloadAction(val)) = attr {
2839 return Ok(val);
2840 }
2841 }
2842 Err(ErrorContext::new_missing(
2843 "Devlink",
2844 "ReloadAction",
2845 self.orig_loc,
2846 self.buf.as_ptr() as usize,
2847 ))
2848 }
2849 #[doc = "Associated type: [`ReloadAction`] (1 bit per enumeration)"]
2850 pub fn get_reload_actions_performed(&self) -> Result<BuiltinBitfield32, ErrorContext> {
2851 let mut iter = self.clone();
2852 iter.pos = 0;
2853 for attr in iter {
2854 if let Ok(Devlink::ReloadActionsPerformed(val)) = attr {
2855 return Ok(val);
2856 }
2857 }
2858 Err(ErrorContext::new_missing(
2859 "Devlink",
2860 "ReloadActionsPerformed",
2861 self.orig_loc,
2862 self.buf.as_ptr() as usize,
2863 ))
2864 }
2865 #[doc = "Associated type: [`ReloadAction`] (1 bit per enumeration)"]
2866 pub fn get_reload_limits(&self) -> Result<BuiltinBitfield32, ErrorContext> {
2867 let mut iter = self.clone();
2868 iter.pos = 0;
2869 for attr in iter {
2870 if let Ok(Devlink::ReloadLimits(val)) = attr {
2871 return Ok(val);
2872 }
2873 }
2874 Err(ErrorContext::new_missing(
2875 "Devlink",
2876 "ReloadLimits",
2877 self.orig_loc,
2878 self.buf.as_ptr() as usize,
2879 ))
2880 }
2881 pub fn get_dev_stats(&self) -> Result<IterableDlDevStats<'a>, ErrorContext> {
2882 let mut iter = self.clone();
2883 iter.pos = 0;
2884 for attr in iter {
2885 if let Ok(Devlink::DevStats(val)) = attr {
2886 return Ok(val);
2887 }
2888 }
2889 Err(ErrorContext::new_missing(
2890 "Devlink",
2891 "DevStats",
2892 self.orig_loc,
2893 self.buf.as_ptr() as usize,
2894 ))
2895 }
2896 pub fn get_reload_stats(&self) -> Result<IterableDlReloadStats<'a>, ErrorContext> {
2897 let mut iter = self.clone();
2898 iter.pos = 0;
2899 for attr in iter {
2900 if let Ok(Devlink::ReloadStats(val)) = attr {
2901 return Ok(val);
2902 }
2903 }
2904 Err(ErrorContext::new_missing(
2905 "Devlink",
2906 "ReloadStats",
2907 self.orig_loc,
2908 self.buf.as_ptr() as usize,
2909 ))
2910 }
2911 #[doc = "Attribute may repeat multiple times (treat it as array)"]
2912 pub fn get_reload_stats_entry(
2913 &self,
2914 ) -> MultiAttrIterable<Self, Devlink<'a>, IterableDlReloadStatsEntry<'a>> {
2915 MultiAttrIterable::new(self.clone(), |variant| {
2916 if let Devlink::ReloadStatsEntry(val) = variant {
2917 Some(val)
2918 } else {
2919 None
2920 }
2921 })
2922 }
2923 pub fn get_reload_stats_limit(&self) -> Result<u8, ErrorContext> {
2924 let mut iter = self.clone();
2925 iter.pos = 0;
2926 for attr in iter {
2927 if let Ok(Devlink::ReloadStatsLimit(val)) = attr {
2928 return Ok(val);
2929 }
2930 }
2931 Err(ErrorContext::new_missing(
2932 "Devlink",
2933 "ReloadStatsLimit",
2934 self.orig_loc,
2935 self.buf.as_ptr() as usize,
2936 ))
2937 }
2938 pub fn get_reload_stats_value(&self) -> Result<u32, ErrorContext> {
2939 let mut iter = self.clone();
2940 iter.pos = 0;
2941 for attr in iter {
2942 if let Ok(Devlink::ReloadStatsValue(val)) = attr {
2943 return Ok(val);
2944 }
2945 }
2946 Err(ErrorContext::new_missing(
2947 "Devlink",
2948 "ReloadStatsValue",
2949 self.orig_loc,
2950 self.buf.as_ptr() as usize,
2951 ))
2952 }
2953 pub fn get_remote_reload_stats(&self) -> Result<IterableDlReloadStats<'a>, ErrorContext> {
2954 let mut iter = self.clone();
2955 iter.pos = 0;
2956 for attr in iter {
2957 if let Ok(Devlink::RemoteReloadStats(val)) = attr {
2958 return Ok(val);
2959 }
2960 }
2961 Err(ErrorContext::new_missing(
2962 "Devlink",
2963 "RemoteReloadStats",
2964 self.orig_loc,
2965 self.buf.as_ptr() as usize,
2966 ))
2967 }
2968 #[doc = "Attribute may repeat multiple times (treat it as array)"]
2969 pub fn get_reload_action_info(
2970 &self,
2971 ) -> MultiAttrIterable<Self, Devlink<'a>, IterableDlReloadActInfo<'a>> {
2972 MultiAttrIterable::new(self.clone(), |variant| {
2973 if let Devlink::ReloadActionInfo(val) = variant {
2974 Some(val)
2975 } else {
2976 None
2977 }
2978 })
2979 }
2980 #[doc = "Attribute may repeat multiple times (treat it as array)"]
2981 pub fn get_reload_action_stats(
2982 &self,
2983 ) -> MultiAttrIterable<Self, Devlink<'a>, IterableDlReloadActStats<'a>> {
2984 MultiAttrIterable::new(self.clone(), |variant| {
2985 if let Devlink::ReloadActionStats(val) = variant {
2986 Some(val)
2987 } else {
2988 None
2989 }
2990 })
2991 }
2992 pub fn get_port_pci_sf_number(&self) -> Result<u32, ErrorContext> {
2993 let mut iter = self.clone();
2994 iter.pos = 0;
2995 for attr in iter {
2996 if let Ok(Devlink::PortPciSfNumber(val)) = attr {
2997 return Ok(val);
2998 }
2999 }
3000 Err(ErrorContext::new_missing(
3001 "Devlink",
3002 "PortPciSfNumber",
3003 self.orig_loc,
3004 self.buf.as_ptr() as usize,
3005 ))
3006 }
3007 #[doc = "Associated type: [`RateType`] (enum)"]
3008 pub fn get_rate_type(&self) -> Result<u16, ErrorContext> {
3009 let mut iter = self.clone();
3010 iter.pos = 0;
3011 for attr in iter {
3012 if let Ok(Devlink::RateType(val)) = attr {
3013 return Ok(val);
3014 }
3015 }
3016 Err(ErrorContext::new_missing(
3017 "Devlink",
3018 "RateType",
3019 self.orig_loc,
3020 self.buf.as_ptr() as usize,
3021 ))
3022 }
3023 pub fn get_rate_tx_share(&self) -> Result<u64, ErrorContext> {
3024 let mut iter = self.clone();
3025 iter.pos = 0;
3026 for attr in iter {
3027 if let Ok(Devlink::RateTxShare(val)) = attr {
3028 return Ok(val);
3029 }
3030 }
3031 Err(ErrorContext::new_missing(
3032 "Devlink",
3033 "RateTxShare",
3034 self.orig_loc,
3035 self.buf.as_ptr() as usize,
3036 ))
3037 }
3038 pub fn get_rate_tx_max(&self) -> Result<u64, ErrorContext> {
3039 let mut iter = self.clone();
3040 iter.pos = 0;
3041 for attr in iter {
3042 if let Ok(Devlink::RateTxMax(val)) = attr {
3043 return Ok(val);
3044 }
3045 }
3046 Err(ErrorContext::new_missing(
3047 "Devlink",
3048 "RateTxMax",
3049 self.orig_loc,
3050 self.buf.as_ptr() as usize,
3051 ))
3052 }
3053 pub fn get_rate_node_name(&self) -> Result<&'a CStr, ErrorContext> {
3054 let mut iter = self.clone();
3055 iter.pos = 0;
3056 for attr in iter {
3057 if let Ok(Devlink::RateNodeName(val)) = attr {
3058 return Ok(val);
3059 }
3060 }
3061 Err(ErrorContext::new_missing(
3062 "Devlink",
3063 "RateNodeName",
3064 self.orig_loc,
3065 self.buf.as_ptr() as usize,
3066 ))
3067 }
3068 pub fn get_rate_parent_node_name(&self) -> Result<&'a CStr, ErrorContext> {
3069 let mut iter = self.clone();
3070 iter.pos = 0;
3071 for attr in iter {
3072 if let Ok(Devlink::RateParentNodeName(val)) = attr {
3073 return Ok(val);
3074 }
3075 }
3076 Err(ErrorContext::new_missing(
3077 "Devlink",
3078 "RateParentNodeName",
3079 self.orig_loc,
3080 self.buf.as_ptr() as usize,
3081 ))
3082 }
3083 pub fn get_region_max_snapshots(&self) -> Result<u32, ErrorContext> {
3084 let mut iter = self.clone();
3085 iter.pos = 0;
3086 for attr in iter {
3087 if let Ok(Devlink::RegionMaxSnapshots(val)) = attr {
3088 return Ok(val);
3089 }
3090 }
3091 Err(ErrorContext::new_missing(
3092 "Devlink",
3093 "RegionMaxSnapshots",
3094 self.orig_loc,
3095 self.buf.as_ptr() as usize,
3096 ))
3097 }
3098 pub fn get_linecard_index(&self) -> Result<u32, ErrorContext> {
3099 let mut iter = self.clone();
3100 iter.pos = 0;
3101 for attr in iter {
3102 if let Ok(Devlink::LinecardIndex(val)) = attr {
3103 return Ok(val);
3104 }
3105 }
3106 Err(ErrorContext::new_missing(
3107 "Devlink",
3108 "LinecardIndex",
3109 self.orig_loc,
3110 self.buf.as_ptr() as usize,
3111 ))
3112 }
3113 pub fn get_linecard_state(&self) -> Result<u8, ErrorContext> {
3114 let mut iter = self.clone();
3115 iter.pos = 0;
3116 for attr in iter {
3117 if let Ok(Devlink::LinecardState(val)) = attr {
3118 return Ok(val);
3119 }
3120 }
3121 Err(ErrorContext::new_missing(
3122 "Devlink",
3123 "LinecardState",
3124 self.orig_loc,
3125 self.buf.as_ptr() as usize,
3126 ))
3127 }
3128 pub fn get_linecard_type(&self) -> Result<&'a CStr, ErrorContext> {
3129 let mut iter = self.clone();
3130 iter.pos = 0;
3131 for attr in iter {
3132 if let Ok(Devlink::LinecardType(val)) = attr {
3133 return Ok(val);
3134 }
3135 }
3136 Err(ErrorContext::new_missing(
3137 "Devlink",
3138 "LinecardType",
3139 self.orig_loc,
3140 self.buf.as_ptr() as usize,
3141 ))
3142 }
3143 pub fn get_linecard_supported_types(
3144 &self,
3145 ) -> Result<IterableDlLinecardSupportedTypes<'a>, ErrorContext> {
3146 let mut iter = self.clone();
3147 iter.pos = 0;
3148 for attr in iter {
3149 if let Ok(Devlink::LinecardSupportedTypes(val)) = attr {
3150 return Ok(val);
3151 }
3152 }
3153 Err(ErrorContext::new_missing(
3154 "Devlink",
3155 "LinecardSupportedTypes",
3156 self.orig_loc,
3157 self.buf.as_ptr() as usize,
3158 ))
3159 }
3160 pub fn get_selftests(&self) -> Result<IterableDlSelftestId<'a>, ErrorContext> {
3161 let mut iter = self.clone();
3162 iter.pos = 0;
3163 for attr in iter {
3164 if let Ok(Devlink::Selftests(val)) = attr {
3165 return Ok(val);
3166 }
3167 }
3168 Err(ErrorContext::new_missing(
3169 "Devlink",
3170 "Selftests",
3171 self.orig_loc,
3172 self.buf.as_ptr() as usize,
3173 ))
3174 }
3175 pub fn get_rate_tx_priority(&self) -> Result<u32, ErrorContext> {
3176 let mut iter = self.clone();
3177 iter.pos = 0;
3178 for attr in iter {
3179 if let Ok(Devlink::RateTxPriority(val)) = attr {
3180 return Ok(val);
3181 }
3182 }
3183 Err(ErrorContext::new_missing(
3184 "Devlink",
3185 "RateTxPriority",
3186 self.orig_loc,
3187 self.buf.as_ptr() as usize,
3188 ))
3189 }
3190 pub fn get_rate_tx_weight(&self) -> Result<u32, ErrorContext> {
3191 let mut iter = self.clone();
3192 iter.pos = 0;
3193 for attr in iter {
3194 if let Ok(Devlink::RateTxWeight(val)) = attr {
3195 return Ok(val);
3196 }
3197 }
3198 Err(ErrorContext::new_missing(
3199 "Devlink",
3200 "RateTxWeight",
3201 self.orig_loc,
3202 self.buf.as_ptr() as usize,
3203 ))
3204 }
3205 pub fn get_region_direct(&self) -> Result<(), ErrorContext> {
3206 let mut iter = self.clone();
3207 iter.pos = 0;
3208 for attr in iter {
3209 if let Ok(Devlink::RegionDirect(val)) = attr {
3210 return Ok(val);
3211 }
3212 }
3213 Err(ErrorContext::new_missing(
3214 "Devlink",
3215 "RegionDirect",
3216 self.orig_loc,
3217 self.buf.as_ptr() as usize,
3218 ))
3219 }
3220 #[doc = "Attribute may repeat multiple times (treat it as array)"]
3221 pub fn get_rate_tc_bws(&self) -> MultiAttrIterable<Self, Devlink<'a>, IterableDlRateTcBws<'a>> {
3222 MultiAttrIterable::new(self.clone(), |variant| {
3223 if let Devlink::RateTcBws(val) = variant {
3224 Some(val)
3225 } else {
3226 None
3227 }
3228 })
3229 }
3230 #[doc = "Time (in msec) for recoveries before starting the grace period.\n"]
3231 pub fn get_health_reporter_burst_period(&self) -> Result<u64, ErrorContext> {
3232 let mut iter = self.clone();
3233 iter.pos = 0;
3234 for attr in iter {
3235 if let Ok(Devlink::HealthReporterBurstPeriod(val)) = attr {
3236 return Ok(val);
3237 }
3238 }
3239 Err(ErrorContext::new_missing(
3240 "Devlink",
3241 "HealthReporterBurstPeriod",
3242 self.orig_loc,
3243 self.buf.as_ptr() as usize,
3244 ))
3245 }
3246 #[doc = "Request restoring parameter to its default value.\n"]
3247 pub fn get_param_reset_default(&self) -> Result<(), ErrorContext> {
3248 let mut iter = self.clone();
3249 iter.pos = 0;
3250 for attr in iter {
3251 if let Ok(Devlink::ParamResetDefault(val)) = attr {
3252 return Ok(val);
3253 }
3254 }
3255 Err(ErrorContext::new_missing(
3256 "Devlink",
3257 "ParamResetDefault",
3258 self.orig_loc,
3259 self.buf.as_ptr() as usize,
3260 ))
3261 }
3262 #[doc = "Unique devlink instance index.\n"]
3263 pub fn get_index(&self) -> Result<u32, ErrorContext> {
3264 let mut iter = self.clone();
3265 iter.pos = 0;
3266 for attr in iter {
3267 if let Ok(Devlink::Index(val)) = attr {
3268 return Ok(val);
3269 }
3270 }
3271 Err(ErrorContext::new_missing(
3272 "Devlink",
3273 "Index",
3274 self.orig_loc,
3275 self.buf.as_ptr() as usize,
3276 ))
3277 }
3278 #[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)"]
3279 pub fn get_resource_scope_mask(&self) -> Result<u32, ErrorContext> {
3280 let mut iter = self.clone();
3281 iter.pos = 0;
3282 for attr in iter {
3283 if let Ok(Devlink::ResourceScopeMask(val)) = attr {
3284 return Ok(val);
3285 }
3286 }
3287 Err(ErrorContext::new_missing(
3288 "Devlink",
3289 "ResourceScopeMask",
3290 self.orig_loc,
3291 self.buf.as_ptr() as usize,
3292 ))
3293 }
3294}
3295impl Devlink<'_> {
3296 pub fn new<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
3297 IterableDevlink::with_loc(buf, buf.as_ptr() as usize)
3298 }
3299 fn attr_from_type(r#type: u16) -> Option<&'static str> {
3300 let res = match r#type {
3301 1u16 => "BusName",
3302 2u16 => "DevName",
3303 3u16 => "PortIndex",
3304 4u16 => "PortType",
3305 5u16 => "PortDesiredType",
3306 6u16 => "PortNetdevIfindex",
3307 7u16 => "PortNetdevName",
3308 8u16 => "PortIbdevName",
3309 9u16 => "PortSplitCount",
3310 10u16 => "PortSplitGroup",
3311 11u16 => "SbIndex",
3312 12u16 => "SbSize",
3313 13u16 => "SbIngressPoolCount",
3314 14u16 => "SbEgressPoolCount",
3315 15u16 => "SbIngressTcCount",
3316 16u16 => "SbEgressTcCount",
3317 17u16 => "SbPoolIndex",
3318 18u16 => "SbPoolType",
3319 19u16 => "SbPoolSize",
3320 20u16 => "SbPoolThresholdType",
3321 21u16 => "SbThreshold",
3322 22u16 => "SbTcIndex",
3323 23u16 => "SbOccCur",
3324 24u16 => "SbOccMax",
3325 25u16 => "EswitchMode",
3326 26u16 => "EswitchInlineMode",
3327 27u16 => "DpipeTables",
3328 28u16 => "DpipeTable",
3329 29u16 => "DpipeTableName",
3330 30u16 => "DpipeTableSize",
3331 31u16 => "DpipeTableMatches",
3332 32u16 => "DpipeTableActions",
3333 33u16 => "DpipeTableCountersEnabled",
3334 34u16 => "DpipeEntries",
3335 35u16 => "DpipeEntry",
3336 36u16 => "DpipeEntryIndex",
3337 37u16 => "DpipeEntryMatchValues",
3338 38u16 => "DpipeEntryActionValues",
3339 39u16 => "DpipeEntryCounter",
3340 40u16 => "DpipeMatch",
3341 41u16 => "DpipeMatchValue",
3342 42u16 => "DpipeMatchType",
3343 43u16 => "DpipeAction",
3344 44u16 => "DpipeActionValue",
3345 45u16 => "DpipeActionType",
3346 46u16 => "DpipeValue",
3347 47u16 => "DpipeValueMask",
3348 48u16 => "DpipeValueMapping",
3349 49u16 => "DpipeHeaders",
3350 50u16 => "DpipeHeader",
3351 51u16 => "DpipeHeaderName",
3352 52u16 => "DpipeHeaderId",
3353 53u16 => "DpipeHeaderFields",
3354 54u16 => "DpipeHeaderGlobal",
3355 55u16 => "DpipeHeaderIndex",
3356 56u16 => "DpipeField",
3357 57u16 => "DpipeFieldName",
3358 58u16 => "DpipeFieldId",
3359 59u16 => "DpipeFieldBitwidth",
3360 60u16 => "DpipeFieldMappingType",
3361 61u16 => "Pad",
3362 62u16 => "EswitchEncapMode",
3363 63u16 => "ResourceList",
3364 64u16 => "Resource",
3365 65u16 => "ResourceName",
3366 66u16 => "ResourceId",
3367 67u16 => "ResourceSize",
3368 68u16 => "ResourceSizeNew",
3369 69u16 => "ResourceSizeValid",
3370 70u16 => "ResourceSizeMin",
3371 71u16 => "ResourceSizeMax",
3372 72u16 => "ResourceSizeGran",
3373 73u16 => "ResourceUnit",
3374 74u16 => "ResourceOcc",
3375 75u16 => "DpipeTableResourceId",
3376 76u16 => "DpipeTableResourceUnits",
3377 77u16 => "PortFlavour",
3378 78u16 => "PortNumber",
3379 79u16 => "PortSplitSubportNumber",
3380 80u16 => "Param",
3381 81u16 => "ParamName",
3382 82u16 => "ParamGeneric",
3383 83u16 => "ParamType",
3384 87u16 => "ParamValueCmode",
3385 88u16 => "RegionName",
3386 89u16 => "RegionSize",
3387 90u16 => "RegionSnapshots",
3388 91u16 => "RegionSnapshot",
3389 92u16 => "RegionSnapshotId",
3390 93u16 => "RegionChunks",
3391 94u16 => "RegionChunk",
3392 95u16 => "RegionChunkData",
3393 96u16 => "RegionChunkAddr",
3394 97u16 => "RegionChunkLen",
3395 98u16 => "InfoDriverName",
3396 99u16 => "InfoSerialNumber",
3397 100u16 => "InfoVersionFixed",
3398 101u16 => "InfoVersionRunning",
3399 102u16 => "InfoVersionStored",
3400 103u16 => "InfoVersionName",
3401 104u16 => "InfoVersionValue",
3402 105u16 => "SbPoolCellSize",
3403 106u16 => "Fmsg",
3404 107u16 => "FmsgObjNestStart",
3405 108u16 => "FmsgPairNestStart",
3406 109u16 => "FmsgArrNestStart",
3407 110u16 => "FmsgNestEnd",
3408 111u16 => "FmsgObjName",
3409 112u16 => "FmsgObjValueType",
3410 114u16 => "HealthReporter",
3411 115u16 => "HealthReporterName",
3412 116u16 => "HealthReporterState",
3413 117u16 => "HealthReporterErrCount",
3414 118u16 => "HealthReporterRecoverCount",
3415 119u16 => "HealthReporterDumpTs",
3416 120u16 => "HealthReporterGracefulPeriod",
3417 121u16 => "HealthReporterAutoRecover",
3418 122u16 => "FlashUpdateFileName",
3419 123u16 => "FlashUpdateComponent",
3420 124u16 => "FlashUpdateStatusMsg",
3421 125u16 => "FlashUpdateStatusDone",
3422 126u16 => "FlashUpdateStatusTotal",
3423 127u16 => "PortPciPfNumber",
3424 128u16 => "PortPciVfNumber",
3425 129u16 => "Stats",
3426 130u16 => "TrapName",
3427 131u16 => "TrapAction",
3428 132u16 => "TrapType",
3429 133u16 => "TrapGeneric",
3430 134u16 => "TrapMetadata",
3431 135u16 => "TrapGroupName",
3432 136u16 => "ReloadFailed",
3433 137u16 => "HealthReporterDumpTsNs",
3434 138u16 => "NetnsFd",
3435 139u16 => "NetnsPid",
3436 140u16 => "NetnsId",
3437 141u16 => "HealthReporterAutoDump",
3438 142u16 => "TrapPolicerId",
3439 143u16 => "TrapPolicerRate",
3440 144u16 => "TrapPolicerBurst",
3441 145u16 => "PortFunction",
3442 146u16 => "InfoBoardSerialNumber",
3443 147u16 => "PortLanes",
3444 148u16 => "PortSplittable",
3445 149u16 => "PortExternal",
3446 150u16 => "PortControllerNumber",
3447 151u16 => "FlashUpdateStatusTimeout",
3448 152u16 => "FlashUpdateOverwriteMask",
3449 153u16 => "ReloadAction",
3450 154u16 => "ReloadActionsPerformed",
3451 155u16 => "ReloadLimits",
3452 156u16 => "DevStats",
3453 157u16 => "ReloadStats",
3454 158u16 => "ReloadStatsEntry",
3455 159u16 => "ReloadStatsLimit",
3456 160u16 => "ReloadStatsValue",
3457 161u16 => "RemoteReloadStats",
3458 162u16 => "ReloadActionInfo",
3459 163u16 => "ReloadActionStats",
3460 164u16 => "PortPciSfNumber",
3461 165u16 => "RateType",
3462 166u16 => "RateTxShare",
3463 167u16 => "RateTxMax",
3464 168u16 => "RateNodeName",
3465 169u16 => "RateParentNodeName",
3466 170u16 => "RegionMaxSnapshots",
3467 171u16 => "LinecardIndex",
3468 172u16 => "LinecardState",
3469 173u16 => "LinecardType",
3470 174u16 => "LinecardSupportedTypes",
3471 176u16 => "Selftests",
3472 177u16 => "RateTxPriority",
3473 178u16 => "RateTxWeight",
3474 179u16 => "RegionDirect",
3475 180u16 => "RateTcBws",
3476 181u16 => "HealthReporterBurstPeriod",
3477 183u16 => "ParamResetDefault",
3478 184u16 => "Index",
3479 185u16 => "ResourceScopeMask",
3480 _ => return None,
3481 };
3482 Some(res)
3483 }
3484}
3485#[derive(Clone, Copy, Default)]
3486pub struct IterableDevlink<'a> {
3487 buf: &'a [u8],
3488 pos: usize,
3489 orig_loc: usize,
3490}
3491impl<'a> IterableDevlink<'a> {
3492 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
3493 Self {
3494 buf,
3495 pos: 0,
3496 orig_loc,
3497 }
3498 }
3499 pub fn get_buf(&self) -> &'a [u8] {
3500 self.buf
3501 }
3502}
3503impl<'a> Iterator for IterableDevlink<'a> {
3504 type Item = Result<Devlink<'a>, ErrorContext>;
3505 fn next(&mut self) -> Option<Self::Item> {
3506 let mut pos;
3507 let mut r#type;
3508 loop {
3509 pos = self.pos;
3510 r#type = None;
3511 if self.buf.len() == self.pos {
3512 return None;
3513 }
3514 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
3515 self.pos = self.buf.len();
3516 break;
3517 };
3518 r#type = Some(header.r#type);
3519 let res = match header.r#type {
3520 1u16 => Devlink::BusName({
3521 let res = CStr::from_bytes_with_nul(next).ok();
3522 let Some(val) = res else { break };
3523 val
3524 }),
3525 2u16 => Devlink::DevName({
3526 let res = CStr::from_bytes_with_nul(next).ok();
3527 let Some(val) = res else { break };
3528 val
3529 }),
3530 3u16 => Devlink::PortIndex({
3531 let res = parse_u32(next);
3532 let Some(val) = res else { break };
3533 val
3534 }),
3535 4u16 => Devlink::PortType({
3536 let res = parse_u16(next);
3537 let Some(val) = res else { break };
3538 val
3539 }),
3540 5u16 => Devlink::PortDesiredType({
3541 let res = parse_u16(next);
3542 let Some(val) = res else { break };
3543 val
3544 }),
3545 6u16 => Devlink::PortNetdevIfindex({
3546 let res = parse_u32(next);
3547 let Some(val) = res else { break };
3548 val
3549 }),
3550 7u16 => Devlink::PortNetdevName({
3551 let res = CStr::from_bytes_with_nul(next).ok();
3552 let Some(val) = res else { break };
3553 val
3554 }),
3555 8u16 => Devlink::PortIbdevName({
3556 let res = CStr::from_bytes_with_nul(next).ok();
3557 let Some(val) = res else { break };
3558 val
3559 }),
3560 9u16 => Devlink::PortSplitCount({
3561 let res = parse_u32(next);
3562 let Some(val) = res else { break };
3563 val
3564 }),
3565 10u16 => Devlink::PortSplitGroup({
3566 let res = parse_u32(next);
3567 let Some(val) = res else { break };
3568 val
3569 }),
3570 11u16 => Devlink::SbIndex({
3571 let res = parse_u32(next);
3572 let Some(val) = res else { break };
3573 val
3574 }),
3575 12u16 => Devlink::SbSize({
3576 let res = parse_u32(next);
3577 let Some(val) = res else { break };
3578 val
3579 }),
3580 13u16 => Devlink::SbIngressPoolCount({
3581 let res = parse_u16(next);
3582 let Some(val) = res else { break };
3583 val
3584 }),
3585 14u16 => Devlink::SbEgressPoolCount({
3586 let res = parse_u16(next);
3587 let Some(val) = res else { break };
3588 val
3589 }),
3590 15u16 => Devlink::SbIngressTcCount({
3591 let res = parse_u16(next);
3592 let Some(val) = res else { break };
3593 val
3594 }),
3595 16u16 => Devlink::SbEgressTcCount({
3596 let res = parse_u16(next);
3597 let Some(val) = res else { break };
3598 val
3599 }),
3600 17u16 => Devlink::SbPoolIndex({
3601 let res = parse_u16(next);
3602 let Some(val) = res else { break };
3603 val
3604 }),
3605 18u16 => Devlink::SbPoolType({
3606 let res = parse_u8(next);
3607 let Some(val) = res else { break };
3608 val
3609 }),
3610 19u16 => Devlink::SbPoolSize({
3611 let res = parse_u32(next);
3612 let Some(val) = res else { break };
3613 val
3614 }),
3615 20u16 => Devlink::SbPoolThresholdType({
3616 let res = parse_u8(next);
3617 let Some(val) = res else { break };
3618 val
3619 }),
3620 21u16 => Devlink::SbThreshold({
3621 let res = parse_u32(next);
3622 let Some(val) = res else { break };
3623 val
3624 }),
3625 22u16 => Devlink::SbTcIndex({
3626 let res = parse_u16(next);
3627 let Some(val) = res else { break };
3628 val
3629 }),
3630 23u16 => Devlink::SbOccCur({
3631 let res = parse_u32(next);
3632 let Some(val) = res else { break };
3633 val
3634 }),
3635 24u16 => Devlink::SbOccMax({
3636 let res = parse_u32(next);
3637 let Some(val) = res else { break };
3638 val
3639 }),
3640 25u16 => Devlink::EswitchMode({
3641 let res = parse_u16(next);
3642 let Some(val) = res else { break };
3643 val
3644 }),
3645 26u16 => Devlink::EswitchInlineMode({
3646 let res = parse_u8(next);
3647 let Some(val) = res else { break };
3648 val
3649 }),
3650 27u16 => Devlink::DpipeTables({
3651 let res = Some(IterableDlDpipeTables::with_loc(next, self.orig_loc));
3652 let Some(val) = res else { break };
3653 val
3654 }),
3655 28u16 => Devlink::DpipeTable({
3656 let res = Some(IterableDlDpipeTable::with_loc(next, self.orig_loc));
3657 let Some(val) = res else { break };
3658 val
3659 }),
3660 29u16 => Devlink::DpipeTableName({
3661 let res = CStr::from_bytes_with_nul(next).ok();
3662 let Some(val) = res else { break };
3663 val
3664 }),
3665 30u16 => Devlink::DpipeTableSize({
3666 let res = parse_u64(next);
3667 let Some(val) = res else { break };
3668 val
3669 }),
3670 31u16 => Devlink::DpipeTableMatches({
3671 let res = Some(IterableDlDpipeTableMatches::with_loc(next, self.orig_loc));
3672 let Some(val) = res else { break };
3673 val
3674 }),
3675 32u16 => Devlink::DpipeTableActions({
3676 let res = Some(IterableDlDpipeTableActions::with_loc(next, self.orig_loc));
3677 let Some(val) = res else { break };
3678 val
3679 }),
3680 33u16 => Devlink::DpipeTableCountersEnabled({
3681 let res = parse_u8(next);
3682 let Some(val) = res else { break };
3683 val
3684 }),
3685 34u16 => Devlink::DpipeEntries({
3686 let res = Some(IterableDlDpipeEntries::with_loc(next, self.orig_loc));
3687 let Some(val) = res else { break };
3688 val
3689 }),
3690 35u16 => Devlink::DpipeEntry({
3691 let res = Some(IterableDlDpipeEntry::with_loc(next, self.orig_loc));
3692 let Some(val) = res else { break };
3693 val
3694 }),
3695 36u16 => Devlink::DpipeEntryIndex({
3696 let res = parse_u64(next);
3697 let Some(val) = res else { break };
3698 val
3699 }),
3700 37u16 => Devlink::DpipeEntryMatchValues({
3701 let res = Some(IterableDlDpipeEntryMatchValues::with_loc(
3702 next,
3703 self.orig_loc,
3704 ));
3705 let Some(val) = res else { break };
3706 val
3707 }),
3708 38u16 => Devlink::DpipeEntryActionValues({
3709 let res = Some(IterableDlDpipeEntryActionValues::with_loc(
3710 next,
3711 self.orig_loc,
3712 ));
3713 let Some(val) = res else { break };
3714 val
3715 }),
3716 39u16 => Devlink::DpipeEntryCounter({
3717 let res = parse_u64(next);
3718 let Some(val) = res else { break };
3719 val
3720 }),
3721 40u16 => Devlink::DpipeMatch({
3722 let res = Some(IterableDlDpipeMatch::with_loc(next, self.orig_loc));
3723 let Some(val) = res else { break };
3724 val
3725 }),
3726 41u16 => Devlink::DpipeMatchValue({
3727 let res = Some(IterableDlDpipeMatchValue::with_loc(next, self.orig_loc));
3728 let Some(val) = res else { break };
3729 val
3730 }),
3731 42u16 => Devlink::DpipeMatchType({
3732 let res = parse_u32(next);
3733 let Some(val) = res else { break };
3734 val
3735 }),
3736 43u16 => Devlink::DpipeAction({
3737 let res = Some(IterableDlDpipeAction::with_loc(next, self.orig_loc));
3738 let Some(val) = res else { break };
3739 val
3740 }),
3741 44u16 => Devlink::DpipeActionValue({
3742 let res = Some(IterableDlDpipeActionValue::with_loc(next, self.orig_loc));
3743 let Some(val) = res else { break };
3744 val
3745 }),
3746 45u16 => Devlink::DpipeActionType({
3747 let res = parse_u32(next);
3748 let Some(val) = res else { break };
3749 val
3750 }),
3751 46u16 => Devlink::DpipeValue({
3752 let res = Some(next);
3753 let Some(val) = res else { break };
3754 val
3755 }),
3756 47u16 => Devlink::DpipeValueMask({
3757 let res = Some(next);
3758 let Some(val) = res else { break };
3759 val
3760 }),
3761 48u16 => Devlink::DpipeValueMapping({
3762 let res = parse_u32(next);
3763 let Some(val) = res else { break };
3764 val
3765 }),
3766 49u16 => Devlink::DpipeHeaders({
3767 let res = Some(IterableDlDpipeHeaders::with_loc(next, self.orig_loc));
3768 let Some(val) = res else { break };
3769 val
3770 }),
3771 50u16 => Devlink::DpipeHeader({
3772 let res = Some(IterableDlDpipeHeader::with_loc(next, self.orig_loc));
3773 let Some(val) = res else { break };
3774 val
3775 }),
3776 51u16 => Devlink::DpipeHeaderName({
3777 let res = CStr::from_bytes_with_nul(next).ok();
3778 let Some(val) = res else { break };
3779 val
3780 }),
3781 52u16 => Devlink::DpipeHeaderId({
3782 let res = parse_u32(next);
3783 let Some(val) = res else { break };
3784 val
3785 }),
3786 53u16 => Devlink::DpipeHeaderFields({
3787 let res = Some(IterableDlDpipeHeaderFields::with_loc(next, self.orig_loc));
3788 let Some(val) = res else { break };
3789 val
3790 }),
3791 54u16 => Devlink::DpipeHeaderGlobal({
3792 let res = parse_u8(next);
3793 let Some(val) = res else { break };
3794 val
3795 }),
3796 55u16 => Devlink::DpipeHeaderIndex({
3797 let res = parse_u32(next);
3798 let Some(val) = res else { break };
3799 val
3800 }),
3801 56u16 => Devlink::DpipeField({
3802 let res = Some(IterableDlDpipeField::with_loc(next, self.orig_loc));
3803 let Some(val) = res else { break };
3804 val
3805 }),
3806 57u16 => Devlink::DpipeFieldName({
3807 let res = CStr::from_bytes_with_nul(next).ok();
3808 let Some(val) = res else { break };
3809 val
3810 }),
3811 58u16 => Devlink::DpipeFieldId({
3812 let res = parse_u32(next);
3813 let Some(val) = res else { break };
3814 val
3815 }),
3816 59u16 => Devlink::DpipeFieldBitwidth({
3817 let res = parse_u32(next);
3818 let Some(val) = res else { break };
3819 val
3820 }),
3821 60u16 => Devlink::DpipeFieldMappingType({
3822 let res = parse_u32(next);
3823 let Some(val) = res else { break };
3824 val
3825 }),
3826 61u16 => Devlink::Pad({
3827 let res = Some(next);
3828 let Some(val) = res else { break };
3829 val
3830 }),
3831 62u16 => Devlink::EswitchEncapMode({
3832 let res = parse_u8(next);
3833 let Some(val) = res else { break };
3834 val
3835 }),
3836 63u16 => Devlink::ResourceList({
3837 let res = Some(IterableDlResourceList::with_loc(next, self.orig_loc));
3838 let Some(val) = res else { break };
3839 val
3840 }),
3841 64u16 => Devlink::Resource({
3842 let res = Some(IterableDlResource::with_loc(next, self.orig_loc));
3843 let Some(val) = res else { break };
3844 val
3845 }),
3846 65u16 => Devlink::ResourceName({
3847 let res = CStr::from_bytes_with_nul(next).ok();
3848 let Some(val) = res else { break };
3849 val
3850 }),
3851 66u16 => Devlink::ResourceId({
3852 let res = parse_u64(next);
3853 let Some(val) = res else { break };
3854 val
3855 }),
3856 67u16 => Devlink::ResourceSize({
3857 let res = parse_u64(next);
3858 let Some(val) = res else { break };
3859 val
3860 }),
3861 68u16 => Devlink::ResourceSizeNew({
3862 let res = parse_u64(next);
3863 let Some(val) = res else { break };
3864 val
3865 }),
3866 69u16 => Devlink::ResourceSizeValid({
3867 let res = parse_u8(next);
3868 let Some(val) = res else { break };
3869 val
3870 }),
3871 70u16 => Devlink::ResourceSizeMin({
3872 let res = parse_u64(next);
3873 let Some(val) = res else { break };
3874 val
3875 }),
3876 71u16 => Devlink::ResourceSizeMax({
3877 let res = parse_u64(next);
3878 let Some(val) = res else { break };
3879 val
3880 }),
3881 72u16 => Devlink::ResourceSizeGran({
3882 let res = parse_u64(next);
3883 let Some(val) = res else { break };
3884 val
3885 }),
3886 73u16 => Devlink::ResourceUnit({
3887 let res = parse_u8(next);
3888 let Some(val) = res else { break };
3889 val
3890 }),
3891 74u16 => Devlink::ResourceOcc({
3892 let res = parse_u64(next);
3893 let Some(val) = res else { break };
3894 val
3895 }),
3896 75u16 => Devlink::DpipeTableResourceId({
3897 let res = parse_u64(next);
3898 let Some(val) = res else { break };
3899 val
3900 }),
3901 76u16 => Devlink::DpipeTableResourceUnits({
3902 let res = parse_u64(next);
3903 let Some(val) = res else { break };
3904 val
3905 }),
3906 77u16 => Devlink::PortFlavour({
3907 let res = parse_u16(next);
3908 let Some(val) = res else { break };
3909 val
3910 }),
3911 78u16 => Devlink::PortNumber({
3912 let res = parse_u32(next);
3913 let Some(val) = res else { break };
3914 val
3915 }),
3916 79u16 => Devlink::PortSplitSubportNumber({
3917 let res = parse_u32(next);
3918 let Some(val) = res else { break };
3919 val
3920 }),
3921 80u16 => Devlink::Param({
3922 let res = Some(IterableDlParam::with_loc(next, self.orig_loc));
3923 let Some(val) = res else { break };
3924 val
3925 }),
3926 81u16 => Devlink::ParamName({
3927 let res = CStr::from_bytes_with_nul(next).ok();
3928 let Some(val) = res else { break };
3929 val
3930 }),
3931 82u16 => Devlink::ParamGeneric(()),
3932 83u16 => Devlink::ParamType({
3933 let res = parse_u8(next);
3934 let Some(val) = res else { break };
3935 val
3936 }),
3937 87u16 => Devlink::ParamValueCmode({
3938 let res = parse_u8(next);
3939 let Some(val) = res else { break };
3940 val
3941 }),
3942 88u16 => Devlink::RegionName({
3943 let res = CStr::from_bytes_with_nul(next).ok();
3944 let Some(val) = res else { break };
3945 val
3946 }),
3947 89u16 => Devlink::RegionSize({
3948 let res = parse_u64(next);
3949 let Some(val) = res else { break };
3950 val
3951 }),
3952 90u16 => Devlink::RegionSnapshots({
3953 let res = Some(IterableDlRegionSnapshots::with_loc(next, self.orig_loc));
3954 let Some(val) = res else { break };
3955 val
3956 }),
3957 91u16 => Devlink::RegionSnapshot({
3958 let res = Some(IterableDlRegionSnapshot::with_loc(next, self.orig_loc));
3959 let Some(val) = res else { break };
3960 val
3961 }),
3962 92u16 => Devlink::RegionSnapshotId({
3963 let res = parse_u32(next);
3964 let Some(val) = res else { break };
3965 val
3966 }),
3967 93u16 => Devlink::RegionChunks({
3968 let res = Some(IterableDlRegionChunks::with_loc(next, self.orig_loc));
3969 let Some(val) = res else { break };
3970 val
3971 }),
3972 94u16 => Devlink::RegionChunk({
3973 let res = Some(IterableDlRegionChunk::with_loc(next, self.orig_loc));
3974 let Some(val) = res else { break };
3975 val
3976 }),
3977 95u16 => Devlink::RegionChunkData({
3978 let res = Some(next);
3979 let Some(val) = res else { break };
3980 val
3981 }),
3982 96u16 => Devlink::RegionChunkAddr({
3983 let res = parse_u64(next);
3984 let Some(val) = res else { break };
3985 val
3986 }),
3987 97u16 => Devlink::RegionChunkLen({
3988 let res = parse_u64(next);
3989 let Some(val) = res else { break };
3990 val
3991 }),
3992 98u16 => Devlink::InfoDriverName({
3993 let res = CStr::from_bytes_with_nul(next).ok();
3994 let Some(val) = res else { break };
3995 val
3996 }),
3997 99u16 => Devlink::InfoSerialNumber({
3998 let res = CStr::from_bytes_with_nul(next).ok();
3999 let Some(val) = res else { break };
4000 val
4001 }),
4002 100u16 => Devlink::InfoVersionFixed({
4003 let res = Some(IterableDlInfoVersion::with_loc(next, self.orig_loc));
4004 let Some(val) = res else { break };
4005 val
4006 }),
4007 101u16 => Devlink::InfoVersionRunning({
4008 let res = Some(IterableDlInfoVersion::with_loc(next, self.orig_loc));
4009 let Some(val) = res else { break };
4010 val
4011 }),
4012 102u16 => Devlink::InfoVersionStored({
4013 let res = Some(IterableDlInfoVersion::with_loc(next, self.orig_loc));
4014 let Some(val) = res else { break };
4015 val
4016 }),
4017 103u16 => Devlink::InfoVersionName({
4018 let res = CStr::from_bytes_with_nul(next).ok();
4019 let Some(val) = res else { break };
4020 val
4021 }),
4022 104u16 => Devlink::InfoVersionValue({
4023 let res = CStr::from_bytes_with_nul(next).ok();
4024 let Some(val) = res else { break };
4025 val
4026 }),
4027 105u16 => Devlink::SbPoolCellSize({
4028 let res = parse_u32(next);
4029 let Some(val) = res else { break };
4030 val
4031 }),
4032 106u16 => Devlink::Fmsg({
4033 let res = Some(IterableDlFmsg::with_loc(next, self.orig_loc));
4034 let Some(val) = res else { break };
4035 val
4036 }),
4037 107u16 => Devlink::FmsgObjNestStart(()),
4038 108u16 => Devlink::FmsgPairNestStart(()),
4039 109u16 => Devlink::FmsgArrNestStart(()),
4040 110u16 => Devlink::FmsgNestEnd(()),
4041 111u16 => Devlink::FmsgObjName({
4042 let res = CStr::from_bytes_with_nul(next).ok();
4043 let Some(val) = res else { break };
4044 val
4045 }),
4046 112u16 => Devlink::FmsgObjValueType({
4047 let res = parse_u8(next);
4048 let Some(val) = res else { break };
4049 val
4050 }),
4051 114u16 => Devlink::HealthReporter({
4052 let res = Some(IterableDlHealthReporter::with_loc(next, self.orig_loc));
4053 let Some(val) = res else { break };
4054 val
4055 }),
4056 115u16 => Devlink::HealthReporterName({
4057 let res = CStr::from_bytes_with_nul(next).ok();
4058 let Some(val) = res else { break };
4059 val
4060 }),
4061 116u16 => Devlink::HealthReporterState({
4062 let res = parse_u8(next);
4063 let Some(val) = res else { break };
4064 val
4065 }),
4066 117u16 => Devlink::HealthReporterErrCount({
4067 let res = parse_u64(next);
4068 let Some(val) = res else { break };
4069 val
4070 }),
4071 118u16 => Devlink::HealthReporterRecoverCount({
4072 let res = parse_u64(next);
4073 let Some(val) = res else { break };
4074 val
4075 }),
4076 119u16 => Devlink::HealthReporterDumpTs({
4077 let res = parse_u64(next);
4078 let Some(val) = res else { break };
4079 val
4080 }),
4081 120u16 => Devlink::HealthReporterGracefulPeriod({
4082 let res = parse_u64(next);
4083 let Some(val) = res else { break };
4084 val
4085 }),
4086 121u16 => Devlink::HealthReporterAutoRecover({
4087 let res = parse_u8(next);
4088 let Some(val) = res else { break };
4089 val
4090 }),
4091 122u16 => Devlink::FlashUpdateFileName({
4092 let res = CStr::from_bytes_with_nul(next).ok();
4093 let Some(val) = res else { break };
4094 val
4095 }),
4096 123u16 => Devlink::FlashUpdateComponent({
4097 let res = CStr::from_bytes_with_nul(next).ok();
4098 let Some(val) = res else { break };
4099 val
4100 }),
4101 124u16 => Devlink::FlashUpdateStatusMsg({
4102 let res = CStr::from_bytes_with_nul(next).ok();
4103 let Some(val) = res else { break };
4104 val
4105 }),
4106 125u16 => Devlink::FlashUpdateStatusDone({
4107 let res = parse_u64(next);
4108 let Some(val) = res else { break };
4109 val
4110 }),
4111 126u16 => Devlink::FlashUpdateStatusTotal({
4112 let res = parse_u64(next);
4113 let Some(val) = res else { break };
4114 val
4115 }),
4116 127u16 => Devlink::PortPciPfNumber({
4117 let res = parse_u16(next);
4118 let Some(val) = res else { break };
4119 val
4120 }),
4121 128u16 => Devlink::PortPciVfNumber({
4122 let res = parse_u16(next);
4123 let Some(val) = res else { break };
4124 val
4125 }),
4126 129u16 => Devlink::Stats({
4127 let res = Some(IterableDlAttrStats::with_loc(next, self.orig_loc));
4128 let Some(val) = res else { break };
4129 val
4130 }),
4131 130u16 => Devlink::TrapName({
4132 let res = CStr::from_bytes_with_nul(next).ok();
4133 let Some(val) = res else { break };
4134 val
4135 }),
4136 131u16 => Devlink::TrapAction({
4137 let res = parse_u8(next);
4138 let Some(val) = res else { break };
4139 val
4140 }),
4141 132u16 => Devlink::TrapType({
4142 let res = parse_u8(next);
4143 let Some(val) = res else { break };
4144 val
4145 }),
4146 133u16 => Devlink::TrapGeneric(()),
4147 134u16 => Devlink::TrapMetadata({
4148 let res = Some(IterableDlTrapMetadata::with_loc(next, self.orig_loc));
4149 let Some(val) = res else { break };
4150 val
4151 }),
4152 135u16 => Devlink::TrapGroupName({
4153 let res = CStr::from_bytes_with_nul(next).ok();
4154 let Some(val) = res else { break };
4155 val
4156 }),
4157 136u16 => Devlink::ReloadFailed({
4158 let res = parse_u8(next);
4159 let Some(val) = res else { break };
4160 val
4161 }),
4162 137u16 => Devlink::HealthReporterDumpTsNs({
4163 let res = parse_u64(next);
4164 let Some(val) = res else { break };
4165 val
4166 }),
4167 138u16 => Devlink::NetnsFd({
4168 let res = parse_u32(next);
4169 let Some(val) = res else { break };
4170 val
4171 }),
4172 139u16 => Devlink::NetnsPid({
4173 let res = parse_u32(next);
4174 let Some(val) = res else { break };
4175 val
4176 }),
4177 140u16 => Devlink::NetnsId({
4178 let res = parse_u32(next);
4179 let Some(val) = res else { break };
4180 val
4181 }),
4182 141u16 => Devlink::HealthReporterAutoDump({
4183 let res = parse_u8(next);
4184 let Some(val) = res else { break };
4185 val
4186 }),
4187 142u16 => Devlink::TrapPolicerId({
4188 let res = parse_u32(next);
4189 let Some(val) = res else { break };
4190 val
4191 }),
4192 143u16 => Devlink::TrapPolicerRate({
4193 let res = parse_u64(next);
4194 let Some(val) = res else { break };
4195 val
4196 }),
4197 144u16 => Devlink::TrapPolicerBurst({
4198 let res = parse_u64(next);
4199 let Some(val) = res else { break };
4200 val
4201 }),
4202 145u16 => Devlink::PortFunction({
4203 let res = Some(IterableDlPortFunction::with_loc(next, self.orig_loc));
4204 let Some(val) = res else { break };
4205 val
4206 }),
4207 146u16 => Devlink::InfoBoardSerialNumber({
4208 let res = CStr::from_bytes_with_nul(next).ok();
4209 let Some(val) = res else { break };
4210 val
4211 }),
4212 147u16 => Devlink::PortLanes({
4213 let res = parse_u32(next);
4214 let Some(val) = res else { break };
4215 val
4216 }),
4217 148u16 => Devlink::PortSplittable({
4218 let res = parse_u8(next);
4219 let Some(val) = res else { break };
4220 val
4221 }),
4222 149u16 => Devlink::PortExternal({
4223 let res = parse_u8(next);
4224 let Some(val) = res else { break };
4225 val
4226 }),
4227 150u16 => Devlink::PortControllerNumber({
4228 let res = parse_u32(next);
4229 let Some(val) = res else { break };
4230 val
4231 }),
4232 151u16 => Devlink::FlashUpdateStatusTimeout({
4233 let res = parse_u64(next);
4234 let Some(val) = res else { break };
4235 val
4236 }),
4237 152u16 => Devlink::FlashUpdateOverwriteMask({
4238 let res = BuiltinBitfield32::new_from_slice(next);
4239 let Some(val) = res else { break };
4240 val
4241 }),
4242 153u16 => Devlink::ReloadAction({
4243 let res = parse_u8(next);
4244 let Some(val) = res else { break };
4245 val
4246 }),
4247 154u16 => Devlink::ReloadActionsPerformed({
4248 let res = BuiltinBitfield32::new_from_slice(next);
4249 let Some(val) = res else { break };
4250 val
4251 }),
4252 155u16 => Devlink::ReloadLimits({
4253 let res = BuiltinBitfield32::new_from_slice(next);
4254 let Some(val) = res else { break };
4255 val
4256 }),
4257 156u16 => Devlink::DevStats({
4258 let res = Some(IterableDlDevStats::with_loc(next, self.orig_loc));
4259 let Some(val) = res else { break };
4260 val
4261 }),
4262 157u16 => Devlink::ReloadStats({
4263 let res = Some(IterableDlReloadStats::with_loc(next, self.orig_loc));
4264 let Some(val) = res else { break };
4265 val
4266 }),
4267 158u16 => Devlink::ReloadStatsEntry({
4268 let res = Some(IterableDlReloadStatsEntry::with_loc(next, self.orig_loc));
4269 let Some(val) = res else { break };
4270 val
4271 }),
4272 159u16 => Devlink::ReloadStatsLimit({
4273 let res = parse_u8(next);
4274 let Some(val) = res else { break };
4275 val
4276 }),
4277 160u16 => Devlink::ReloadStatsValue({
4278 let res = parse_u32(next);
4279 let Some(val) = res else { break };
4280 val
4281 }),
4282 161u16 => Devlink::RemoteReloadStats({
4283 let res = Some(IterableDlReloadStats::with_loc(next, self.orig_loc));
4284 let Some(val) = res else { break };
4285 val
4286 }),
4287 162u16 => Devlink::ReloadActionInfo({
4288 let res = Some(IterableDlReloadActInfo::with_loc(next, self.orig_loc));
4289 let Some(val) = res else { break };
4290 val
4291 }),
4292 163u16 => Devlink::ReloadActionStats({
4293 let res = Some(IterableDlReloadActStats::with_loc(next, self.orig_loc));
4294 let Some(val) = res else { break };
4295 val
4296 }),
4297 164u16 => Devlink::PortPciSfNumber({
4298 let res = parse_u32(next);
4299 let Some(val) = res else { break };
4300 val
4301 }),
4302 165u16 => Devlink::RateType({
4303 let res = parse_u16(next);
4304 let Some(val) = res else { break };
4305 val
4306 }),
4307 166u16 => Devlink::RateTxShare({
4308 let res = parse_u64(next);
4309 let Some(val) = res else { break };
4310 val
4311 }),
4312 167u16 => Devlink::RateTxMax({
4313 let res = parse_u64(next);
4314 let Some(val) = res else { break };
4315 val
4316 }),
4317 168u16 => Devlink::RateNodeName({
4318 let res = CStr::from_bytes_with_nul(next).ok();
4319 let Some(val) = res else { break };
4320 val
4321 }),
4322 169u16 => Devlink::RateParentNodeName({
4323 let res = CStr::from_bytes_with_nul(next).ok();
4324 let Some(val) = res else { break };
4325 val
4326 }),
4327 170u16 => Devlink::RegionMaxSnapshots({
4328 let res = parse_u32(next);
4329 let Some(val) = res else { break };
4330 val
4331 }),
4332 171u16 => Devlink::LinecardIndex({
4333 let res = parse_u32(next);
4334 let Some(val) = res else { break };
4335 val
4336 }),
4337 172u16 => Devlink::LinecardState({
4338 let res = parse_u8(next);
4339 let Some(val) = res else { break };
4340 val
4341 }),
4342 173u16 => Devlink::LinecardType({
4343 let res = CStr::from_bytes_with_nul(next).ok();
4344 let Some(val) = res else { break };
4345 val
4346 }),
4347 174u16 => Devlink::LinecardSupportedTypes({
4348 let res = Some(IterableDlLinecardSupportedTypes::with_loc(
4349 next,
4350 self.orig_loc,
4351 ));
4352 let Some(val) = res else { break };
4353 val
4354 }),
4355 176u16 => Devlink::Selftests({
4356 let res = Some(IterableDlSelftestId::with_loc(next, self.orig_loc));
4357 let Some(val) = res else { break };
4358 val
4359 }),
4360 177u16 => Devlink::RateTxPriority({
4361 let res = parse_u32(next);
4362 let Some(val) = res else { break };
4363 val
4364 }),
4365 178u16 => Devlink::RateTxWeight({
4366 let res = parse_u32(next);
4367 let Some(val) = res else { break };
4368 val
4369 }),
4370 179u16 => Devlink::RegionDirect(()),
4371 180u16 => Devlink::RateTcBws({
4372 let res = Some(IterableDlRateTcBws::with_loc(next, self.orig_loc));
4373 let Some(val) = res else { break };
4374 val
4375 }),
4376 181u16 => Devlink::HealthReporterBurstPeriod({
4377 let res = parse_u64(next);
4378 let Some(val) = res else { break };
4379 val
4380 }),
4381 183u16 => Devlink::ParamResetDefault(()),
4382 184u16 => Devlink::Index({
4383 let res = parse_u32(next);
4384 let Some(val) = res else { break };
4385 val
4386 }),
4387 185u16 => Devlink::ResourceScopeMask({
4388 let res = parse_u32(next);
4389 let Some(val) = res else { break };
4390 val
4391 }),
4392 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
4393 n => continue,
4394 };
4395 return Some(Ok(res));
4396 }
4397 Some(Err(ErrorContext::new(
4398 "Devlink",
4399 r#type.and_then(|t| Devlink::attr_from_type(t)),
4400 self.orig_loc,
4401 self.buf.as_ptr().wrapping_add(pos) as usize,
4402 )))
4403 }
4404}
4405impl<'a> std::fmt::Debug for IterableDevlink<'_> {
4406 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4407 let mut fmt = f.debug_struct("Devlink");
4408 for attr in self.clone() {
4409 let attr = match attr {
4410 Ok(a) => a,
4411 Err(err) => {
4412 fmt.finish()?;
4413 f.write_str("Err(")?;
4414 err.fmt(f)?;
4415 return f.write_str(")");
4416 }
4417 };
4418 match attr {
4419 Devlink::BusName(val) => fmt.field("BusName", &val),
4420 Devlink::DevName(val) => fmt.field("DevName", &val),
4421 Devlink::PortIndex(val) => fmt.field("PortIndex", &val),
4422 Devlink::PortType(val) => {
4423 fmt.field("PortType", &FormatEnum(val.into(), PortType::from_value))
4424 }
4425 Devlink::PortDesiredType(val) => fmt.field("PortDesiredType", &val),
4426 Devlink::PortNetdevIfindex(val) => fmt.field("PortNetdevIfindex", &val),
4427 Devlink::PortNetdevName(val) => fmt.field("PortNetdevName", &val),
4428 Devlink::PortIbdevName(val) => fmt.field("PortIbdevName", &val),
4429 Devlink::PortSplitCount(val) => fmt.field("PortSplitCount", &val),
4430 Devlink::PortSplitGroup(val) => fmt.field("PortSplitGroup", &val),
4431 Devlink::SbIndex(val) => fmt.field("SbIndex", &val),
4432 Devlink::SbSize(val) => fmt.field("SbSize", &val),
4433 Devlink::SbIngressPoolCount(val) => fmt.field("SbIngressPoolCount", &val),
4434 Devlink::SbEgressPoolCount(val) => fmt.field("SbEgressPoolCount", &val),
4435 Devlink::SbIngressTcCount(val) => fmt.field("SbIngressTcCount", &val),
4436 Devlink::SbEgressTcCount(val) => fmt.field("SbEgressTcCount", &val),
4437 Devlink::SbPoolIndex(val) => fmt.field("SbPoolIndex", &val),
4438 Devlink::SbPoolType(val) => fmt.field(
4439 "SbPoolType",
4440 &FormatEnum(val.into(), SbPoolType::from_value),
4441 ),
4442 Devlink::SbPoolSize(val) => fmt.field("SbPoolSize", &val),
4443 Devlink::SbPoolThresholdType(val) => fmt.field(
4444 "SbPoolThresholdType",
4445 &FormatEnum(val.into(), SbThresholdType::from_value),
4446 ),
4447 Devlink::SbThreshold(val) => fmt.field("SbThreshold", &val),
4448 Devlink::SbTcIndex(val) => fmt.field("SbTcIndex", &val),
4449 Devlink::SbOccCur(val) => fmt.field("SbOccCur", &val),
4450 Devlink::SbOccMax(val) => fmt.field("SbOccMax", &val),
4451 Devlink::EswitchMode(val) => fmt.field(
4452 "EswitchMode",
4453 &FormatEnum(val.into(), EswitchMode::from_value),
4454 ),
4455 Devlink::EswitchInlineMode(val) => fmt.field(
4456 "EswitchInlineMode",
4457 &FormatEnum(val.into(), EswitchInlineMode::from_value),
4458 ),
4459 Devlink::DpipeTables(val) => fmt.field("DpipeTables", &val),
4460 Devlink::DpipeTable(val) => fmt.field("DpipeTable", &val),
4461 Devlink::DpipeTableName(val) => fmt.field("DpipeTableName", &val),
4462 Devlink::DpipeTableSize(val) => fmt.field("DpipeTableSize", &val),
4463 Devlink::DpipeTableMatches(val) => fmt.field("DpipeTableMatches", &val),
4464 Devlink::DpipeTableActions(val) => fmt.field("DpipeTableActions", &val),
4465 Devlink::DpipeTableCountersEnabled(val) => {
4466 fmt.field("DpipeTableCountersEnabled", &val)
4467 }
4468 Devlink::DpipeEntries(val) => fmt.field("DpipeEntries", &val),
4469 Devlink::DpipeEntry(val) => fmt.field("DpipeEntry", &val),
4470 Devlink::DpipeEntryIndex(val) => fmt.field("DpipeEntryIndex", &val),
4471 Devlink::DpipeEntryMatchValues(val) => fmt.field("DpipeEntryMatchValues", &val),
4472 Devlink::DpipeEntryActionValues(val) => fmt.field("DpipeEntryActionValues", &val),
4473 Devlink::DpipeEntryCounter(val) => fmt.field("DpipeEntryCounter", &val),
4474 Devlink::DpipeMatch(val) => fmt.field("DpipeMatch", &val),
4475 Devlink::DpipeMatchValue(val) => fmt.field("DpipeMatchValue", &val),
4476 Devlink::DpipeMatchType(val) => fmt.field(
4477 "DpipeMatchType",
4478 &FormatEnum(val.into(), DpipeMatchType::from_value),
4479 ),
4480 Devlink::DpipeAction(val) => fmt.field("DpipeAction", &val),
4481 Devlink::DpipeActionValue(val) => fmt.field("DpipeActionValue", &val),
4482 Devlink::DpipeActionType(val) => fmt.field(
4483 "DpipeActionType",
4484 &FormatEnum(val.into(), DpipeActionType::from_value),
4485 ),
4486 Devlink::DpipeValue(val) => fmt.field("DpipeValue", &val),
4487 Devlink::DpipeValueMask(val) => fmt.field("DpipeValueMask", &val),
4488 Devlink::DpipeValueMapping(val) => fmt.field("DpipeValueMapping", &val),
4489 Devlink::DpipeHeaders(val) => fmt.field("DpipeHeaders", &val),
4490 Devlink::DpipeHeader(val) => fmt.field("DpipeHeader", &val),
4491 Devlink::DpipeHeaderName(val) => fmt.field("DpipeHeaderName", &val),
4492 Devlink::DpipeHeaderId(val) => fmt.field(
4493 "DpipeHeaderId",
4494 &FormatEnum(val.into(), DpipeHeaderId::from_value),
4495 ),
4496 Devlink::DpipeHeaderFields(val) => fmt.field("DpipeHeaderFields", &val),
4497 Devlink::DpipeHeaderGlobal(val) => fmt.field("DpipeHeaderGlobal", &val),
4498 Devlink::DpipeHeaderIndex(val) => fmt.field("DpipeHeaderIndex", &val),
4499 Devlink::DpipeField(val) => fmt.field("DpipeField", &val),
4500 Devlink::DpipeFieldName(val) => fmt.field("DpipeFieldName", &val),
4501 Devlink::DpipeFieldId(val) => fmt.field("DpipeFieldId", &val),
4502 Devlink::DpipeFieldBitwidth(val) => fmt.field("DpipeFieldBitwidth", &val),
4503 Devlink::DpipeFieldMappingType(val) => fmt.field(
4504 "DpipeFieldMappingType",
4505 &FormatEnum(val.into(), DpipeFieldMappingType::from_value),
4506 ),
4507 Devlink::Pad(val) => fmt.field("Pad", &val),
4508 Devlink::EswitchEncapMode(val) => fmt.field(
4509 "EswitchEncapMode",
4510 &FormatEnum(val.into(), EswitchEncapMode::from_value),
4511 ),
4512 Devlink::ResourceList(val) => fmt.field("ResourceList", &val),
4513 Devlink::Resource(val) => fmt.field("Resource", &val),
4514 Devlink::ResourceName(val) => fmt.field("ResourceName", &val),
4515 Devlink::ResourceId(val) => fmt.field("ResourceId", &val),
4516 Devlink::ResourceSize(val) => fmt.field("ResourceSize", &val),
4517 Devlink::ResourceSizeNew(val) => fmt.field("ResourceSizeNew", &val),
4518 Devlink::ResourceSizeValid(val) => fmt.field("ResourceSizeValid", &val),
4519 Devlink::ResourceSizeMin(val) => fmt.field("ResourceSizeMin", &val),
4520 Devlink::ResourceSizeMax(val) => fmt.field("ResourceSizeMax", &val),
4521 Devlink::ResourceSizeGran(val) => fmt.field("ResourceSizeGran", &val),
4522 Devlink::ResourceUnit(val) => fmt.field(
4523 "ResourceUnit",
4524 &FormatEnum(val.into(), ResourceUnit::from_value),
4525 ),
4526 Devlink::ResourceOcc(val) => fmt.field("ResourceOcc", &val),
4527 Devlink::DpipeTableResourceId(val) => fmt.field("DpipeTableResourceId", &val),
4528 Devlink::DpipeTableResourceUnits(val) => fmt.field("DpipeTableResourceUnits", &val),
4529 Devlink::PortFlavour(val) => fmt.field(
4530 "PortFlavour",
4531 &FormatEnum(val.into(), PortFlavour::from_value),
4532 ),
4533 Devlink::PortNumber(val) => fmt.field("PortNumber", &val),
4534 Devlink::PortSplitSubportNumber(val) => fmt.field("PortSplitSubportNumber", &val),
4535 Devlink::Param(val) => fmt.field("Param", &val),
4536 Devlink::ParamName(val) => fmt.field("ParamName", &val),
4537 Devlink::ParamGeneric(val) => fmt.field("ParamGeneric", &val),
4538 Devlink::ParamType(val) => fmt.field(
4539 "ParamType",
4540 &FormatEnum(val.into(), VarAttrType::from_value),
4541 ),
4542 Devlink::ParamValueCmode(val) => fmt.field(
4543 "ParamValueCmode",
4544 &FormatEnum(val.into(), ParamCmode::from_value),
4545 ),
4546 Devlink::RegionName(val) => fmt.field("RegionName", &val),
4547 Devlink::RegionSize(val) => fmt.field("RegionSize", &val),
4548 Devlink::RegionSnapshots(val) => fmt.field("RegionSnapshots", &val),
4549 Devlink::RegionSnapshot(val) => fmt.field("RegionSnapshot", &val),
4550 Devlink::RegionSnapshotId(val) => fmt.field("RegionSnapshotId", &val),
4551 Devlink::RegionChunks(val) => fmt.field("RegionChunks", &val),
4552 Devlink::RegionChunk(val) => fmt.field("RegionChunk", &val),
4553 Devlink::RegionChunkData(val) => fmt.field("RegionChunkData", &val),
4554 Devlink::RegionChunkAddr(val) => fmt.field("RegionChunkAddr", &val),
4555 Devlink::RegionChunkLen(val) => fmt.field("RegionChunkLen", &val),
4556 Devlink::InfoDriverName(val) => fmt.field("InfoDriverName", &val),
4557 Devlink::InfoSerialNumber(val) => fmt.field("InfoSerialNumber", &val),
4558 Devlink::InfoVersionFixed(val) => fmt.field("InfoVersionFixed", &val),
4559 Devlink::InfoVersionRunning(val) => fmt.field("InfoVersionRunning", &val),
4560 Devlink::InfoVersionStored(val) => fmt.field("InfoVersionStored", &val),
4561 Devlink::InfoVersionName(val) => fmt.field("InfoVersionName", &val),
4562 Devlink::InfoVersionValue(val) => fmt.field("InfoVersionValue", &val),
4563 Devlink::SbPoolCellSize(val) => fmt.field("SbPoolCellSize", &val),
4564 Devlink::Fmsg(val) => fmt.field("Fmsg", &val),
4565 Devlink::FmsgObjNestStart(val) => fmt.field("FmsgObjNestStart", &val),
4566 Devlink::FmsgPairNestStart(val) => fmt.field("FmsgPairNestStart", &val),
4567 Devlink::FmsgArrNestStart(val) => fmt.field("FmsgArrNestStart", &val),
4568 Devlink::FmsgNestEnd(val) => fmt.field("FmsgNestEnd", &val),
4569 Devlink::FmsgObjName(val) => fmt.field("FmsgObjName", &val),
4570 Devlink::FmsgObjValueType(val) => fmt.field(
4571 "FmsgObjValueType",
4572 &FormatEnum(val.into(), VarAttrType::from_value),
4573 ),
4574 Devlink::HealthReporter(val) => fmt.field("HealthReporter", &val),
4575 Devlink::HealthReporterName(val) => fmt.field("HealthReporterName", &val),
4576 Devlink::HealthReporterState(val) => fmt.field("HealthReporterState", &val),
4577 Devlink::HealthReporterErrCount(val) => fmt.field("HealthReporterErrCount", &val),
4578 Devlink::HealthReporterRecoverCount(val) => {
4579 fmt.field("HealthReporterRecoverCount", &val)
4580 }
4581 Devlink::HealthReporterDumpTs(val) => fmt.field("HealthReporterDumpTs", &val),
4582 Devlink::HealthReporterGracefulPeriod(val) => {
4583 fmt.field("HealthReporterGracefulPeriod", &val)
4584 }
4585 Devlink::HealthReporterAutoRecover(val) => {
4586 fmt.field("HealthReporterAutoRecover", &val)
4587 }
4588 Devlink::FlashUpdateFileName(val) => fmt.field("FlashUpdateFileName", &val),
4589 Devlink::FlashUpdateComponent(val) => fmt.field("FlashUpdateComponent", &val),
4590 Devlink::FlashUpdateStatusMsg(val) => fmt.field("FlashUpdateStatusMsg", &val),
4591 Devlink::FlashUpdateStatusDone(val) => fmt.field("FlashUpdateStatusDone", &val),
4592 Devlink::FlashUpdateStatusTotal(val) => fmt.field("FlashUpdateStatusTotal", &val),
4593 Devlink::PortPciPfNumber(val) => fmt.field("PortPciPfNumber", &val),
4594 Devlink::PortPciVfNumber(val) => fmt.field("PortPciVfNumber", &val),
4595 Devlink::Stats(val) => fmt.field("Stats", &val),
4596 Devlink::TrapName(val) => fmt.field("TrapName", &val),
4597 Devlink::TrapAction(val) => fmt.field(
4598 "TrapAction",
4599 &FormatEnum(val.into(), TrapAction::from_value),
4600 ),
4601 Devlink::TrapType(val) => {
4602 fmt.field("TrapType", &FormatEnum(val.into(), TrapType::from_value))
4603 }
4604 Devlink::TrapGeneric(val) => fmt.field("TrapGeneric", &val),
4605 Devlink::TrapMetadata(val) => fmt.field("TrapMetadata", &val),
4606 Devlink::TrapGroupName(val) => fmt.field("TrapGroupName", &val),
4607 Devlink::ReloadFailed(val) => fmt.field("ReloadFailed", &val),
4608 Devlink::HealthReporterDumpTsNs(val) => fmt.field("HealthReporterDumpTsNs", &val),
4609 Devlink::NetnsFd(val) => fmt.field("NetnsFd", &val),
4610 Devlink::NetnsPid(val) => fmt.field("NetnsPid", &val),
4611 Devlink::NetnsId(val) => fmt.field("NetnsId", &val),
4612 Devlink::HealthReporterAutoDump(val) => fmt.field("HealthReporterAutoDump", &val),
4613 Devlink::TrapPolicerId(val) => fmt.field("TrapPolicerId", &val),
4614 Devlink::TrapPolicerRate(val) => fmt.field("TrapPolicerRate", &val),
4615 Devlink::TrapPolicerBurst(val) => fmt.field("TrapPolicerBurst", &val),
4616 Devlink::PortFunction(val) => fmt.field("PortFunction", &val),
4617 Devlink::InfoBoardSerialNumber(val) => fmt.field("InfoBoardSerialNumber", &val),
4618 Devlink::PortLanes(val) => fmt.field("PortLanes", &val),
4619 Devlink::PortSplittable(val) => fmt.field("PortSplittable", &val),
4620 Devlink::PortExternal(val) => fmt.field("PortExternal", &val),
4621 Devlink::PortControllerNumber(val) => fmt.field("PortControllerNumber", &val),
4622 Devlink::FlashUpdateStatusTimeout(val) => {
4623 fmt.field("FlashUpdateStatusTimeout", &val)
4624 }
4625 Devlink::FlashUpdateOverwriteMask(val) => fmt.field(
4626 "FlashUpdateOverwriteMask",
4627 &FormatFlags(val.value.into(), |val| {
4628 FlashOverwrite::from_value(val.trailing_zeros().into())
4629 }),
4630 ),
4631 Devlink::ReloadAction(val) => fmt.field(
4632 "ReloadAction",
4633 &FormatEnum(val.into(), ReloadAction::from_value),
4634 ),
4635 Devlink::ReloadActionsPerformed(val) => fmt.field(
4636 "ReloadActionsPerformed",
4637 &FormatFlags(val.value.into(), |val| {
4638 ReloadAction::from_value(val.trailing_zeros().into())
4639 }),
4640 ),
4641 Devlink::ReloadLimits(val) => fmt.field(
4642 "ReloadLimits",
4643 &FormatFlags(val.value.into(), |val| {
4644 ReloadAction::from_value(val.trailing_zeros().into())
4645 }),
4646 ),
4647 Devlink::DevStats(val) => fmt.field("DevStats", &val),
4648 Devlink::ReloadStats(val) => fmt.field("ReloadStats", &val),
4649 Devlink::ReloadStatsEntry(val) => fmt.field("ReloadStatsEntry", &val),
4650 Devlink::ReloadStatsLimit(val) => fmt.field("ReloadStatsLimit", &val),
4651 Devlink::ReloadStatsValue(val) => fmt.field("ReloadStatsValue", &val),
4652 Devlink::RemoteReloadStats(val) => fmt.field("RemoteReloadStats", &val),
4653 Devlink::ReloadActionInfo(val) => fmt.field("ReloadActionInfo", &val),
4654 Devlink::ReloadActionStats(val) => fmt.field("ReloadActionStats", &val),
4655 Devlink::PortPciSfNumber(val) => fmt.field("PortPciSfNumber", &val),
4656 Devlink::RateType(val) => {
4657 fmt.field("RateType", &FormatEnum(val.into(), RateType::from_value))
4658 }
4659 Devlink::RateTxShare(val) => fmt.field("RateTxShare", &val),
4660 Devlink::RateTxMax(val) => fmt.field("RateTxMax", &val),
4661 Devlink::RateNodeName(val) => fmt.field("RateNodeName", &val),
4662 Devlink::RateParentNodeName(val) => fmt.field("RateParentNodeName", &val),
4663 Devlink::RegionMaxSnapshots(val) => fmt.field("RegionMaxSnapshots", &val),
4664 Devlink::LinecardIndex(val) => fmt.field("LinecardIndex", &val),
4665 Devlink::LinecardState(val) => fmt.field("LinecardState", &val),
4666 Devlink::LinecardType(val) => fmt.field("LinecardType", &val),
4667 Devlink::LinecardSupportedTypes(val) => fmt.field("LinecardSupportedTypes", &val),
4668 Devlink::Selftests(val) => fmt.field("Selftests", &val),
4669 Devlink::RateTxPriority(val) => fmt.field("RateTxPriority", &val),
4670 Devlink::RateTxWeight(val) => fmt.field("RateTxWeight", &val),
4671 Devlink::RegionDirect(val) => fmt.field("RegionDirect", &val),
4672 Devlink::RateTcBws(val) => fmt.field("RateTcBws", &val),
4673 Devlink::HealthReporterBurstPeriod(val) => {
4674 fmt.field("HealthReporterBurstPeriod", &val)
4675 }
4676 Devlink::ParamResetDefault(val) => fmt.field("ParamResetDefault", &val),
4677 Devlink::Index(val) => fmt.field("Index", &val),
4678 Devlink::ResourceScopeMask(val) => fmt.field(
4679 "ResourceScopeMask",
4680 &FormatFlags(val.into(), |val| {
4681 ResourceScope::from_value(val.trailing_zeros().into())
4682 }),
4683 ),
4684 };
4685 }
4686 fmt.finish()
4687 }
4688}
4689impl IterableDevlink<'_> {
4690 pub fn lookup_attr(
4691 &self,
4692 offset: usize,
4693 missing_type: Option<u16>,
4694 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
4695 let mut stack = Vec::new();
4696 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
4697 if missing_type.is_some() && cur == offset {
4698 stack.push(("Devlink", offset));
4699 return (stack, missing_type.and_then(|t| Devlink::attr_from_type(t)));
4700 }
4701 if cur > offset || cur + self.buf.len() < offset {
4702 return (stack, None);
4703 }
4704 let mut attrs = self.clone();
4705 let mut last_off = cur + attrs.pos;
4706 let mut missing = None;
4707 while let Some(attr) = attrs.next() {
4708 let Ok(attr) = attr else { break };
4709 match attr {
4710 Devlink::BusName(val) => {
4711 if last_off == offset {
4712 stack.push(("BusName", last_off));
4713 break;
4714 }
4715 }
4716 Devlink::DevName(val) => {
4717 if last_off == offset {
4718 stack.push(("DevName", last_off));
4719 break;
4720 }
4721 }
4722 Devlink::PortIndex(val) => {
4723 if last_off == offset {
4724 stack.push(("PortIndex", last_off));
4725 break;
4726 }
4727 }
4728 Devlink::PortType(val) => {
4729 if last_off == offset {
4730 stack.push(("PortType", last_off));
4731 break;
4732 }
4733 }
4734 Devlink::PortDesiredType(val) => {
4735 if last_off == offset {
4736 stack.push(("PortDesiredType", last_off));
4737 break;
4738 }
4739 }
4740 Devlink::PortNetdevIfindex(val) => {
4741 if last_off == offset {
4742 stack.push(("PortNetdevIfindex", last_off));
4743 break;
4744 }
4745 }
4746 Devlink::PortNetdevName(val) => {
4747 if last_off == offset {
4748 stack.push(("PortNetdevName", last_off));
4749 break;
4750 }
4751 }
4752 Devlink::PortIbdevName(val) => {
4753 if last_off == offset {
4754 stack.push(("PortIbdevName", last_off));
4755 break;
4756 }
4757 }
4758 Devlink::PortSplitCount(val) => {
4759 if last_off == offset {
4760 stack.push(("PortSplitCount", last_off));
4761 break;
4762 }
4763 }
4764 Devlink::PortSplitGroup(val) => {
4765 if last_off == offset {
4766 stack.push(("PortSplitGroup", last_off));
4767 break;
4768 }
4769 }
4770 Devlink::SbIndex(val) => {
4771 if last_off == offset {
4772 stack.push(("SbIndex", last_off));
4773 break;
4774 }
4775 }
4776 Devlink::SbSize(val) => {
4777 if last_off == offset {
4778 stack.push(("SbSize", last_off));
4779 break;
4780 }
4781 }
4782 Devlink::SbIngressPoolCount(val) => {
4783 if last_off == offset {
4784 stack.push(("SbIngressPoolCount", last_off));
4785 break;
4786 }
4787 }
4788 Devlink::SbEgressPoolCount(val) => {
4789 if last_off == offset {
4790 stack.push(("SbEgressPoolCount", last_off));
4791 break;
4792 }
4793 }
4794 Devlink::SbIngressTcCount(val) => {
4795 if last_off == offset {
4796 stack.push(("SbIngressTcCount", last_off));
4797 break;
4798 }
4799 }
4800 Devlink::SbEgressTcCount(val) => {
4801 if last_off == offset {
4802 stack.push(("SbEgressTcCount", last_off));
4803 break;
4804 }
4805 }
4806 Devlink::SbPoolIndex(val) => {
4807 if last_off == offset {
4808 stack.push(("SbPoolIndex", last_off));
4809 break;
4810 }
4811 }
4812 Devlink::SbPoolType(val) => {
4813 if last_off == offset {
4814 stack.push(("SbPoolType", last_off));
4815 break;
4816 }
4817 }
4818 Devlink::SbPoolSize(val) => {
4819 if last_off == offset {
4820 stack.push(("SbPoolSize", last_off));
4821 break;
4822 }
4823 }
4824 Devlink::SbPoolThresholdType(val) => {
4825 if last_off == offset {
4826 stack.push(("SbPoolThresholdType", last_off));
4827 break;
4828 }
4829 }
4830 Devlink::SbThreshold(val) => {
4831 if last_off == offset {
4832 stack.push(("SbThreshold", last_off));
4833 break;
4834 }
4835 }
4836 Devlink::SbTcIndex(val) => {
4837 if last_off == offset {
4838 stack.push(("SbTcIndex", last_off));
4839 break;
4840 }
4841 }
4842 Devlink::SbOccCur(val) => {
4843 if last_off == offset {
4844 stack.push(("SbOccCur", last_off));
4845 break;
4846 }
4847 }
4848 Devlink::SbOccMax(val) => {
4849 if last_off == offset {
4850 stack.push(("SbOccMax", last_off));
4851 break;
4852 }
4853 }
4854 Devlink::EswitchMode(val) => {
4855 if last_off == offset {
4856 stack.push(("EswitchMode", last_off));
4857 break;
4858 }
4859 }
4860 Devlink::EswitchInlineMode(val) => {
4861 if last_off == offset {
4862 stack.push(("EswitchInlineMode", last_off));
4863 break;
4864 }
4865 }
4866 Devlink::DpipeTables(val) => {
4867 (stack, missing) = val.lookup_attr(offset, missing_type);
4868 if !stack.is_empty() {
4869 break;
4870 }
4871 }
4872 Devlink::DpipeTable(val) => {
4873 (stack, missing) = val.lookup_attr(offset, missing_type);
4874 if !stack.is_empty() {
4875 break;
4876 }
4877 }
4878 Devlink::DpipeTableName(val) => {
4879 if last_off == offset {
4880 stack.push(("DpipeTableName", last_off));
4881 break;
4882 }
4883 }
4884 Devlink::DpipeTableSize(val) => {
4885 if last_off == offset {
4886 stack.push(("DpipeTableSize", last_off));
4887 break;
4888 }
4889 }
4890 Devlink::DpipeTableMatches(val) => {
4891 (stack, missing) = val.lookup_attr(offset, missing_type);
4892 if !stack.is_empty() {
4893 break;
4894 }
4895 }
4896 Devlink::DpipeTableActions(val) => {
4897 (stack, missing) = val.lookup_attr(offset, missing_type);
4898 if !stack.is_empty() {
4899 break;
4900 }
4901 }
4902 Devlink::DpipeTableCountersEnabled(val) => {
4903 if last_off == offset {
4904 stack.push(("DpipeTableCountersEnabled", last_off));
4905 break;
4906 }
4907 }
4908 Devlink::DpipeEntries(val) => {
4909 (stack, missing) = val.lookup_attr(offset, missing_type);
4910 if !stack.is_empty() {
4911 break;
4912 }
4913 }
4914 Devlink::DpipeEntry(val) => {
4915 (stack, missing) = val.lookup_attr(offset, missing_type);
4916 if !stack.is_empty() {
4917 break;
4918 }
4919 }
4920 Devlink::DpipeEntryIndex(val) => {
4921 if last_off == offset {
4922 stack.push(("DpipeEntryIndex", last_off));
4923 break;
4924 }
4925 }
4926 Devlink::DpipeEntryMatchValues(val) => {
4927 (stack, missing) = val.lookup_attr(offset, missing_type);
4928 if !stack.is_empty() {
4929 break;
4930 }
4931 }
4932 Devlink::DpipeEntryActionValues(val) => {
4933 (stack, missing) = val.lookup_attr(offset, missing_type);
4934 if !stack.is_empty() {
4935 break;
4936 }
4937 }
4938 Devlink::DpipeEntryCounter(val) => {
4939 if last_off == offset {
4940 stack.push(("DpipeEntryCounter", last_off));
4941 break;
4942 }
4943 }
4944 Devlink::DpipeMatch(val) => {
4945 (stack, missing) = val.lookup_attr(offset, missing_type);
4946 if !stack.is_empty() {
4947 break;
4948 }
4949 }
4950 Devlink::DpipeMatchValue(val) => {
4951 (stack, missing) = val.lookup_attr(offset, missing_type);
4952 if !stack.is_empty() {
4953 break;
4954 }
4955 }
4956 Devlink::DpipeMatchType(val) => {
4957 if last_off == offset {
4958 stack.push(("DpipeMatchType", last_off));
4959 break;
4960 }
4961 }
4962 Devlink::DpipeAction(val) => {
4963 (stack, missing) = val.lookup_attr(offset, missing_type);
4964 if !stack.is_empty() {
4965 break;
4966 }
4967 }
4968 Devlink::DpipeActionValue(val) => {
4969 (stack, missing) = val.lookup_attr(offset, missing_type);
4970 if !stack.is_empty() {
4971 break;
4972 }
4973 }
4974 Devlink::DpipeActionType(val) => {
4975 if last_off == offset {
4976 stack.push(("DpipeActionType", last_off));
4977 break;
4978 }
4979 }
4980 Devlink::DpipeValue(val) => {
4981 if last_off == offset {
4982 stack.push(("DpipeValue", last_off));
4983 break;
4984 }
4985 }
4986 Devlink::DpipeValueMask(val) => {
4987 if last_off == offset {
4988 stack.push(("DpipeValueMask", last_off));
4989 break;
4990 }
4991 }
4992 Devlink::DpipeValueMapping(val) => {
4993 if last_off == offset {
4994 stack.push(("DpipeValueMapping", last_off));
4995 break;
4996 }
4997 }
4998 Devlink::DpipeHeaders(val) => {
4999 (stack, missing) = val.lookup_attr(offset, missing_type);
5000 if !stack.is_empty() {
5001 break;
5002 }
5003 }
5004 Devlink::DpipeHeader(val) => {
5005 (stack, missing) = val.lookup_attr(offset, missing_type);
5006 if !stack.is_empty() {
5007 break;
5008 }
5009 }
5010 Devlink::DpipeHeaderName(val) => {
5011 if last_off == offset {
5012 stack.push(("DpipeHeaderName", last_off));
5013 break;
5014 }
5015 }
5016 Devlink::DpipeHeaderId(val) => {
5017 if last_off == offset {
5018 stack.push(("DpipeHeaderId", last_off));
5019 break;
5020 }
5021 }
5022 Devlink::DpipeHeaderFields(val) => {
5023 (stack, missing) = val.lookup_attr(offset, missing_type);
5024 if !stack.is_empty() {
5025 break;
5026 }
5027 }
5028 Devlink::DpipeHeaderGlobal(val) => {
5029 if last_off == offset {
5030 stack.push(("DpipeHeaderGlobal", last_off));
5031 break;
5032 }
5033 }
5034 Devlink::DpipeHeaderIndex(val) => {
5035 if last_off == offset {
5036 stack.push(("DpipeHeaderIndex", last_off));
5037 break;
5038 }
5039 }
5040 Devlink::DpipeField(val) => {
5041 (stack, missing) = val.lookup_attr(offset, missing_type);
5042 if !stack.is_empty() {
5043 break;
5044 }
5045 }
5046 Devlink::DpipeFieldName(val) => {
5047 if last_off == offset {
5048 stack.push(("DpipeFieldName", last_off));
5049 break;
5050 }
5051 }
5052 Devlink::DpipeFieldId(val) => {
5053 if last_off == offset {
5054 stack.push(("DpipeFieldId", last_off));
5055 break;
5056 }
5057 }
5058 Devlink::DpipeFieldBitwidth(val) => {
5059 if last_off == offset {
5060 stack.push(("DpipeFieldBitwidth", last_off));
5061 break;
5062 }
5063 }
5064 Devlink::DpipeFieldMappingType(val) => {
5065 if last_off == offset {
5066 stack.push(("DpipeFieldMappingType", last_off));
5067 break;
5068 }
5069 }
5070 Devlink::Pad(val) => {
5071 if last_off == offset {
5072 stack.push(("Pad", last_off));
5073 break;
5074 }
5075 }
5076 Devlink::EswitchEncapMode(val) => {
5077 if last_off == offset {
5078 stack.push(("EswitchEncapMode", last_off));
5079 break;
5080 }
5081 }
5082 Devlink::ResourceList(val) => {
5083 (stack, missing) = val.lookup_attr(offset, missing_type);
5084 if !stack.is_empty() {
5085 break;
5086 }
5087 }
5088 Devlink::Resource(val) => {
5089 (stack, missing) = val.lookup_attr(offset, missing_type);
5090 if !stack.is_empty() {
5091 break;
5092 }
5093 }
5094 Devlink::ResourceName(val) => {
5095 if last_off == offset {
5096 stack.push(("ResourceName", last_off));
5097 break;
5098 }
5099 }
5100 Devlink::ResourceId(val) => {
5101 if last_off == offset {
5102 stack.push(("ResourceId", last_off));
5103 break;
5104 }
5105 }
5106 Devlink::ResourceSize(val) => {
5107 if last_off == offset {
5108 stack.push(("ResourceSize", last_off));
5109 break;
5110 }
5111 }
5112 Devlink::ResourceSizeNew(val) => {
5113 if last_off == offset {
5114 stack.push(("ResourceSizeNew", last_off));
5115 break;
5116 }
5117 }
5118 Devlink::ResourceSizeValid(val) => {
5119 if last_off == offset {
5120 stack.push(("ResourceSizeValid", last_off));
5121 break;
5122 }
5123 }
5124 Devlink::ResourceSizeMin(val) => {
5125 if last_off == offset {
5126 stack.push(("ResourceSizeMin", last_off));
5127 break;
5128 }
5129 }
5130 Devlink::ResourceSizeMax(val) => {
5131 if last_off == offset {
5132 stack.push(("ResourceSizeMax", last_off));
5133 break;
5134 }
5135 }
5136 Devlink::ResourceSizeGran(val) => {
5137 if last_off == offset {
5138 stack.push(("ResourceSizeGran", last_off));
5139 break;
5140 }
5141 }
5142 Devlink::ResourceUnit(val) => {
5143 if last_off == offset {
5144 stack.push(("ResourceUnit", last_off));
5145 break;
5146 }
5147 }
5148 Devlink::ResourceOcc(val) => {
5149 if last_off == offset {
5150 stack.push(("ResourceOcc", last_off));
5151 break;
5152 }
5153 }
5154 Devlink::DpipeTableResourceId(val) => {
5155 if last_off == offset {
5156 stack.push(("DpipeTableResourceId", last_off));
5157 break;
5158 }
5159 }
5160 Devlink::DpipeTableResourceUnits(val) => {
5161 if last_off == offset {
5162 stack.push(("DpipeTableResourceUnits", last_off));
5163 break;
5164 }
5165 }
5166 Devlink::PortFlavour(val) => {
5167 if last_off == offset {
5168 stack.push(("PortFlavour", last_off));
5169 break;
5170 }
5171 }
5172 Devlink::PortNumber(val) => {
5173 if last_off == offset {
5174 stack.push(("PortNumber", last_off));
5175 break;
5176 }
5177 }
5178 Devlink::PortSplitSubportNumber(val) => {
5179 if last_off == offset {
5180 stack.push(("PortSplitSubportNumber", last_off));
5181 break;
5182 }
5183 }
5184 Devlink::Param(val) => {
5185 (stack, missing) = val.lookup_attr(offset, missing_type);
5186 if !stack.is_empty() {
5187 break;
5188 }
5189 }
5190 Devlink::ParamName(val) => {
5191 if last_off == offset {
5192 stack.push(("ParamName", last_off));
5193 break;
5194 }
5195 }
5196 Devlink::ParamGeneric(val) => {
5197 if last_off == offset {
5198 stack.push(("ParamGeneric", last_off));
5199 break;
5200 }
5201 }
5202 Devlink::ParamType(val) => {
5203 if last_off == offset {
5204 stack.push(("ParamType", last_off));
5205 break;
5206 }
5207 }
5208 Devlink::ParamValueCmode(val) => {
5209 if last_off == offset {
5210 stack.push(("ParamValueCmode", last_off));
5211 break;
5212 }
5213 }
5214 Devlink::RegionName(val) => {
5215 if last_off == offset {
5216 stack.push(("RegionName", last_off));
5217 break;
5218 }
5219 }
5220 Devlink::RegionSize(val) => {
5221 if last_off == offset {
5222 stack.push(("RegionSize", last_off));
5223 break;
5224 }
5225 }
5226 Devlink::RegionSnapshots(val) => {
5227 (stack, missing) = val.lookup_attr(offset, missing_type);
5228 if !stack.is_empty() {
5229 break;
5230 }
5231 }
5232 Devlink::RegionSnapshot(val) => {
5233 (stack, missing) = val.lookup_attr(offset, missing_type);
5234 if !stack.is_empty() {
5235 break;
5236 }
5237 }
5238 Devlink::RegionSnapshotId(val) => {
5239 if last_off == offset {
5240 stack.push(("RegionSnapshotId", last_off));
5241 break;
5242 }
5243 }
5244 Devlink::RegionChunks(val) => {
5245 (stack, missing) = val.lookup_attr(offset, missing_type);
5246 if !stack.is_empty() {
5247 break;
5248 }
5249 }
5250 Devlink::RegionChunk(val) => {
5251 (stack, missing) = val.lookup_attr(offset, missing_type);
5252 if !stack.is_empty() {
5253 break;
5254 }
5255 }
5256 Devlink::RegionChunkData(val) => {
5257 if last_off == offset {
5258 stack.push(("RegionChunkData", last_off));
5259 break;
5260 }
5261 }
5262 Devlink::RegionChunkAddr(val) => {
5263 if last_off == offset {
5264 stack.push(("RegionChunkAddr", last_off));
5265 break;
5266 }
5267 }
5268 Devlink::RegionChunkLen(val) => {
5269 if last_off == offset {
5270 stack.push(("RegionChunkLen", last_off));
5271 break;
5272 }
5273 }
5274 Devlink::InfoDriverName(val) => {
5275 if last_off == offset {
5276 stack.push(("InfoDriverName", last_off));
5277 break;
5278 }
5279 }
5280 Devlink::InfoSerialNumber(val) => {
5281 if last_off == offset {
5282 stack.push(("InfoSerialNumber", last_off));
5283 break;
5284 }
5285 }
5286 Devlink::InfoVersionFixed(val) => {
5287 (stack, missing) = val.lookup_attr(offset, missing_type);
5288 if !stack.is_empty() {
5289 break;
5290 }
5291 }
5292 Devlink::InfoVersionRunning(val) => {
5293 (stack, missing) = val.lookup_attr(offset, missing_type);
5294 if !stack.is_empty() {
5295 break;
5296 }
5297 }
5298 Devlink::InfoVersionStored(val) => {
5299 (stack, missing) = val.lookup_attr(offset, missing_type);
5300 if !stack.is_empty() {
5301 break;
5302 }
5303 }
5304 Devlink::InfoVersionName(val) => {
5305 if last_off == offset {
5306 stack.push(("InfoVersionName", last_off));
5307 break;
5308 }
5309 }
5310 Devlink::InfoVersionValue(val) => {
5311 if last_off == offset {
5312 stack.push(("InfoVersionValue", last_off));
5313 break;
5314 }
5315 }
5316 Devlink::SbPoolCellSize(val) => {
5317 if last_off == offset {
5318 stack.push(("SbPoolCellSize", last_off));
5319 break;
5320 }
5321 }
5322 Devlink::Fmsg(val) => {
5323 (stack, missing) = val.lookup_attr(offset, missing_type);
5324 if !stack.is_empty() {
5325 break;
5326 }
5327 }
5328 Devlink::FmsgObjNestStart(val) => {
5329 if last_off == offset {
5330 stack.push(("FmsgObjNestStart", last_off));
5331 break;
5332 }
5333 }
5334 Devlink::FmsgPairNestStart(val) => {
5335 if last_off == offset {
5336 stack.push(("FmsgPairNestStart", last_off));
5337 break;
5338 }
5339 }
5340 Devlink::FmsgArrNestStart(val) => {
5341 if last_off == offset {
5342 stack.push(("FmsgArrNestStart", last_off));
5343 break;
5344 }
5345 }
5346 Devlink::FmsgNestEnd(val) => {
5347 if last_off == offset {
5348 stack.push(("FmsgNestEnd", last_off));
5349 break;
5350 }
5351 }
5352 Devlink::FmsgObjName(val) => {
5353 if last_off == offset {
5354 stack.push(("FmsgObjName", last_off));
5355 break;
5356 }
5357 }
5358 Devlink::FmsgObjValueType(val) => {
5359 if last_off == offset {
5360 stack.push(("FmsgObjValueType", last_off));
5361 break;
5362 }
5363 }
5364 Devlink::HealthReporter(val) => {
5365 (stack, missing) = val.lookup_attr(offset, missing_type);
5366 if !stack.is_empty() {
5367 break;
5368 }
5369 }
5370 Devlink::HealthReporterName(val) => {
5371 if last_off == offset {
5372 stack.push(("HealthReporterName", last_off));
5373 break;
5374 }
5375 }
5376 Devlink::HealthReporterState(val) => {
5377 if last_off == offset {
5378 stack.push(("HealthReporterState", last_off));
5379 break;
5380 }
5381 }
5382 Devlink::HealthReporterErrCount(val) => {
5383 if last_off == offset {
5384 stack.push(("HealthReporterErrCount", last_off));
5385 break;
5386 }
5387 }
5388 Devlink::HealthReporterRecoverCount(val) => {
5389 if last_off == offset {
5390 stack.push(("HealthReporterRecoverCount", last_off));
5391 break;
5392 }
5393 }
5394 Devlink::HealthReporterDumpTs(val) => {
5395 if last_off == offset {
5396 stack.push(("HealthReporterDumpTs", last_off));
5397 break;
5398 }
5399 }
5400 Devlink::HealthReporterGracefulPeriod(val) => {
5401 if last_off == offset {
5402 stack.push(("HealthReporterGracefulPeriod", last_off));
5403 break;
5404 }
5405 }
5406 Devlink::HealthReporterAutoRecover(val) => {
5407 if last_off == offset {
5408 stack.push(("HealthReporterAutoRecover", last_off));
5409 break;
5410 }
5411 }
5412 Devlink::FlashUpdateFileName(val) => {
5413 if last_off == offset {
5414 stack.push(("FlashUpdateFileName", last_off));
5415 break;
5416 }
5417 }
5418 Devlink::FlashUpdateComponent(val) => {
5419 if last_off == offset {
5420 stack.push(("FlashUpdateComponent", last_off));
5421 break;
5422 }
5423 }
5424 Devlink::FlashUpdateStatusMsg(val) => {
5425 if last_off == offset {
5426 stack.push(("FlashUpdateStatusMsg", last_off));
5427 break;
5428 }
5429 }
5430 Devlink::FlashUpdateStatusDone(val) => {
5431 if last_off == offset {
5432 stack.push(("FlashUpdateStatusDone", last_off));
5433 break;
5434 }
5435 }
5436 Devlink::FlashUpdateStatusTotal(val) => {
5437 if last_off == offset {
5438 stack.push(("FlashUpdateStatusTotal", last_off));
5439 break;
5440 }
5441 }
5442 Devlink::PortPciPfNumber(val) => {
5443 if last_off == offset {
5444 stack.push(("PortPciPfNumber", last_off));
5445 break;
5446 }
5447 }
5448 Devlink::PortPciVfNumber(val) => {
5449 if last_off == offset {
5450 stack.push(("PortPciVfNumber", last_off));
5451 break;
5452 }
5453 }
5454 Devlink::Stats(val) => {
5455 (stack, missing) = val.lookup_attr(offset, missing_type);
5456 if !stack.is_empty() {
5457 break;
5458 }
5459 }
5460 Devlink::TrapName(val) => {
5461 if last_off == offset {
5462 stack.push(("TrapName", last_off));
5463 break;
5464 }
5465 }
5466 Devlink::TrapAction(val) => {
5467 if last_off == offset {
5468 stack.push(("TrapAction", last_off));
5469 break;
5470 }
5471 }
5472 Devlink::TrapType(val) => {
5473 if last_off == offset {
5474 stack.push(("TrapType", last_off));
5475 break;
5476 }
5477 }
5478 Devlink::TrapGeneric(val) => {
5479 if last_off == offset {
5480 stack.push(("TrapGeneric", last_off));
5481 break;
5482 }
5483 }
5484 Devlink::TrapMetadata(val) => {
5485 (stack, missing) = val.lookup_attr(offset, missing_type);
5486 if !stack.is_empty() {
5487 break;
5488 }
5489 }
5490 Devlink::TrapGroupName(val) => {
5491 if last_off == offset {
5492 stack.push(("TrapGroupName", last_off));
5493 break;
5494 }
5495 }
5496 Devlink::ReloadFailed(val) => {
5497 if last_off == offset {
5498 stack.push(("ReloadFailed", last_off));
5499 break;
5500 }
5501 }
5502 Devlink::HealthReporterDumpTsNs(val) => {
5503 if last_off == offset {
5504 stack.push(("HealthReporterDumpTsNs", last_off));
5505 break;
5506 }
5507 }
5508 Devlink::NetnsFd(val) => {
5509 if last_off == offset {
5510 stack.push(("NetnsFd", last_off));
5511 break;
5512 }
5513 }
5514 Devlink::NetnsPid(val) => {
5515 if last_off == offset {
5516 stack.push(("NetnsPid", last_off));
5517 break;
5518 }
5519 }
5520 Devlink::NetnsId(val) => {
5521 if last_off == offset {
5522 stack.push(("NetnsId", last_off));
5523 break;
5524 }
5525 }
5526 Devlink::HealthReporterAutoDump(val) => {
5527 if last_off == offset {
5528 stack.push(("HealthReporterAutoDump", last_off));
5529 break;
5530 }
5531 }
5532 Devlink::TrapPolicerId(val) => {
5533 if last_off == offset {
5534 stack.push(("TrapPolicerId", last_off));
5535 break;
5536 }
5537 }
5538 Devlink::TrapPolicerRate(val) => {
5539 if last_off == offset {
5540 stack.push(("TrapPolicerRate", last_off));
5541 break;
5542 }
5543 }
5544 Devlink::TrapPolicerBurst(val) => {
5545 if last_off == offset {
5546 stack.push(("TrapPolicerBurst", last_off));
5547 break;
5548 }
5549 }
5550 Devlink::PortFunction(val) => {
5551 (stack, missing) = val.lookup_attr(offset, missing_type);
5552 if !stack.is_empty() {
5553 break;
5554 }
5555 }
5556 Devlink::InfoBoardSerialNumber(val) => {
5557 if last_off == offset {
5558 stack.push(("InfoBoardSerialNumber", last_off));
5559 break;
5560 }
5561 }
5562 Devlink::PortLanes(val) => {
5563 if last_off == offset {
5564 stack.push(("PortLanes", last_off));
5565 break;
5566 }
5567 }
5568 Devlink::PortSplittable(val) => {
5569 if last_off == offset {
5570 stack.push(("PortSplittable", last_off));
5571 break;
5572 }
5573 }
5574 Devlink::PortExternal(val) => {
5575 if last_off == offset {
5576 stack.push(("PortExternal", last_off));
5577 break;
5578 }
5579 }
5580 Devlink::PortControllerNumber(val) => {
5581 if last_off == offset {
5582 stack.push(("PortControllerNumber", last_off));
5583 break;
5584 }
5585 }
5586 Devlink::FlashUpdateStatusTimeout(val) => {
5587 if last_off == offset {
5588 stack.push(("FlashUpdateStatusTimeout", last_off));
5589 break;
5590 }
5591 }
5592 Devlink::FlashUpdateOverwriteMask(val) => {
5593 if last_off == offset {
5594 stack.push(("FlashUpdateOverwriteMask", last_off));
5595 break;
5596 }
5597 }
5598 Devlink::ReloadAction(val) => {
5599 if last_off == offset {
5600 stack.push(("ReloadAction", last_off));
5601 break;
5602 }
5603 }
5604 Devlink::ReloadActionsPerformed(val) => {
5605 if last_off == offset {
5606 stack.push(("ReloadActionsPerformed", last_off));
5607 break;
5608 }
5609 }
5610 Devlink::ReloadLimits(val) => {
5611 if last_off == offset {
5612 stack.push(("ReloadLimits", last_off));
5613 break;
5614 }
5615 }
5616 Devlink::DevStats(val) => {
5617 (stack, missing) = val.lookup_attr(offset, missing_type);
5618 if !stack.is_empty() {
5619 break;
5620 }
5621 }
5622 Devlink::ReloadStats(val) => {
5623 (stack, missing) = val.lookup_attr(offset, missing_type);
5624 if !stack.is_empty() {
5625 break;
5626 }
5627 }
5628 Devlink::ReloadStatsEntry(val) => {
5629 (stack, missing) = val.lookup_attr(offset, missing_type);
5630 if !stack.is_empty() {
5631 break;
5632 }
5633 }
5634 Devlink::ReloadStatsLimit(val) => {
5635 if last_off == offset {
5636 stack.push(("ReloadStatsLimit", last_off));
5637 break;
5638 }
5639 }
5640 Devlink::ReloadStatsValue(val) => {
5641 if last_off == offset {
5642 stack.push(("ReloadStatsValue", last_off));
5643 break;
5644 }
5645 }
5646 Devlink::RemoteReloadStats(val) => {
5647 (stack, missing) = val.lookup_attr(offset, missing_type);
5648 if !stack.is_empty() {
5649 break;
5650 }
5651 }
5652 Devlink::ReloadActionInfo(val) => {
5653 (stack, missing) = val.lookup_attr(offset, missing_type);
5654 if !stack.is_empty() {
5655 break;
5656 }
5657 }
5658 Devlink::ReloadActionStats(val) => {
5659 (stack, missing) = val.lookup_attr(offset, missing_type);
5660 if !stack.is_empty() {
5661 break;
5662 }
5663 }
5664 Devlink::PortPciSfNumber(val) => {
5665 if last_off == offset {
5666 stack.push(("PortPciSfNumber", last_off));
5667 break;
5668 }
5669 }
5670 Devlink::RateType(val) => {
5671 if last_off == offset {
5672 stack.push(("RateType", last_off));
5673 break;
5674 }
5675 }
5676 Devlink::RateTxShare(val) => {
5677 if last_off == offset {
5678 stack.push(("RateTxShare", last_off));
5679 break;
5680 }
5681 }
5682 Devlink::RateTxMax(val) => {
5683 if last_off == offset {
5684 stack.push(("RateTxMax", last_off));
5685 break;
5686 }
5687 }
5688 Devlink::RateNodeName(val) => {
5689 if last_off == offset {
5690 stack.push(("RateNodeName", last_off));
5691 break;
5692 }
5693 }
5694 Devlink::RateParentNodeName(val) => {
5695 if last_off == offset {
5696 stack.push(("RateParentNodeName", last_off));
5697 break;
5698 }
5699 }
5700 Devlink::RegionMaxSnapshots(val) => {
5701 if last_off == offset {
5702 stack.push(("RegionMaxSnapshots", last_off));
5703 break;
5704 }
5705 }
5706 Devlink::LinecardIndex(val) => {
5707 if last_off == offset {
5708 stack.push(("LinecardIndex", last_off));
5709 break;
5710 }
5711 }
5712 Devlink::LinecardState(val) => {
5713 if last_off == offset {
5714 stack.push(("LinecardState", last_off));
5715 break;
5716 }
5717 }
5718 Devlink::LinecardType(val) => {
5719 if last_off == offset {
5720 stack.push(("LinecardType", last_off));
5721 break;
5722 }
5723 }
5724 Devlink::LinecardSupportedTypes(val) => {
5725 (stack, missing) = val.lookup_attr(offset, missing_type);
5726 if !stack.is_empty() {
5727 break;
5728 }
5729 }
5730 Devlink::Selftests(val) => {
5731 (stack, missing) = val.lookup_attr(offset, missing_type);
5732 if !stack.is_empty() {
5733 break;
5734 }
5735 }
5736 Devlink::RateTxPriority(val) => {
5737 if last_off == offset {
5738 stack.push(("RateTxPriority", last_off));
5739 break;
5740 }
5741 }
5742 Devlink::RateTxWeight(val) => {
5743 if last_off == offset {
5744 stack.push(("RateTxWeight", last_off));
5745 break;
5746 }
5747 }
5748 Devlink::RegionDirect(val) => {
5749 if last_off == offset {
5750 stack.push(("RegionDirect", last_off));
5751 break;
5752 }
5753 }
5754 Devlink::RateTcBws(val) => {
5755 (stack, missing) = val.lookup_attr(offset, missing_type);
5756 if !stack.is_empty() {
5757 break;
5758 }
5759 }
5760 Devlink::HealthReporterBurstPeriod(val) => {
5761 if last_off == offset {
5762 stack.push(("HealthReporterBurstPeriod", last_off));
5763 break;
5764 }
5765 }
5766 Devlink::ParamResetDefault(val) => {
5767 if last_off == offset {
5768 stack.push(("ParamResetDefault", last_off));
5769 break;
5770 }
5771 }
5772 Devlink::Index(val) => {
5773 if last_off == offset {
5774 stack.push(("Index", last_off));
5775 break;
5776 }
5777 }
5778 Devlink::ResourceScopeMask(val) => {
5779 if last_off == offset {
5780 stack.push(("ResourceScopeMask", last_off));
5781 break;
5782 }
5783 }
5784 _ => {}
5785 };
5786 last_off = cur + attrs.pos;
5787 }
5788 if !stack.is_empty() {
5789 stack.push(("Devlink", cur));
5790 }
5791 (stack, missing)
5792 }
5793}
5794#[derive(Clone)]
5795pub enum DlDevStats<'a> {
5796 ReloadStats(IterableDlReloadStats<'a>),
5797 RemoteReloadStats(IterableDlReloadStats<'a>),
5798}
5799impl<'a> IterableDlDevStats<'a> {
5800 pub fn get_reload_stats(&self) -> Result<IterableDlReloadStats<'a>, ErrorContext> {
5801 let mut iter = self.clone();
5802 iter.pos = 0;
5803 for attr in iter {
5804 if let Ok(DlDevStats::ReloadStats(val)) = attr {
5805 return Ok(val);
5806 }
5807 }
5808 Err(ErrorContext::new_missing(
5809 "DlDevStats",
5810 "ReloadStats",
5811 self.orig_loc,
5812 self.buf.as_ptr() as usize,
5813 ))
5814 }
5815 pub fn get_remote_reload_stats(&self) -> Result<IterableDlReloadStats<'a>, ErrorContext> {
5816 let mut iter = self.clone();
5817 iter.pos = 0;
5818 for attr in iter {
5819 if let Ok(DlDevStats::RemoteReloadStats(val)) = attr {
5820 return Ok(val);
5821 }
5822 }
5823 Err(ErrorContext::new_missing(
5824 "DlDevStats",
5825 "RemoteReloadStats",
5826 self.orig_loc,
5827 self.buf.as_ptr() as usize,
5828 ))
5829 }
5830}
5831impl DlDevStats<'_> {
5832 pub fn new<'a>(buf: &'a [u8]) -> IterableDlDevStats<'a> {
5833 IterableDlDevStats::with_loc(buf, buf.as_ptr() as usize)
5834 }
5835 fn attr_from_type(r#type: u16) -> Option<&'static str> {
5836 Devlink::attr_from_type(r#type)
5837 }
5838}
5839#[derive(Clone, Copy, Default)]
5840pub struct IterableDlDevStats<'a> {
5841 buf: &'a [u8],
5842 pos: usize,
5843 orig_loc: usize,
5844}
5845impl<'a> IterableDlDevStats<'a> {
5846 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
5847 Self {
5848 buf,
5849 pos: 0,
5850 orig_loc,
5851 }
5852 }
5853 pub fn get_buf(&self) -> &'a [u8] {
5854 self.buf
5855 }
5856}
5857impl<'a> Iterator for IterableDlDevStats<'a> {
5858 type Item = Result<DlDevStats<'a>, ErrorContext>;
5859 fn next(&mut self) -> Option<Self::Item> {
5860 let mut pos;
5861 let mut r#type;
5862 loop {
5863 pos = self.pos;
5864 r#type = None;
5865 if self.buf.len() == self.pos {
5866 return None;
5867 }
5868 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
5869 self.pos = self.buf.len();
5870 break;
5871 };
5872 r#type = Some(header.r#type);
5873 let res = match header.r#type {
5874 157u16 => DlDevStats::ReloadStats({
5875 let res = Some(IterableDlReloadStats::with_loc(next, self.orig_loc));
5876 let Some(val) = res else { break };
5877 val
5878 }),
5879 161u16 => DlDevStats::RemoteReloadStats({
5880 let res = Some(IterableDlReloadStats::with_loc(next, self.orig_loc));
5881 let Some(val) = res else { break };
5882 val
5883 }),
5884 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
5885 n => continue,
5886 };
5887 return Some(Ok(res));
5888 }
5889 Some(Err(ErrorContext::new(
5890 "DlDevStats",
5891 r#type.and_then(|t| DlDevStats::attr_from_type(t)),
5892 self.orig_loc,
5893 self.buf.as_ptr().wrapping_add(pos) as usize,
5894 )))
5895 }
5896}
5897impl<'a> std::fmt::Debug for IterableDlDevStats<'_> {
5898 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5899 let mut fmt = f.debug_struct("DlDevStats");
5900 for attr in self.clone() {
5901 let attr = match attr {
5902 Ok(a) => a,
5903 Err(err) => {
5904 fmt.finish()?;
5905 f.write_str("Err(")?;
5906 err.fmt(f)?;
5907 return f.write_str(")");
5908 }
5909 };
5910 match attr {
5911 DlDevStats::ReloadStats(val) => fmt.field("ReloadStats", &val),
5912 DlDevStats::RemoteReloadStats(val) => fmt.field("RemoteReloadStats", &val),
5913 };
5914 }
5915 fmt.finish()
5916 }
5917}
5918impl IterableDlDevStats<'_> {
5919 pub fn lookup_attr(
5920 &self,
5921 offset: usize,
5922 missing_type: Option<u16>,
5923 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
5924 let mut stack = Vec::new();
5925 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
5926 if missing_type.is_some() && cur == offset {
5927 stack.push(("DlDevStats", offset));
5928 return (
5929 stack,
5930 missing_type.and_then(|t| DlDevStats::attr_from_type(t)),
5931 );
5932 }
5933 if cur > offset || cur + self.buf.len() < offset {
5934 return (stack, None);
5935 }
5936 let mut attrs = self.clone();
5937 let mut last_off = cur + attrs.pos;
5938 let mut missing = None;
5939 while let Some(attr) = attrs.next() {
5940 let Ok(attr) = attr else { break };
5941 match attr {
5942 DlDevStats::ReloadStats(val) => {
5943 (stack, missing) = val.lookup_attr(offset, missing_type);
5944 if !stack.is_empty() {
5945 break;
5946 }
5947 }
5948 DlDevStats::RemoteReloadStats(val) => {
5949 (stack, missing) = val.lookup_attr(offset, missing_type);
5950 if !stack.is_empty() {
5951 break;
5952 }
5953 }
5954 _ => {}
5955 };
5956 last_off = cur + attrs.pos;
5957 }
5958 if !stack.is_empty() {
5959 stack.push(("DlDevStats", cur));
5960 }
5961 (stack, missing)
5962 }
5963}
5964#[derive(Clone)]
5965pub enum DlReloadStats<'a> {
5966 #[doc = "Attribute may repeat multiple times (treat it as array)"]
5967 ReloadActionInfo(IterableDlReloadActInfo<'a>),
5968}
5969impl<'a> IterableDlReloadStats<'a> {
5970 #[doc = "Attribute may repeat multiple times (treat it as array)"]
5971 pub fn get_reload_action_info(
5972 &self,
5973 ) -> MultiAttrIterable<Self, DlReloadStats<'a>, IterableDlReloadActInfo<'a>> {
5974 MultiAttrIterable::new(self.clone(), |variant| {
5975 if let DlReloadStats::ReloadActionInfo(val) = variant {
5976 Some(val)
5977 } else {
5978 None
5979 }
5980 })
5981 }
5982}
5983impl DlReloadStats<'_> {
5984 pub fn new<'a>(buf: &'a [u8]) -> IterableDlReloadStats<'a> {
5985 IterableDlReloadStats::with_loc(buf, buf.as_ptr() as usize)
5986 }
5987 fn attr_from_type(r#type: u16) -> Option<&'static str> {
5988 Devlink::attr_from_type(r#type)
5989 }
5990}
5991#[derive(Clone, Copy, Default)]
5992pub struct IterableDlReloadStats<'a> {
5993 buf: &'a [u8],
5994 pos: usize,
5995 orig_loc: usize,
5996}
5997impl<'a> IterableDlReloadStats<'a> {
5998 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
5999 Self {
6000 buf,
6001 pos: 0,
6002 orig_loc,
6003 }
6004 }
6005 pub fn get_buf(&self) -> &'a [u8] {
6006 self.buf
6007 }
6008}
6009impl<'a> Iterator for IterableDlReloadStats<'a> {
6010 type Item = Result<DlReloadStats<'a>, ErrorContext>;
6011 fn next(&mut self) -> Option<Self::Item> {
6012 let mut pos;
6013 let mut r#type;
6014 loop {
6015 pos = self.pos;
6016 r#type = None;
6017 if self.buf.len() == self.pos {
6018 return None;
6019 }
6020 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
6021 self.pos = self.buf.len();
6022 break;
6023 };
6024 r#type = Some(header.r#type);
6025 let res = match header.r#type {
6026 162u16 => DlReloadStats::ReloadActionInfo({
6027 let res = Some(IterableDlReloadActInfo::with_loc(next, self.orig_loc));
6028 let Some(val) = res else { break };
6029 val
6030 }),
6031 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
6032 n => continue,
6033 };
6034 return Some(Ok(res));
6035 }
6036 Some(Err(ErrorContext::new(
6037 "DlReloadStats",
6038 r#type.and_then(|t| DlReloadStats::attr_from_type(t)),
6039 self.orig_loc,
6040 self.buf.as_ptr().wrapping_add(pos) as usize,
6041 )))
6042 }
6043}
6044impl<'a> std::fmt::Debug for IterableDlReloadStats<'_> {
6045 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6046 let mut fmt = f.debug_struct("DlReloadStats");
6047 for attr in self.clone() {
6048 let attr = match attr {
6049 Ok(a) => a,
6050 Err(err) => {
6051 fmt.finish()?;
6052 f.write_str("Err(")?;
6053 err.fmt(f)?;
6054 return f.write_str(")");
6055 }
6056 };
6057 match attr {
6058 DlReloadStats::ReloadActionInfo(val) => fmt.field("ReloadActionInfo", &val),
6059 };
6060 }
6061 fmt.finish()
6062 }
6063}
6064impl IterableDlReloadStats<'_> {
6065 pub fn lookup_attr(
6066 &self,
6067 offset: usize,
6068 missing_type: Option<u16>,
6069 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
6070 let mut stack = Vec::new();
6071 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
6072 if missing_type.is_some() && cur == offset {
6073 stack.push(("DlReloadStats", offset));
6074 return (
6075 stack,
6076 missing_type.and_then(|t| DlReloadStats::attr_from_type(t)),
6077 );
6078 }
6079 if cur > offset || cur + self.buf.len() < offset {
6080 return (stack, None);
6081 }
6082 let mut attrs = self.clone();
6083 let mut last_off = cur + attrs.pos;
6084 let mut missing = None;
6085 while let Some(attr) = attrs.next() {
6086 let Ok(attr) = attr else { break };
6087 match attr {
6088 DlReloadStats::ReloadActionInfo(val) => {
6089 (stack, missing) = val.lookup_attr(offset, missing_type);
6090 if !stack.is_empty() {
6091 break;
6092 }
6093 }
6094 _ => {}
6095 };
6096 last_off = cur + attrs.pos;
6097 }
6098 if !stack.is_empty() {
6099 stack.push(("DlReloadStats", cur));
6100 }
6101 (stack, missing)
6102 }
6103}
6104#[derive(Clone)]
6105pub enum DlReloadActInfo<'a> {
6106 #[doc = "Associated type: [`ReloadAction`] (enum)"]
6107 ReloadAction(u8),
6108 #[doc = "Attribute may repeat multiple times (treat it as array)"]
6109 ReloadActionStats(IterableDlReloadActStats<'a>),
6110}
6111impl<'a> IterableDlReloadActInfo<'a> {
6112 #[doc = "Associated type: [`ReloadAction`] (enum)"]
6113 pub fn get_reload_action(&self) -> Result<u8, ErrorContext> {
6114 let mut iter = self.clone();
6115 iter.pos = 0;
6116 for attr in iter {
6117 if let Ok(DlReloadActInfo::ReloadAction(val)) = attr {
6118 return Ok(val);
6119 }
6120 }
6121 Err(ErrorContext::new_missing(
6122 "DlReloadActInfo",
6123 "ReloadAction",
6124 self.orig_loc,
6125 self.buf.as_ptr() as usize,
6126 ))
6127 }
6128 #[doc = "Attribute may repeat multiple times (treat it as array)"]
6129 pub fn get_reload_action_stats(
6130 &self,
6131 ) -> MultiAttrIterable<Self, DlReloadActInfo<'a>, IterableDlReloadActStats<'a>> {
6132 MultiAttrIterable::new(self.clone(), |variant| {
6133 if let DlReloadActInfo::ReloadActionStats(val) = variant {
6134 Some(val)
6135 } else {
6136 None
6137 }
6138 })
6139 }
6140}
6141impl DlReloadActInfo<'_> {
6142 pub fn new<'a>(buf: &'a [u8]) -> IterableDlReloadActInfo<'a> {
6143 IterableDlReloadActInfo::with_loc(buf, buf.as_ptr() as usize)
6144 }
6145 fn attr_from_type(r#type: u16) -> Option<&'static str> {
6146 Devlink::attr_from_type(r#type)
6147 }
6148}
6149#[derive(Clone, Copy, Default)]
6150pub struct IterableDlReloadActInfo<'a> {
6151 buf: &'a [u8],
6152 pos: usize,
6153 orig_loc: usize,
6154}
6155impl<'a> IterableDlReloadActInfo<'a> {
6156 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
6157 Self {
6158 buf,
6159 pos: 0,
6160 orig_loc,
6161 }
6162 }
6163 pub fn get_buf(&self) -> &'a [u8] {
6164 self.buf
6165 }
6166}
6167impl<'a> Iterator for IterableDlReloadActInfo<'a> {
6168 type Item = Result<DlReloadActInfo<'a>, ErrorContext>;
6169 fn next(&mut self) -> Option<Self::Item> {
6170 let mut pos;
6171 let mut r#type;
6172 loop {
6173 pos = self.pos;
6174 r#type = None;
6175 if self.buf.len() == self.pos {
6176 return None;
6177 }
6178 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
6179 self.pos = self.buf.len();
6180 break;
6181 };
6182 r#type = Some(header.r#type);
6183 let res = match header.r#type {
6184 153u16 => DlReloadActInfo::ReloadAction({
6185 let res = parse_u8(next);
6186 let Some(val) = res else { break };
6187 val
6188 }),
6189 163u16 => DlReloadActInfo::ReloadActionStats({
6190 let res = Some(IterableDlReloadActStats::with_loc(next, self.orig_loc));
6191 let Some(val) = res else { break };
6192 val
6193 }),
6194 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
6195 n => continue,
6196 };
6197 return Some(Ok(res));
6198 }
6199 Some(Err(ErrorContext::new(
6200 "DlReloadActInfo",
6201 r#type.and_then(|t| DlReloadActInfo::attr_from_type(t)),
6202 self.orig_loc,
6203 self.buf.as_ptr().wrapping_add(pos) as usize,
6204 )))
6205 }
6206}
6207impl<'a> std::fmt::Debug for IterableDlReloadActInfo<'_> {
6208 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6209 let mut fmt = f.debug_struct("DlReloadActInfo");
6210 for attr in self.clone() {
6211 let attr = match attr {
6212 Ok(a) => a,
6213 Err(err) => {
6214 fmt.finish()?;
6215 f.write_str("Err(")?;
6216 err.fmt(f)?;
6217 return f.write_str(")");
6218 }
6219 };
6220 match attr {
6221 DlReloadActInfo::ReloadAction(val) => fmt.field(
6222 "ReloadAction",
6223 &FormatEnum(val.into(), ReloadAction::from_value),
6224 ),
6225 DlReloadActInfo::ReloadActionStats(val) => fmt.field("ReloadActionStats", &val),
6226 };
6227 }
6228 fmt.finish()
6229 }
6230}
6231impl IterableDlReloadActInfo<'_> {
6232 pub fn lookup_attr(
6233 &self,
6234 offset: usize,
6235 missing_type: Option<u16>,
6236 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
6237 let mut stack = Vec::new();
6238 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
6239 if missing_type.is_some() && cur == offset {
6240 stack.push(("DlReloadActInfo", offset));
6241 return (
6242 stack,
6243 missing_type.and_then(|t| DlReloadActInfo::attr_from_type(t)),
6244 );
6245 }
6246 if cur > offset || cur + self.buf.len() < offset {
6247 return (stack, None);
6248 }
6249 let mut attrs = self.clone();
6250 let mut last_off = cur + attrs.pos;
6251 let mut missing = None;
6252 while let Some(attr) = attrs.next() {
6253 let Ok(attr) = attr else { break };
6254 match attr {
6255 DlReloadActInfo::ReloadAction(val) => {
6256 if last_off == offset {
6257 stack.push(("ReloadAction", last_off));
6258 break;
6259 }
6260 }
6261 DlReloadActInfo::ReloadActionStats(val) => {
6262 (stack, missing) = val.lookup_attr(offset, missing_type);
6263 if !stack.is_empty() {
6264 break;
6265 }
6266 }
6267 _ => {}
6268 };
6269 last_off = cur + attrs.pos;
6270 }
6271 if !stack.is_empty() {
6272 stack.push(("DlReloadActInfo", cur));
6273 }
6274 (stack, missing)
6275 }
6276}
6277#[derive(Clone)]
6278pub enum DlReloadActStats<'a> {
6279 #[doc = "Attribute may repeat multiple times (treat it as array)"]
6280 ReloadStatsEntry(IterableDlReloadStatsEntry<'a>),
6281}
6282impl<'a> IterableDlReloadActStats<'a> {
6283 #[doc = "Attribute may repeat multiple times (treat it as array)"]
6284 pub fn get_reload_stats_entry(
6285 &self,
6286 ) -> MultiAttrIterable<Self, DlReloadActStats<'a>, IterableDlReloadStatsEntry<'a>> {
6287 MultiAttrIterable::new(self.clone(), |variant| {
6288 if let DlReloadActStats::ReloadStatsEntry(val) = variant {
6289 Some(val)
6290 } else {
6291 None
6292 }
6293 })
6294 }
6295}
6296impl DlReloadActStats<'_> {
6297 pub fn new<'a>(buf: &'a [u8]) -> IterableDlReloadActStats<'a> {
6298 IterableDlReloadActStats::with_loc(buf, buf.as_ptr() as usize)
6299 }
6300 fn attr_from_type(r#type: u16) -> Option<&'static str> {
6301 Devlink::attr_from_type(r#type)
6302 }
6303}
6304#[derive(Clone, Copy, Default)]
6305pub struct IterableDlReloadActStats<'a> {
6306 buf: &'a [u8],
6307 pos: usize,
6308 orig_loc: usize,
6309}
6310impl<'a> IterableDlReloadActStats<'a> {
6311 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
6312 Self {
6313 buf,
6314 pos: 0,
6315 orig_loc,
6316 }
6317 }
6318 pub fn get_buf(&self) -> &'a [u8] {
6319 self.buf
6320 }
6321}
6322impl<'a> Iterator for IterableDlReloadActStats<'a> {
6323 type Item = Result<DlReloadActStats<'a>, ErrorContext>;
6324 fn next(&mut self) -> Option<Self::Item> {
6325 let mut pos;
6326 let mut r#type;
6327 loop {
6328 pos = self.pos;
6329 r#type = None;
6330 if self.buf.len() == self.pos {
6331 return None;
6332 }
6333 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
6334 self.pos = self.buf.len();
6335 break;
6336 };
6337 r#type = Some(header.r#type);
6338 let res = match header.r#type {
6339 158u16 => DlReloadActStats::ReloadStatsEntry({
6340 let res = Some(IterableDlReloadStatsEntry::with_loc(next, self.orig_loc));
6341 let Some(val) = res else { break };
6342 val
6343 }),
6344 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
6345 n => continue,
6346 };
6347 return Some(Ok(res));
6348 }
6349 Some(Err(ErrorContext::new(
6350 "DlReloadActStats",
6351 r#type.and_then(|t| DlReloadActStats::attr_from_type(t)),
6352 self.orig_loc,
6353 self.buf.as_ptr().wrapping_add(pos) as usize,
6354 )))
6355 }
6356}
6357impl<'a> std::fmt::Debug for IterableDlReloadActStats<'_> {
6358 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6359 let mut fmt = f.debug_struct("DlReloadActStats");
6360 for attr in self.clone() {
6361 let attr = match attr {
6362 Ok(a) => a,
6363 Err(err) => {
6364 fmt.finish()?;
6365 f.write_str("Err(")?;
6366 err.fmt(f)?;
6367 return f.write_str(")");
6368 }
6369 };
6370 match attr {
6371 DlReloadActStats::ReloadStatsEntry(val) => fmt.field("ReloadStatsEntry", &val),
6372 };
6373 }
6374 fmt.finish()
6375 }
6376}
6377impl IterableDlReloadActStats<'_> {
6378 pub fn lookup_attr(
6379 &self,
6380 offset: usize,
6381 missing_type: Option<u16>,
6382 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
6383 let mut stack = Vec::new();
6384 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
6385 if missing_type.is_some() && cur == offset {
6386 stack.push(("DlReloadActStats", offset));
6387 return (
6388 stack,
6389 missing_type.and_then(|t| DlReloadActStats::attr_from_type(t)),
6390 );
6391 }
6392 if cur > offset || cur + self.buf.len() < offset {
6393 return (stack, None);
6394 }
6395 let mut attrs = self.clone();
6396 let mut last_off = cur + attrs.pos;
6397 let mut missing = None;
6398 while let Some(attr) = attrs.next() {
6399 let Ok(attr) = attr else { break };
6400 match attr {
6401 DlReloadActStats::ReloadStatsEntry(val) => {
6402 (stack, missing) = val.lookup_attr(offset, missing_type);
6403 if !stack.is_empty() {
6404 break;
6405 }
6406 }
6407 _ => {}
6408 };
6409 last_off = cur + attrs.pos;
6410 }
6411 if !stack.is_empty() {
6412 stack.push(("DlReloadActStats", cur));
6413 }
6414 (stack, missing)
6415 }
6416}
6417#[derive(Clone)]
6418pub enum DlReloadStatsEntry {
6419 ReloadStatsLimit(u8),
6420 ReloadStatsValue(u32),
6421}
6422impl<'a> IterableDlReloadStatsEntry<'a> {
6423 pub fn get_reload_stats_limit(&self) -> Result<u8, ErrorContext> {
6424 let mut iter = self.clone();
6425 iter.pos = 0;
6426 for attr in iter {
6427 if let Ok(DlReloadStatsEntry::ReloadStatsLimit(val)) = attr {
6428 return Ok(val);
6429 }
6430 }
6431 Err(ErrorContext::new_missing(
6432 "DlReloadStatsEntry",
6433 "ReloadStatsLimit",
6434 self.orig_loc,
6435 self.buf.as_ptr() as usize,
6436 ))
6437 }
6438 pub fn get_reload_stats_value(&self) -> Result<u32, ErrorContext> {
6439 let mut iter = self.clone();
6440 iter.pos = 0;
6441 for attr in iter {
6442 if let Ok(DlReloadStatsEntry::ReloadStatsValue(val)) = attr {
6443 return Ok(val);
6444 }
6445 }
6446 Err(ErrorContext::new_missing(
6447 "DlReloadStatsEntry",
6448 "ReloadStatsValue",
6449 self.orig_loc,
6450 self.buf.as_ptr() as usize,
6451 ))
6452 }
6453}
6454impl DlReloadStatsEntry {
6455 pub fn new<'a>(buf: &'a [u8]) -> IterableDlReloadStatsEntry<'a> {
6456 IterableDlReloadStatsEntry::with_loc(buf, buf.as_ptr() as usize)
6457 }
6458 fn attr_from_type(r#type: u16) -> Option<&'static str> {
6459 Devlink::attr_from_type(r#type)
6460 }
6461}
6462#[derive(Clone, Copy, Default)]
6463pub struct IterableDlReloadStatsEntry<'a> {
6464 buf: &'a [u8],
6465 pos: usize,
6466 orig_loc: usize,
6467}
6468impl<'a> IterableDlReloadStatsEntry<'a> {
6469 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
6470 Self {
6471 buf,
6472 pos: 0,
6473 orig_loc,
6474 }
6475 }
6476 pub fn get_buf(&self) -> &'a [u8] {
6477 self.buf
6478 }
6479}
6480impl<'a> Iterator for IterableDlReloadStatsEntry<'a> {
6481 type Item = Result<DlReloadStatsEntry, ErrorContext>;
6482 fn next(&mut self) -> Option<Self::Item> {
6483 let mut pos;
6484 let mut r#type;
6485 loop {
6486 pos = self.pos;
6487 r#type = None;
6488 if self.buf.len() == self.pos {
6489 return None;
6490 }
6491 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
6492 self.pos = self.buf.len();
6493 break;
6494 };
6495 r#type = Some(header.r#type);
6496 let res = match header.r#type {
6497 159u16 => DlReloadStatsEntry::ReloadStatsLimit({
6498 let res = parse_u8(next);
6499 let Some(val) = res else { break };
6500 val
6501 }),
6502 160u16 => DlReloadStatsEntry::ReloadStatsValue({
6503 let res = parse_u32(next);
6504 let Some(val) = res else { break };
6505 val
6506 }),
6507 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
6508 n => continue,
6509 };
6510 return Some(Ok(res));
6511 }
6512 Some(Err(ErrorContext::new(
6513 "DlReloadStatsEntry",
6514 r#type.and_then(|t| DlReloadStatsEntry::attr_from_type(t)),
6515 self.orig_loc,
6516 self.buf.as_ptr().wrapping_add(pos) as usize,
6517 )))
6518 }
6519}
6520impl std::fmt::Debug for IterableDlReloadStatsEntry<'_> {
6521 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6522 let mut fmt = f.debug_struct("DlReloadStatsEntry");
6523 for attr in self.clone() {
6524 let attr = match attr {
6525 Ok(a) => a,
6526 Err(err) => {
6527 fmt.finish()?;
6528 f.write_str("Err(")?;
6529 err.fmt(f)?;
6530 return f.write_str(")");
6531 }
6532 };
6533 match attr {
6534 DlReloadStatsEntry::ReloadStatsLimit(val) => fmt.field("ReloadStatsLimit", &val),
6535 DlReloadStatsEntry::ReloadStatsValue(val) => fmt.field("ReloadStatsValue", &val),
6536 };
6537 }
6538 fmt.finish()
6539 }
6540}
6541impl IterableDlReloadStatsEntry<'_> {
6542 pub fn lookup_attr(
6543 &self,
6544 offset: usize,
6545 missing_type: Option<u16>,
6546 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
6547 let mut stack = Vec::new();
6548 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
6549 if missing_type.is_some() && cur == offset {
6550 stack.push(("DlReloadStatsEntry", offset));
6551 return (
6552 stack,
6553 missing_type.and_then(|t| DlReloadStatsEntry::attr_from_type(t)),
6554 );
6555 }
6556 if cur > offset || cur + self.buf.len() < offset {
6557 return (stack, None);
6558 }
6559 let mut attrs = self.clone();
6560 let mut last_off = cur + attrs.pos;
6561 while let Some(attr) = attrs.next() {
6562 let Ok(attr) = attr else { break };
6563 match attr {
6564 DlReloadStatsEntry::ReloadStatsLimit(val) => {
6565 if last_off == offset {
6566 stack.push(("ReloadStatsLimit", last_off));
6567 break;
6568 }
6569 }
6570 DlReloadStatsEntry::ReloadStatsValue(val) => {
6571 if last_off == offset {
6572 stack.push(("ReloadStatsValue", last_off));
6573 break;
6574 }
6575 }
6576 _ => {}
6577 };
6578 last_off = cur + attrs.pos;
6579 }
6580 if !stack.is_empty() {
6581 stack.push(("DlReloadStatsEntry", cur));
6582 }
6583 (stack, None)
6584 }
6585}
6586#[derive(Clone)]
6587pub enum DlInfoVersion<'a> {
6588 InfoVersionName(&'a CStr),
6589 InfoVersionValue(&'a CStr),
6590}
6591impl<'a> IterableDlInfoVersion<'a> {
6592 pub fn get_info_version_name(&self) -> Result<&'a CStr, ErrorContext> {
6593 let mut iter = self.clone();
6594 iter.pos = 0;
6595 for attr in iter {
6596 if let Ok(DlInfoVersion::InfoVersionName(val)) = attr {
6597 return Ok(val);
6598 }
6599 }
6600 Err(ErrorContext::new_missing(
6601 "DlInfoVersion",
6602 "InfoVersionName",
6603 self.orig_loc,
6604 self.buf.as_ptr() as usize,
6605 ))
6606 }
6607 pub fn get_info_version_value(&self) -> Result<&'a CStr, ErrorContext> {
6608 let mut iter = self.clone();
6609 iter.pos = 0;
6610 for attr in iter {
6611 if let Ok(DlInfoVersion::InfoVersionValue(val)) = attr {
6612 return Ok(val);
6613 }
6614 }
6615 Err(ErrorContext::new_missing(
6616 "DlInfoVersion",
6617 "InfoVersionValue",
6618 self.orig_loc,
6619 self.buf.as_ptr() as usize,
6620 ))
6621 }
6622}
6623impl DlInfoVersion<'_> {
6624 pub fn new<'a>(buf: &'a [u8]) -> IterableDlInfoVersion<'a> {
6625 IterableDlInfoVersion::with_loc(buf, buf.as_ptr() as usize)
6626 }
6627 fn attr_from_type(r#type: u16) -> Option<&'static str> {
6628 Devlink::attr_from_type(r#type)
6629 }
6630}
6631#[derive(Clone, Copy, Default)]
6632pub struct IterableDlInfoVersion<'a> {
6633 buf: &'a [u8],
6634 pos: usize,
6635 orig_loc: usize,
6636}
6637impl<'a> IterableDlInfoVersion<'a> {
6638 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
6639 Self {
6640 buf,
6641 pos: 0,
6642 orig_loc,
6643 }
6644 }
6645 pub fn get_buf(&self) -> &'a [u8] {
6646 self.buf
6647 }
6648}
6649impl<'a> Iterator for IterableDlInfoVersion<'a> {
6650 type Item = Result<DlInfoVersion<'a>, ErrorContext>;
6651 fn next(&mut self) -> Option<Self::Item> {
6652 let mut pos;
6653 let mut r#type;
6654 loop {
6655 pos = self.pos;
6656 r#type = None;
6657 if self.buf.len() == self.pos {
6658 return None;
6659 }
6660 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
6661 self.pos = self.buf.len();
6662 break;
6663 };
6664 r#type = Some(header.r#type);
6665 let res = match header.r#type {
6666 103u16 => DlInfoVersion::InfoVersionName({
6667 let res = CStr::from_bytes_with_nul(next).ok();
6668 let Some(val) = res else { break };
6669 val
6670 }),
6671 104u16 => DlInfoVersion::InfoVersionValue({
6672 let res = CStr::from_bytes_with_nul(next).ok();
6673 let Some(val) = res else { break };
6674 val
6675 }),
6676 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
6677 n => continue,
6678 };
6679 return Some(Ok(res));
6680 }
6681 Some(Err(ErrorContext::new(
6682 "DlInfoVersion",
6683 r#type.and_then(|t| DlInfoVersion::attr_from_type(t)),
6684 self.orig_loc,
6685 self.buf.as_ptr().wrapping_add(pos) as usize,
6686 )))
6687 }
6688}
6689impl<'a> std::fmt::Debug for IterableDlInfoVersion<'_> {
6690 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6691 let mut fmt = f.debug_struct("DlInfoVersion");
6692 for attr in self.clone() {
6693 let attr = match attr {
6694 Ok(a) => a,
6695 Err(err) => {
6696 fmt.finish()?;
6697 f.write_str("Err(")?;
6698 err.fmt(f)?;
6699 return f.write_str(")");
6700 }
6701 };
6702 match attr {
6703 DlInfoVersion::InfoVersionName(val) => fmt.field("InfoVersionName", &val),
6704 DlInfoVersion::InfoVersionValue(val) => fmt.field("InfoVersionValue", &val),
6705 };
6706 }
6707 fmt.finish()
6708 }
6709}
6710impl IterableDlInfoVersion<'_> {
6711 pub fn lookup_attr(
6712 &self,
6713 offset: usize,
6714 missing_type: Option<u16>,
6715 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
6716 let mut stack = Vec::new();
6717 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
6718 if missing_type.is_some() && cur == offset {
6719 stack.push(("DlInfoVersion", offset));
6720 return (
6721 stack,
6722 missing_type.and_then(|t| DlInfoVersion::attr_from_type(t)),
6723 );
6724 }
6725 if cur > offset || cur + self.buf.len() < offset {
6726 return (stack, None);
6727 }
6728 let mut attrs = self.clone();
6729 let mut last_off = cur + attrs.pos;
6730 while let Some(attr) = attrs.next() {
6731 let Ok(attr) = attr else { break };
6732 match attr {
6733 DlInfoVersion::InfoVersionName(val) => {
6734 if last_off == offset {
6735 stack.push(("InfoVersionName", last_off));
6736 break;
6737 }
6738 }
6739 DlInfoVersion::InfoVersionValue(val) => {
6740 if last_off == offset {
6741 stack.push(("InfoVersionValue", last_off));
6742 break;
6743 }
6744 }
6745 _ => {}
6746 };
6747 last_off = cur + attrs.pos;
6748 }
6749 if !stack.is_empty() {
6750 stack.push(("DlInfoVersion", cur));
6751 }
6752 (stack, None)
6753 }
6754}
6755#[derive(Clone)]
6756pub enum DlPortFunction<'a> {
6757 HwAddr(&'a [u8]),
6758 #[doc = "Associated type: [`PortFnState`] (enum)"]
6759 State(u8),
6760 #[doc = "Associated type: [`PortFnOpstate`] (enum)"]
6761 Opstate(u8),
6762 #[doc = "Associated type: [`PortFnAttrCap`] (1 bit per enumeration)"]
6763 Caps(BuiltinBitfield32),
6764}
6765impl<'a> IterableDlPortFunction<'a> {
6766 pub fn get_hw_addr(&self) -> Result<&'a [u8], ErrorContext> {
6767 let mut iter = self.clone();
6768 iter.pos = 0;
6769 for attr in iter {
6770 if let Ok(DlPortFunction::HwAddr(val)) = attr {
6771 return Ok(val);
6772 }
6773 }
6774 Err(ErrorContext::new_missing(
6775 "DlPortFunction",
6776 "HwAddr",
6777 self.orig_loc,
6778 self.buf.as_ptr() as usize,
6779 ))
6780 }
6781 #[doc = "Associated type: [`PortFnState`] (enum)"]
6782 pub fn get_state(&self) -> Result<u8, ErrorContext> {
6783 let mut iter = self.clone();
6784 iter.pos = 0;
6785 for attr in iter {
6786 if let Ok(DlPortFunction::State(val)) = attr {
6787 return Ok(val);
6788 }
6789 }
6790 Err(ErrorContext::new_missing(
6791 "DlPortFunction",
6792 "State",
6793 self.orig_loc,
6794 self.buf.as_ptr() as usize,
6795 ))
6796 }
6797 #[doc = "Associated type: [`PortFnOpstate`] (enum)"]
6798 pub fn get_opstate(&self) -> Result<u8, ErrorContext> {
6799 let mut iter = self.clone();
6800 iter.pos = 0;
6801 for attr in iter {
6802 if let Ok(DlPortFunction::Opstate(val)) = attr {
6803 return Ok(val);
6804 }
6805 }
6806 Err(ErrorContext::new_missing(
6807 "DlPortFunction",
6808 "Opstate",
6809 self.orig_loc,
6810 self.buf.as_ptr() as usize,
6811 ))
6812 }
6813 #[doc = "Associated type: [`PortFnAttrCap`] (1 bit per enumeration)"]
6814 pub fn get_caps(&self) -> Result<BuiltinBitfield32, ErrorContext> {
6815 let mut iter = self.clone();
6816 iter.pos = 0;
6817 for attr in iter {
6818 if let Ok(DlPortFunction::Caps(val)) = attr {
6819 return Ok(val);
6820 }
6821 }
6822 Err(ErrorContext::new_missing(
6823 "DlPortFunction",
6824 "Caps",
6825 self.orig_loc,
6826 self.buf.as_ptr() as usize,
6827 ))
6828 }
6829}
6830impl DlPortFunction<'_> {
6831 pub fn new<'a>(buf: &'a [u8]) -> IterableDlPortFunction<'a> {
6832 IterableDlPortFunction::with_loc(buf, buf.as_ptr() as usize)
6833 }
6834 fn attr_from_type(r#type: u16) -> Option<&'static str> {
6835 let res = match r#type {
6836 1u16 => "HwAddr",
6837 2u16 => "State",
6838 3u16 => "Opstate",
6839 4u16 => "Caps",
6840 _ => return None,
6841 };
6842 Some(res)
6843 }
6844}
6845#[derive(Clone, Copy, Default)]
6846pub struct IterableDlPortFunction<'a> {
6847 buf: &'a [u8],
6848 pos: usize,
6849 orig_loc: usize,
6850}
6851impl<'a> IterableDlPortFunction<'a> {
6852 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
6853 Self {
6854 buf,
6855 pos: 0,
6856 orig_loc,
6857 }
6858 }
6859 pub fn get_buf(&self) -> &'a [u8] {
6860 self.buf
6861 }
6862}
6863impl<'a> Iterator for IterableDlPortFunction<'a> {
6864 type Item = Result<DlPortFunction<'a>, ErrorContext>;
6865 fn next(&mut self) -> Option<Self::Item> {
6866 let mut pos;
6867 let mut r#type;
6868 loop {
6869 pos = self.pos;
6870 r#type = None;
6871 if self.buf.len() == self.pos {
6872 return None;
6873 }
6874 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
6875 self.pos = self.buf.len();
6876 break;
6877 };
6878 r#type = Some(header.r#type);
6879 let res = match header.r#type {
6880 1u16 => DlPortFunction::HwAddr({
6881 let res = Some(next);
6882 let Some(val) = res else { break };
6883 val
6884 }),
6885 2u16 => DlPortFunction::State({
6886 let res = parse_u8(next);
6887 let Some(val) = res else { break };
6888 val
6889 }),
6890 3u16 => DlPortFunction::Opstate({
6891 let res = parse_u8(next);
6892 let Some(val) = res else { break };
6893 val
6894 }),
6895 4u16 => DlPortFunction::Caps({
6896 let res = BuiltinBitfield32::new_from_slice(next);
6897 let Some(val) = res else { break };
6898 val
6899 }),
6900 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
6901 n => continue,
6902 };
6903 return Some(Ok(res));
6904 }
6905 Some(Err(ErrorContext::new(
6906 "DlPortFunction",
6907 r#type.and_then(|t| DlPortFunction::attr_from_type(t)),
6908 self.orig_loc,
6909 self.buf.as_ptr().wrapping_add(pos) as usize,
6910 )))
6911 }
6912}
6913impl<'a> std::fmt::Debug for IterableDlPortFunction<'_> {
6914 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6915 let mut fmt = f.debug_struct("DlPortFunction");
6916 for attr in self.clone() {
6917 let attr = match attr {
6918 Ok(a) => a,
6919 Err(err) => {
6920 fmt.finish()?;
6921 f.write_str("Err(")?;
6922 err.fmt(f)?;
6923 return f.write_str(")");
6924 }
6925 };
6926 match attr {
6927 DlPortFunction::HwAddr(val) => fmt.field("HwAddr", &val),
6928 DlPortFunction::State(val) => {
6929 fmt.field("State", &FormatEnum(val.into(), PortFnState::from_value))
6930 }
6931 DlPortFunction::Opstate(val) => fmt.field(
6932 "Opstate",
6933 &FormatEnum(val.into(), PortFnOpstate::from_value),
6934 ),
6935 DlPortFunction::Caps(val) => fmt.field(
6936 "Caps",
6937 &FormatFlags(val.value.into(), |val| {
6938 PortFnAttrCap::from_value(val.trailing_zeros().into())
6939 }),
6940 ),
6941 };
6942 }
6943 fmt.finish()
6944 }
6945}
6946impl IterableDlPortFunction<'_> {
6947 pub fn lookup_attr(
6948 &self,
6949 offset: usize,
6950 missing_type: Option<u16>,
6951 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
6952 let mut stack = Vec::new();
6953 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
6954 if missing_type.is_some() && cur == offset {
6955 stack.push(("DlPortFunction", offset));
6956 return (
6957 stack,
6958 missing_type.and_then(|t| DlPortFunction::attr_from_type(t)),
6959 );
6960 }
6961 if cur > offset || cur + self.buf.len() < offset {
6962 return (stack, None);
6963 }
6964 let mut attrs = self.clone();
6965 let mut last_off = cur + attrs.pos;
6966 while let Some(attr) = attrs.next() {
6967 let Ok(attr) = attr else { break };
6968 match attr {
6969 DlPortFunction::HwAddr(val) => {
6970 if last_off == offset {
6971 stack.push(("HwAddr", last_off));
6972 break;
6973 }
6974 }
6975 DlPortFunction::State(val) => {
6976 if last_off == offset {
6977 stack.push(("State", last_off));
6978 break;
6979 }
6980 }
6981 DlPortFunction::Opstate(val) => {
6982 if last_off == offset {
6983 stack.push(("Opstate", last_off));
6984 break;
6985 }
6986 }
6987 DlPortFunction::Caps(val) => {
6988 if last_off == offset {
6989 stack.push(("Caps", last_off));
6990 break;
6991 }
6992 }
6993 _ => {}
6994 };
6995 last_off = cur + attrs.pos;
6996 }
6997 if !stack.is_empty() {
6998 stack.push(("DlPortFunction", cur));
6999 }
7000 (stack, None)
7001 }
7002}
7003#[derive(Clone)]
7004pub enum DlDpipeTables<'a> {
7005 #[doc = "Attribute may repeat multiple times (treat it as array)"]
7006 DpipeTable(IterableDlDpipeTable<'a>),
7007}
7008impl<'a> IterableDlDpipeTables<'a> {
7009 #[doc = "Attribute may repeat multiple times (treat it as array)"]
7010 pub fn get_dpipe_table(
7011 &self,
7012 ) -> MultiAttrIterable<Self, DlDpipeTables<'a>, IterableDlDpipeTable<'a>> {
7013 MultiAttrIterable::new(self.clone(), |variant| {
7014 if let DlDpipeTables::DpipeTable(val) = variant {
7015 Some(val)
7016 } else {
7017 None
7018 }
7019 })
7020 }
7021}
7022impl DlDpipeTables<'_> {
7023 pub fn new<'a>(buf: &'a [u8]) -> IterableDlDpipeTables<'a> {
7024 IterableDlDpipeTables::with_loc(buf, buf.as_ptr() as usize)
7025 }
7026 fn attr_from_type(r#type: u16) -> Option<&'static str> {
7027 Devlink::attr_from_type(r#type)
7028 }
7029}
7030#[derive(Clone, Copy, Default)]
7031pub struct IterableDlDpipeTables<'a> {
7032 buf: &'a [u8],
7033 pos: usize,
7034 orig_loc: usize,
7035}
7036impl<'a> IterableDlDpipeTables<'a> {
7037 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
7038 Self {
7039 buf,
7040 pos: 0,
7041 orig_loc,
7042 }
7043 }
7044 pub fn get_buf(&self) -> &'a [u8] {
7045 self.buf
7046 }
7047}
7048impl<'a> Iterator for IterableDlDpipeTables<'a> {
7049 type Item = Result<DlDpipeTables<'a>, ErrorContext>;
7050 fn next(&mut self) -> Option<Self::Item> {
7051 let mut pos;
7052 let mut r#type;
7053 loop {
7054 pos = self.pos;
7055 r#type = None;
7056 if self.buf.len() == self.pos {
7057 return None;
7058 }
7059 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
7060 self.pos = self.buf.len();
7061 break;
7062 };
7063 r#type = Some(header.r#type);
7064 let res = match header.r#type {
7065 28u16 => DlDpipeTables::DpipeTable({
7066 let res = Some(IterableDlDpipeTable::with_loc(next, self.orig_loc));
7067 let Some(val) = res else { break };
7068 val
7069 }),
7070 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
7071 n => continue,
7072 };
7073 return Some(Ok(res));
7074 }
7075 Some(Err(ErrorContext::new(
7076 "DlDpipeTables",
7077 r#type.and_then(|t| DlDpipeTables::attr_from_type(t)),
7078 self.orig_loc,
7079 self.buf.as_ptr().wrapping_add(pos) as usize,
7080 )))
7081 }
7082}
7083impl<'a> std::fmt::Debug for IterableDlDpipeTables<'_> {
7084 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7085 let mut fmt = f.debug_struct("DlDpipeTables");
7086 for attr in self.clone() {
7087 let attr = match attr {
7088 Ok(a) => a,
7089 Err(err) => {
7090 fmt.finish()?;
7091 f.write_str("Err(")?;
7092 err.fmt(f)?;
7093 return f.write_str(")");
7094 }
7095 };
7096 match attr {
7097 DlDpipeTables::DpipeTable(val) => fmt.field("DpipeTable", &val),
7098 };
7099 }
7100 fmt.finish()
7101 }
7102}
7103impl IterableDlDpipeTables<'_> {
7104 pub fn lookup_attr(
7105 &self,
7106 offset: usize,
7107 missing_type: Option<u16>,
7108 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
7109 let mut stack = Vec::new();
7110 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
7111 if missing_type.is_some() && cur == offset {
7112 stack.push(("DlDpipeTables", offset));
7113 return (
7114 stack,
7115 missing_type.and_then(|t| DlDpipeTables::attr_from_type(t)),
7116 );
7117 }
7118 if cur > offset || cur + self.buf.len() < offset {
7119 return (stack, None);
7120 }
7121 let mut attrs = self.clone();
7122 let mut last_off = cur + attrs.pos;
7123 let mut missing = None;
7124 while let Some(attr) = attrs.next() {
7125 let Ok(attr) = attr else { break };
7126 match attr {
7127 DlDpipeTables::DpipeTable(val) => {
7128 (stack, missing) = val.lookup_attr(offset, missing_type);
7129 if !stack.is_empty() {
7130 break;
7131 }
7132 }
7133 _ => {}
7134 };
7135 last_off = cur + attrs.pos;
7136 }
7137 if !stack.is_empty() {
7138 stack.push(("DlDpipeTables", cur));
7139 }
7140 (stack, missing)
7141 }
7142}
7143#[derive(Clone)]
7144pub enum DlDpipeTable<'a> {
7145 DpipeTableName(&'a CStr),
7146 DpipeTableSize(u64),
7147 DpipeTableMatches(IterableDlDpipeTableMatches<'a>),
7148 DpipeTableActions(IterableDlDpipeTableActions<'a>),
7149 DpipeTableCountersEnabled(u8),
7150 DpipeTableResourceId(u64),
7151 DpipeTableResourceUnits(u64),
7152}
7153impl<'a> IterableDlDpipeTable<'a> {
7154 pub fn get_dpipe_table_name(&self) -> Result<&'a CStr, ErrorContext> {
7155 let mut iter = self.clone();
7156 iter.pos = 0;
7157 for attr in iter {
7158 if let Ok(DlDpipeTable::DpipeTableName(val)) = attr {
7159 return Ok(val);
7160 }
7161 }
7162 Err(ErrorContext::new_missing(
7163 "DlDpipeTable",
7164 "DpipeTableName",
7165 self.orig_loc,
7166 self.buf.as_ptr() as usize,
7167 ))
7168 }
7169 pub fn get_dpipe_table_size(&self) -> Result<u64, ErrorContext> {
7170 let mut iter = self.clone();
7171 iter.pos = 0;
7172 for attr in iter {
7173 if let Ok(DlDpipeTable::DpipeTableSize(val)) = attr {
7174 return Ok(val);
7175 }
7176 }
7177 Err(ErrorContext::new_missing(
7178 "DlDpipeTable",
7179 "DpipeTableSize",
7180 self.orig_loc,
7181 self.buf.as_ptr() as usize,
7182 ))
7183 }
7184 pub fn get_dpipe_table_matches(&self) -> Result<IterableDlDpipeTableMatches<'a>, ErrorContext> {
7185 let mut iter = self.clone();
7186 iter.pos = 0;
7187 for attr in iter {
7188 if let Ok(DlDpipeTable::DpipeTableMatches(val)) = attr {
7189 return Ok(val);
7190 }
7191 }
7192 Err(ErrorContext::new_missing(
7193 "DlDpipeTable",
7194 "DpipeTableMatches",
7195 self.orig_loc,
7196 self.buf.as_ptr() as usize,
7197 ))
7198 }
7199 pub fn get_dpipe_table_actions(&self) -> Result<IterableDlDpipeTableActions<'a>, ErrorContext> {
7200 let mut iter = self.clone();
7201 iter.pos = 0;
7202 for attr in iter {
7203 if let Ok(DlDpipeTable::DpipeTableActions(val)) = attr {
7204 return Ok(val);
7205 }
7206 }
7207 Err(ErrorContext::new_missing(
7208 "DlDpipeTable",
7209 "DpipeTableActions",
7210 self.orig_loc,
7211 self.buf.as_ptr() as usize,
7212 ))
7213 }
7214 pub fn get_dpipe_table_counters_enabled(&self) -> Result<u8, ErrorContext> {
7215 let mut iter = self.clone();
7216 iter.pos = 0;
7217 for attr in iter {
7218 if let Ok(DlDpipeTable::DpipeTableCountersEnabled(val)) = attr {
7219 return Ok(val);
7220 }
7221 }
7222 Err(ErrorContext::new_missing(
7223 "DlDpipeTable",
7224 "DpipeTableCountersEnabled",
7225 self.orig_loc,
7226 self.buf.as_ptr() as usize,
7227 ))
7228 }
7229 pub fn get_dpipe_table_resource_id(&self) -> Result<u64, ErrorContext> {
7230 let mut iter = self.clone();
7231 iter.pos = 0;
7232 for attr in iter {
7233 if let Ok(DlDpipeTable::DpipeTableResourceId(val)) = attr {
7234 return Ok(val);
7235 }
7236 }
7237 Err(ErrorContext::new_missing(
7238 "DlDpipeTable",
7239 "DpipeTableResourceId",
7240 self.orig_loc,
7241 self.buf.as_ptr() as usize,
7242 ))
7243 }
7244 pub fn get_dpipe_table_resource_units(&self) -> Result<u64, ErrorContext> {
7245 let mut iter = self.clone();
7246 iter.pos = 0;
7247 for attr in iter {
7248 if let Ok(DlDpipeTable::DpipeTableResourceUnits(val)) = attr {
7249 return Ok(val);
7250 }
7251 }
7252 Err(ErrorContext::new_missing(
7253 "DlDpipeTable",
7254 "DpipeTableResourceUnits",
7255 self.orig_loc,
7256 self.buf.as_ptr() as usize,
7257 ))
7258 }
7259}
7260impl DlDpipeTable<'_> {
7261 pub fn new<'a>(buf: &'a [u8]) -> IterableDlDpipeTable<'a> {
7262 IterableDlDpipeTable::with_loc(buf, buf.as_ptr() as usize)
7263 }
7264 fn attr_from_type(r#type: u16) -> Option<&'static str> {
7265 Devlink::attr_from_type(r#type)
7266 }
7267}
7268#[derive(Clone, Copy, Default)]
7269pub struct IterableDlDpipeTable<'a> {
7270 buf: &'a [u8],
7271 pos: usize,
7272 orig_loc: usize,
7273}
7274impl<'a> IterableDlDpipeTable<'a> {
7275 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
7276 Self {
7277 buf,
7278 pos: 0,
7279 orig_loc,
7280 }
7281 }
7282 pub fn get_buf(&self) -> &'a [u8] {
7283 self.buf
7284 }
7285}
7286impl<'a> Iterator for IterableDlDpipeTable<'a> {
7287 type Item = Result<DlDpipeTable<'a>, ErrorContext>;
7288 fn next(&mut self) -> Option<Self::Item> {
7289 let mut pos;
7290 let mut r#type;
7291 loop {
7292 pos = self.pos;
7293 r#type = None;
7294 if self.buf.len() == self.pos {
7295 return None;
7296 }
7297 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
7298 self.pos = self.buf.len();
7299 break;
7300 };
7301 r#type = Some(header.r#type);
7302 let res = match header.r#type {
7303 29u16 => DlDpipeTable::DpipeTableName({
7304 let res = CStr::from_bytes_with_nul(next).ok();
7305 let Some(val) = res else { break };
7306 val
7307 }),
7308 30u16 => DlDpipeTable::DpipeTableSize({
7309 let res = parse_u64(next);
7310 let Some(val) = res else { break };
7311 val
7312 }),
7313 31u16 => DlDpipeTable::DpipeTableMatches({
7314 let res = Some(IterableDlDpipeTableMatches::with_loc(next, self.orig_loc));
7315 let Some(val) = res else { break };
7316 val
7317 }),
7318 32u16 => DlDpipeTable::DpipeTableActions({
7319 let res = Some(IterableDlDpipeTableActions::with_loc(next, self.orig_loc));
7320 let Some(val) = res else { break };
7321 val
7322 }),
7323 33u16 => DlDpipeTable::DpipeTableCountersEnabled({
7324 let res = parse_u8(next);
7325 let Some(val) = res else { break };
7326 val
7327 }),
7328 75u16 => DlDpipeTable::DpipeTableResourceId({
7329 let res = parse_u64(next);
7330 let Some(val) = res else { break };
7331 val
7332 }),
7333 76u16 => DlDpipeTable::DpipeTableResourceUnits({
7334 let res = parse_u64(next);
7335 let Some(val) = res else { break };
7336 val
7337 }),
7338 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
7339 n => continue,
7340 };
7341 return Some(Ok(res));
7342 }
7343 Some(Err(ErrorContext::new(
7344 "DlDpipeTable",
7345 r#type.and_then(|t| DlDpipeTable::attr_from_type(t)),
7346 self.orig_loc,
7347 self.buf.as_ptr().wrapping_add(pos) as usize,
7348 )))
7349 }
7350}
7351impl<'a> std::fmt::Debug for IterableDlDpipeTable<'_> {
7352 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7353 let mut fmt = f.debug_struct("DlDpipeTable");
7354 for attr in self.clone() {
7355 let attr = match attr {
7356 Ok(a) => a,
7357 Err(err) => {
7358 fmt.finish()?;
7359 f.write_str("Err(")?;
7360 err.fmt(f)?;
7361 return f.write_str(")");
7362 }
7363 };
7364 match attr {
7365 DlDpipeTable::DpipeTableName(val) => fmt.field("DpipeTableName", &val),
7366 DlDpipeTable::DpipeTableSize(val) => fmt.field("DpipeTableSize", &val),
7367 DlDpipeTable::DpipeTableMatches(val) => fmt.field("DpipeTableMatches", &val),
7368 DlDpipeTable::DpipeTableActions(val) => fmt.field("DpipeTableActions", &val),
7369 DlDpipeTable::DpipeTableCountersEnabled(val) => {
7370 fmt.field("DpipeTableCountersEnabled", &val)
7371 }
7372 DlDpipeTable::DpipeTableResourceId(val) => fmt.field("DpipeTableResourceId", &val),
7373 DlDpipeTable::DpipeTableResourceUnits(val) => {
7374 fmt.field("DpipeTableResourceUnits", &val)
7375 }
7376 };
7377 }
7378 fmt.finish()
7379 }
7380}
7381impl IterableDlDpipeTable<'_> {
7382 pub fn lookup_attr(
7383 &self,
7384 offset: usize,
7385 missing_type: Option<u16>,
7386 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
7387 let mut stack = Vec::new();
7388 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
7389 if missing_type.is_some() && cur == offset {
7390 stack.push(("DlDpipeTable", offset));
7391 return (
7392 stack,
7393 missing_type.and_then(|t| DlDpipeTable::attr_from_type(t)),
7394 );
7395 }
7396 if cur > offset || cur + self.buf.len() < offset {
7397 return (stack, None);
7398 }
7399 let mut attrs = self.clone();
7400 let mut last_off = cur + attrs.pos;
7401 let mut missing = None;
7402 while let Some(attr) = attrs.next() {
7403 let Ok(attr) = attr else { break };
7404 match attr {
7405 DlDpipeTable::DpipeTableName(val) => {
7406 if last_off == offset {
7407 stack.push(("DpipeTableName", last_off));
7408 break;
7409 }
7410 }
7411 DlDpipeTable::DpipeTableSize(val) => {
7412 if last_off == offset {
7413 stack.push(("DpipeTableSize", last_off));
7414 break;
7415 }
7416 }
7417 DlDpipeTable::DpipeTableMatches(val) => {
7418 (stack, missing) = val.lookup_attr(offset, missing_type);
7419 if !stack.is_empty() {
7420 break;
7421 }
7422 }
7423 DlDpipeTable::DpipeTableActions(val) => {
7424 (stack, missing) = val.lookup_attr(offset, missing_type);
7425 if !stack.is_empty() {
7426 break;
7427 }
7428 }
7429 DlDpipeTable::DpipeTableCountersEnabled(val) => {
7430 if last_off == offset {
7431 stack.push(("DpipeTableCountersEnabled", last_off));
7432 break;
7433 }
7434 }
7435 DlDpipeTable::DpipeTableResourceId(val) => {
7436 if last_off == offset {
7437 stack.push(("DpipeTableResourceId", last_off));
7438 break;
7439 }
7440 }
7441 DlDpipeTable::DpipeTableResourceUnits(val) => {
7442 if last_off == offset {
7443 stack.push(("DpipeTableResourceUnits", last_off));
7444 break;
7445 }
7446 }
7447 _ => {}
7448 };
7449 last_off = cur + attrs.pos;
7450 }
7451 if !stack.is_empty() {
7452 stack.push(("DlDpipeTable", cur));
7453 }
7454 (stack, missing)
7455 }
7456}
7457#[derive(Clone)]
7458pub enum DlDpipeTableMatches<'a> {
7459 #[doc = "Attribute may repeat multiple times (treat it as array)"]
7460 DpipeMatch(IterableDlDpipeMatch<'a>),
7461}
7462impl<'a> IterableDlDpipeTableMatches<'a> {
7463 #[doc = "Attribute may repeat multiple times (treat it as array)"]
7464 pub fn get_dpipe_match(
7465 &self,
7466 ) -> MultiAttrIterable<Self, DlDpipeTableMatches<'a>, IterableDlDpipeMatch<'a>> {
7467 MultiAttrIterable::new(self.clone(), |variant| {
7468 if let DlDpipeTableMatches::DpipeMatch(val) = variant {
7469 Some(val)
7470 } else {
7471 None
7472 }
7473 })
7474 }
7475}
7476impl DlDpipeTableMatches<'_> {
7477 pub fn new<'a>(buf: &'a [u8]) -> IterableDlDpipeTableMatches<'a> {
7478 IterableDlDpipeTableMatches::with_loc(buf, buf.as_ptr() as usize)
7479 }
7480 fn attr_from_type(r#type: u16) -> Option<&'static str> {
7481 Devlink::attr_from_type(r#type)
7482 }
7483}
7484#[derive(Clone, Copy, Default)]
7485pub struct IterableDlDpipeTableMatches<'a> {
7486 buf: &'a [u8],
7487 pos: usize,
7488 orig_loc: usize,
7489}
7490impl<'a> IterableDlDpipeTableMatches<'a> {
7491 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
7492 Self {
7493 buf,
7494 pos: 0,
7495 orig_loc,
7496 }
7497 }
7498 pub fn get_buf(&self) -> &'a [u8] {
7499 self.buf
7500 }
7501}
7502impl<'a> Iterator for IterableDlDpipeTableMatches<'a> {
7503 type Item = Result<DlDpipeTableMatches<'a>, ErrorContext>;
7504 fn next(&mut self) -> Option<Self::Item> {
7505 let mut pos;
7506 let mut r#type;
7507 loop {
7508 pos = self.pos;
7509 r#type = None;
7510 if self.buf.len() == self.pos {
7511 return None;
7512 }
7513 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
7514 self.pos = self.buf.len();
7515 break;
7516 };
7517 r#type = Some(header.r#type);
7518 let res = match header.r#type {
7519 40u16 => DlDpipeTableMatches::DpipeMatch({
7520 let res = Some(IterableDlDpipeMatch::with_loc(next, self.orig_loc));
7521 let Some(val) = res else { break };
7522 val
7523 }),
7524 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
7525 n => continue,
7526 };
7527 return Some(Ok(res));
7528 }
7529 Some(Err(ErrorContext::new(
7530 "DlDpipeTableMatches",
7531 r#type.and_then(|t| DlDpipeTableMatches::attr_from_type(t)),
7532 self.orig_loc,
7533 self.buf.as_ptr().wrapping_add(pos) as usize,
7534 )))
7535 }
7536}
7537impl<'a> std::fmt::Debug for IterableDlDpipeTableMatches<'_> {
7538 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7539 let mut fmt = f.debug_struct("DlDpipeTableMatches");
7540 for attr in self.clone() {
7541 let attr = match attr {
7542 Ok(a) => a,
7543 Err(err) => {
7544 fmt.finish()?;
7545 f.write_str("Err(")?;
7546 err.fmt(f)?;
7547 return f.write_str(")");
7548 }
7549 };
7550 match attr {
7551 DlDpipeTableMatches::DpipeMatch(val) => fmt.field("DpipeMatch", &val),
7552 };
7553 }
7554 fmt.finish()
7555 }
7556}
7557impl IterableDlDpipeTableMatches<'_> {
7558 pub fn lookup_attr(
7559 &self,
7560 offset: usize,
7561 missing_type: Option<u16>,
7562 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
7563 let mut stack = Vec::new();
7564 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
7565 if missing_type.is_some() && cur == offset {
7566 stack.push(("DlDpipeTableMatches", offset));
7567 return (
7568 stack,
7569 missing_type.and_then(|t| DlDpipeTableMatches::attr_from_type(t)),
7570 );
7571 }
7572 if cur > offset || cur + self.buf.len() < offset {
7573 return (stack, None);
7574 }
7575 let mut attrs = self.clone();
7576 let mut last_off = cur + attrs.pos;
7577 let mut missing = None;
7578 while let Some(attr) = attrs.next() {
7579 let Ok(attr) = attr else { break };
7580 match attr {
7581 DlDpipeTableMatches::DpipeMatch(val) => {
7582 (stack, missing) = val.lookup_attr(offset, missing_type);
7583 if !stack.is_empty() {
7584 break;
7585 }
7586 }
7587 _ => {}
7588 };
7589 last_off = cur + attrs.pos;
7590 }
7591 if !stack.is_empty() {
7592 stack.push(("DlDpipeTableMatches", cur));
7593 }
7594 (stack, missing)
7595 }
7596}
7597#[derive(Clone)]
7598pub enum DlDpipeTableActions<'a> {
7599 #[doc = "Attribute may repeat multiple times (treat it as array)"]
7600 DpipeAction(IterableDlDpipeAction<'a>),
7601}
7602impl<'a> IterableDlDpipeTableActions<'a> {
7603 #[doc = "Attribute may repeat multiple times (treat it as array)"]
7604 pub fn get_dpipe_action(
7605 &self,
7606 ) -> MultiAttrIterable<Self, DlDpipeTableActions<'a>, IterableDlDpipeAction<'a>> {
7607 MultiAttrIterable::new(self.clone(), |variant| {
7608 if let DlDpipeTableActions::DpipeAction(val) = variant {
7609 Some(val)
7610 } else {
7611 None
7612 }
7613 })
7614 }
7615}
7616impl DlDpipeTableActions<'_> {
7617 pub fn new<'a>(buf: &'a [u8]) -> IterableDlDpipeTableActions<'a> {
7618 IterableDlDpipeTableActions::with_loc(buf, buf.as_ptr() as usize)
7619 }
7620 fn attr_from_type(r#type: u16) -> Option<&'static str> {
7621 Devlink::attr_from_type(r#type)
7622 }
7623}
7624#[derive(Clone, Copy, Default)]
7625pub struct IterableDlDpipeTableActions<'a> {
7626 buf: &'a [u8],
7627 pos: usize,
7628 orig_loc: usize,
7629}
7630impl<'a> IterableDlDpipeTableActions<'a> {
7631 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
7632 Self {
7633 buf,
7634 pos: 0,
7635 orig_loc,
7636 }
7637 }
7638 pub fn get_buf(&self) -> &'a [u8] {
7639 self.buf
7640 }
7641}
7642impl<'a> Iterator for IterableDlDpipeTableActions<'a> {
7643 type Item = Result<DlDpipeTableActions<'a>, ErrorContext>;
7644 fn next(&mut self) -> Option<Self::Item> {
7645 let mut pos;
7646 let mut r#type;
7647 loop {
7648 pos = self.pos;
7649 r#type = None;
7650 if self.buf.len() == self.pos {
7651 return None;
7652 }
7653 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
7654 self.pos = self.buf.len();
7655 break;
7656 };
7657 r#type = Some(header.r#type);
7658 let res = match header.r#type {
7659 43u16 => DlDpipeTableActions::DpipeAction({
7660 let res = Some(IterableDlDpipeAction::with_loc(next, self.orig_loc));
7661 let Some(val) = res else { break };
7662 val
7663 }),
7664 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
7665 n => continue,
7666 };
7667 return Some(Ok(res));
7668 }
7669 Some(Err(ErrorContext::new(
7670 "DlDpipeTableActions",
7671 r#type.and_then(|t| DlDpipeTableActions::attr_from_type(t)),
7672 self.orig_loc,
7673 self.buf.as_ptr().wrapping_add(pos) as usize,
7674 )))
7675 }
7676}
7677impl<'a> std::fmt::Debug for IterableDlDpipeTableActions<'_> {
7678 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7679 let mut fmt = f.debug_struct("DlDpipeTableActions");
7680 for attr in self.clone() {
7681 let attr = match attr {
7682 Ok(a) => a,
7683 Err(err) => {
7684 fmt.finish()?;
7685 f.write_str("Err(")?;
7686 err.fmt(f)?;
7687 return f.write_str(")");
7688 }
7689 };
7690 match attr {
7691 DlDpipeTableActions::DpipeAction(val) => fmt.field("DpipeAction", &val),
7692 };
7693 }
7694 fmt.finish()
7695 }
7696}
7697impl IterableDlDpipeTableActions<'_> {
7698 pub fn lookup_attr(
7699 &self,
7700 offset: usize,
7701 missing_type: Option<u16>,
7702 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
7703 let mut stack = Vec::new();
7704 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
7705 if missing_type.is_some() && cur == offset {
7706 stack.push(("DlDpipeTableActions", offset));
7707 return (
7708 stack,
7709 missing_type.and_then(|t| DlDpipeTableActions::attr_from_type(t)),
7710 );
7711 }
7712 if cur > offset || cur + self.buf.len() < offset {
7713 return (stack, None);
7714 }
7715 let mut attrs = self.clone();
7716 let mut last_off = cur + attrs.pos;
7717 let mut missing = None;
7718 while let Some(attr) = attrs.next() {
7719 let Ok(attr) = attr else { break };
7720 match attr {
7721 DlDpipeTableActions::DpipeAction(val) => {
7722 (stack, missing) = val.lookup_attr(offset, missing_type);
7723 if !stack.is_empty() {
7724 break;
7725 }
7726 }
7727 _ => {}
7728 };
7729 last_off = cur + attrs.pos;
7730 }
7731 if !stack.is_empty() {
7732 stack.push(("DlDpipeTableActions", cur));
7733 }
7734 (stack, missing)
7735 }
7736}
7737#[derive(Clone)]
7738pub enum DlDpipeEntries<'a> {
7739 #[doc = "Attribute may repeat multiple times (treat it as array)"]
7740 DpipeEntry(IterableDlDpipeEntry<'a>),
7741}
7742impl<'a> IterableDlDpipeEntries<'a> {
7743 #[doc = "Attribute may repeat multiple times (treat it as array)"]
7744 pub fn get_dpipe_entry(
7745 &self,
7746 ) -> MultiAttrIterable<Self, DlDpipeEntries<'a>, IterableDlDpipeEntry<'a>> {
7747 MultiAttrIterable::new(self.clone(), |variant| {
7748 if let DlDpipeEntries::DpipeEntry(val) = variant {
7749 Some(val)
7750 } else {
7751 None
7752 }
7753 })
7754 }
7755}
7756impl DlDpipeEntries<'_> {
7757 pub fn new<'a>(buf: &'a [u8]) -> IterableDlDpipeEntries<'a> {
7758 IterableDlDpipeEntries::with_loc(buf, buf.as_ptr() as usize)
7759 }
7760 fn attr_from_type(r#type: u16) -> Option<&'static str> {
7761 Devlink::attr_from_type(r#type)
7762 }
7763}
7764#[derive(Clone, Copy, Default)]
7765pub struct IterableDlDpipeEntries<'a> {
7766 buf: &'a [u8],
7767 pos: usize,
7768 orig_loc: usize,
7769}
7770impl<'a> IterableDlDpipeEntries<'a> {
7771 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
7772 Self {
7773 buf,
7774 pos: 0,
7775 orig_loc,
7776 }
7777 }
7778 pub fn get_buf(&self) -> &'a [u8] {
7779 self.buf
7780 }
7781}
7782impl<'a> Iterator for IterableDlDpipeEntries<'a> {
7783 type Item = Result<DlDpipeEntries<'a>, ErrorContext>;
7784 fn next(&mut self) -> Option<Self::Item> {
7785 let mut pos;
7786 let mut r#type;
7787 loop {
7788 pos = self.pos;
7789 r#type = None;
7790 if self.buf.len() == self.pos {
7791 return None;
7792 }
7793 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
7794 self.pos = self.buf.len();
7795 break;
7796 };
7797 r#type = Some(header.r#type);
7798 let res = match header.r#type {
7799 35u16 => DlDpipeEntries::DpipeEntry({
7800 let res = Some(IterableDlDpipeEntry::with_loc(next, self.orig_loc));
7801 let Some(val) = res else { break };
7802 val
7803 }),
7804 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
7805 n => continue,
7806 };
7807 return Some(Ok(res));
7808 }
7809 Some(Err(ErrorContext::new(
7810 "DlDpipeEntries",
7811 r#type.and_then(|t| DlDpipeEntries::attr_from_type(t)),
7812 self.orig_loc,
7813 self.buf.as_ptr().wrapping_add(pos) as usize,
7814 )))
7815 }
7816}
7817impl<'a> std::fmt::Debug for IterableDlDpipeEntries<'_> {
7818 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7819 let mut fmt = f.debug_struct("DlDpipeEntries");
7820 for attr in self.clone() {
7821 let attr = match attr {
7822 Ok(a) => a,
7823 Err(err) => {
7824 fmt.finish()?;
7825 f.write_str("Err(")?;
7826 err.fmt(f)?;
7827 return f.write_str(")");
7828 }
7829 };
7830 match attr {
7831 DlDpipeEntries::DpipeEntry(val) => fmt.field("DpipeEntry", &val),
7832 };
7833 }
7834 fmt.finish()
7835 }
7836}
7837impl IterableDlDpipeEntries<'_> {
7838 pub fn lookup_attr(
7839 &self,
7840 offset: usize,
7841 missing_type: Option<u16>,
7842 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
7843 let mut stack = Vec::new();
7844 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
7845 if missing_type.is_some() && cur == offset {
7846 stack.push(("DlDpipeEntries", offset));
7847 return (
7848 stack,
7849 missing_type.and_then(|t| DlDpipeEntries::attr_from_type(t)),
7850 );
7851 }
7852 if cur > offset || cur + self.buf.len() < offset {
7853 return (stack, None);
7854 }
7855 let mut attrs = self.clone();
7856 let mut last_off = cur + attrs.pos;
7857 let mut missing = None;
7858 while let Some(attr) = attrs.next() {
7859 let Ok(attr) = attr else { break };
7860 match attr {
7861 DlDpipeEntries::DpipeEntry(val) => {
7862 (stack, missing) = val.lookup_attr(offset, missing_type);
7863 if !stack.is_empty() {
7864 break;
7865 }
7866 }
7867 _ => {}
7868 };
7869 last_off = cur + attrs.pos;
7870 }
7871 if !stack.is_empty() {
7872 stack.push(("DlDpipeEntries", cur));
7873 }
7874 (stack, missing)
7875 }
7876}
7877#[derive(Clone)]
7878pub enum DlDpipeEntry<'a> {
7879 DpipeEntryIndex(u64),
7880 DpipeEntryMatchValues(IterableDlDpipeEntryMatchValues<'a>),
7881 DpipeEntryActionValues(IterableDlDpipeEntryActionValues<'a>),
7882 DpipeEntryCounter(u64),
7883}
7884impl<'a> IterableDlDpipeEntry<'a> {
7885 pub fn get_dpipe_entry_index(&self) -> Result<u64, ErrorContext> {
7886 let mut iter = self.clone();
7887 iter.pos = 0;
7888 for attr in iter {
7889 if let Ok(DlDpipeEntry::DpipeEntryIndex(val)) = attr {
7890 return Ok(val);
7891 }
7892 }
7893 Err(ErrorContext::new_missing(
7894 "DlDpipeEntry",
7895 "DpipeEntryIndex",
7896 self.orig_loc,
7897 self.buf.as_ptr() as usize,
7898 ))
7899 }
7900 pub fn get_dpipe_entry_match_values(
7901 &self,
7902 ) -> Result<IterableDlDpipeEntryMatchValues<'a>, ErrorContext> {
7903 let mut iter = self.clone();
7904 iter.pos = 0;
7905 for attr in iter {
7906 if let Ok(DlDpipeEntry::DpipeEntryMatchValues(val)) = attr {
7907 return Ok(val);
7908 }
7909 }
7910 Err(ErrorContext::new_missing(
7911 "DlDpipeEntry",
7912 "DpipeEntryMatchValues",
7913 self.orig_loc,
7914 self.buf.as_ptr() as usize,
7915 ))
7916 }
7917 pub fn get_dpipe_entry_action_values(
7918 &self,
7919 ) -> Result<IterableDlDpipeEntryActionValues<'a>, ErrorContext> {
7920 let mut iter = self.clone();
7921 iter.pos = 0;
7922 for attr in iter {
7923 if let Ok(DlDpipeEntry::DpipeEntryActionValues(val)) = attr {
7924 return Ok(val);
7925 }
7926 }
7927 Err(ErrorContext::new_missing(
7928 "DlDpipeEntry",
7929 "DpipeEntryActionValues",
7930 self.orig_loc,
7931 self.buf.as_ptr() as usize,
7932 ))
7933 }
7934 pub fn get_dpipe_entry_counter(&self) -> Result<u64, ErrorContext> {
7935 let mut iter = self.clone();
7936 iter.pos = 0;
7937 for attr in iter {
7938 if let Ok(DlDpipeEntry::DpipeEntryCounter(val)) = attr {
7939 return Ok(val);
7940 }
7941 }
7942 Err(ErrorContext::new_missing(
7943 "DlDpipeEntry",
7944 "DpipeEntryCounter",
7945 self.orig_loc,
7946 self.buf.as_ptr() as usize,
7947 ))
7948 }
7949}
7950impl DlDpipeEntry<'_> {
7951 pub fn new<'a>(buf: &'a [u8]) -> IterableDlDpipeEntry<'a> {
7952 IterableDlDpipeEntry::with_loc(buf, buf.as_ptr() as usize)
7953 }
7954 fn attr_from_type(r#type: u16) -> Option<&'static str> {
7955 Devlink::attr_from_type(r#type)
7956 }
7957}
7958#[derive(Clone, Copy, Default)]
7959pub struct IterableDlDpipeEntry<'a> {
7960 buf: &'a [u8],
7961 pos: usize,
7962 orig_loc: usize,
7963}
7964impl<'a> IterableDlDpipeEntry<'a> {
7965 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
7966 Self {
7967 buf,
7968 pos: 0,
7969 orig_loc,
7970 }
7971 }
7972 pub fn get_buf(&self) -> &'a [u8] {
7973 self.buf
7974 }
7975}
7976impl<'a> Iterator for IterableDlDpipeEntry<'a> {
7977 type Item = Result<DlDpipeEntry<'a>, ErrorContext>;
7978 fn next(&mut self) -> Option<Self::Item> {
7979 let mut pos;
7980 let mut r#type;
7981 loop {
7982 pos = self.pos;
7983 r#type = None;
7984 if self.buf.len() == self.pos {
7985 return None;
7986 }
7987 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
7988 self.pos = self.buf.len();
7989 break;
7990 };
7991 r#type = Some(header.r#type);
7992 let res = match header.r#type {
7993 36u16 => DlDpipeEntry::DpipeEntryIndex({
7994 let res = parse_u64(next);
7995 let Some(val) = res else { break };
7996 val
7997 }),
7998 37u16 => DlDpipeEntry::DpipeEntryMatchValues({
7999 let res = Some(IterableDlDpipeEntryMatchValues::with_loc(
8000 next,
8001 self.orig_loc,
8002 ));
8003 let Some(val) = res else { break };
8004 val
8005 }),
8006 38u16 => DlDpipeEntry::DpipeEntryActionValues({
8007 let res = Some(IterableDlDpipeEntryActionValues::with_loc(
8008 next,
8009 self.orig_loc,
8010 ));
8011 let Some(val) = res else { break };
8012 val
8013 }),
8014 39u16 => DlDpipeEntry::DpipeEntryCounter({
8015 let res = parse_u64(next);
8016 let Some(val) = res else { break };
8017 val
8018 }),
8019 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
8020 n => continue,
8021 };
8022 return Some(Ok(res));
8023 }
8024 Some(Err(ErrorContext::new(
8025 "DlDpipeEntry",
8026 r#type.and_then(|t| DlDpipeEntry::attr_from_type(t)),
8027 self.orig_loc,
8028 self.buf.as_ptr().wrapping_add(pos) as usize,
8029 )))
8030 }
8031}
8032impl<'a> std::fmt::Debug for IterableDlDpipeEntry<'_> {
8033 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8034 let mut fmt = f.debug_struct("DlDpipeEntry");
8035 for attr in self.clone() {
8036 let attr = match attr {
8037 Ok(a) => a,
8038 Err(err) => {
8039 fmt.finish()?;
8040 f.write_str("Err(")?;
8041 err.fmt(f)?;
8042 return f.write_str(")");
8043 }
8044 };
8045 match attr {
8046 DlDpipeEntry::DpipeEntryIndex(val) => fmt.field("DpipeEntryIndex", &val),
8047 DlDpipeEntry::DpipeEntryMatchValues(val) => {
8048 fmt.field("DpipeEntryMatchValues", &val)
8049 }
8050 DlDpipeEntry::DpipeEntryActionValues(val) => {
8051 fmt.field("DpipeEntryActionValues", &val)
8052 }
8053 DlDpipeEntry::DpipeEntryCounter(val) => fmt.field("DpipeEntryCounter", &val),
8054 };
8055 }
8056 fmt.finish()
8057 }
8058}
8059impl IterableDlDpipeEntry<'_> {
8060 pub fn lookup_attr(
8061 &self,
8062 offset: usize,
8063 missing_type: Option<u16>,
8064 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
8065 let mut stack = Vec::new();
8066 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
8067 if missing_type.is_some() && cur == offset {
8068 stack.push(("DlDpipeEntry", offset));
8069 return (
8070 stack,
8071 missing_type.and_then(|t| DlDpipeEntry::attr_from_type(t)),
8072 );
8073 }
8074 if cur > offset || cur + self.buf.len() < offset {
8075 return (stack, None);
8076 }
8077 let mut attrs = self.clone();
8078 let mut last_off = cur + attrs.pos;
8079 let mut missing = None;
8080 while let Some(attr) = attrs.next() {
8081 let Ok(attr) = attr else { break };
8082 match attr {
8083 DlDpipeEntry::DpipeEntryIndex(val) => {
8084 if last_off == offset {
8085 stack.push(("DpipeEntryIndex", last_off));
8086 break;
8087 }
8088 }
8089 DlDpipeEntry::DpipeEntryMatchValues(val) => {
8090 (stack, missing) = val.lookup_attr(offset, missing_type);
8091 if !stack.is_empty() {
8092 break;
8093 }
8094 }
8095 DlDpipeEntry::DpipeEntryActionValues(val) => {
8096 (stack, missing) = val.lookup_attr(offset, missing_type);
8097 if !stack.is_empty() {
8098 break;
8099 }
8100 }
8101 DlDpipeEntry::DpipeEntryCounter(val) => {
8102 if last_off == offset {
8103 stack.push(("DpipeEntryCounter", last_off));
8104 break;
8105 }
8106 }
8107 _ => {}
8108 };
8109 last_off = cur + attrs.pos;
8110 }
8111 if !stack.is_empty() {
8112 stack.push(("DlDpipeEntry", cur));
8113 }
8114 (stack, missing)
8115 }
8116}
8117#[derive(Clone)]
8118pub enum DlDpipeEntryMatchValues<'a> {
8119 #[doc = "Attribute may repeat multiple times (treat it as array)"]
8120 DpipeMatchValue(IterableDlDpipeMatchValue<'a>),
8121}
8122impl<'a> IterableDlDpipeEntryMatchValues<'a> {
8123 #[doc = "Attribute may repeat multiple times (treat it as array)"]
8124 pub fn get_dpipe_match_value(
8125 &self,
8126 ) -> MultiAttrIterable<Self, DlDpipeEntryMatchValues<'a>, IterableDlDpipeMatchValue<'a>> {
8127 MultiAttrIterable::new(self.clone(), |variant| {
8128 if let DlDpipeEntryMatchValues::DpipeMatchValue(val) = variant {
8129 Some(val)
8130 } else {
8131 None
8132 }
8133 })
8134 }
8135}
8136impl DlDpipeEntryMatchValues<'_> {
8137 pub fn new<'a>(buf: &'a [u8]) -> IterableDlDpipeEntryMatchValues<'a> {
8138 IterableDlDpipeEntryMatchValues::with_loc(buf, buf.as_ptr() as usize)
8139 }
8140 fn attr_from_type(r#type: u16) -> Option<&'static str> {
8141 Devlink::attr_from_type(r#type)
8142 }
8143}
8144#[derive(Clone, Copy, Default)]
8145pub struct IterableDlDpipeEntryMatchValues<'a> {
8146 buf: &'a [u8],
8147 pos: usize,
8148 orig_loc: usize,
8149}
8150impl<'a> IterableDlDpipeEntryMatchValues<'a> {
8151 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
8152 Self {
8153 buf,
8154 pos: 0,
8155 orig_loc,
8156 }
8157 }
8158 pub fn get_buf(&self) -> &'a [u8] {
8159 self.buf
8160 }
8161}
8162impl<'a> Iterator for IterableDlDpipeEntryMatchValues<'a> {
8163 type Item = Result<DlDpipeEntryMatchValues<'a>, ErrorContext>;
8164 fn next(&mut self) -> Option<Self::Item> {
8165 let mut pos;
8166 let mut r#type;
8167 loop {
8168 pos = self.pos;
8169 r#type = None;
8170 if self.buf.len() == self.pos {
8171 return None;
8172 }
8173 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
8174 self.pos = self.buf.len();
8175 break;
8176 };
8177 r#type = Some(header.r#type);
8178 let res = match header.r#type {
8179 41u16 => DlDpipeEntryMatchValues::DpipeMatchValue({
8180 let res = Some(IterableDlDpipeMatchValue::with_loc(next, self.orig_loc));
8181 let Some(val) = res else { break };
8182 val
8183 }),
8184 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
8185 n => continue,
8186 };
8187 return Some(Ok(res));
8188 }
8189 Some(Err(ErrorContext::new(
8190 "DlDpipeEntryMatchValues",
8191 r#type.and_then(|t| DlDpipeEntryMatchValues::attr_from_type(t)),
8192 self.orig_loc,
8193 self.buf.as_ptr().wrapping_add(pos) as usize,
8194 )))
8195 }
8196}
8197impl<'a> std::fmt::Debug for IterableDlDpipeEntryMatchValues<'_> {
8198 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8199 let mut fmt = f.debug_struct("DlDpipeEntryMatchValues");
8200 for attr in self.clone() {
8201 let attr = match attr {
8202 Ok(a) => a,
8203 Err(err) => {
8204 fmt.finish()?;
8205 f.write_str("Err(")?;
8206 err.fmt(f)?;
8207 return f.write_str(")");
8208 }
8209 };
8210 match attr {
8211 DlDpipeEntryMatchValues::DpipeMatchValue(val) => fmt.field("DpipeMatchValue", &val),
8212 };
8213 }
8214 fmt.finish()
8215 }
8216}
8217impl IterableDlDpipeEntryMatchValues<'_> {
8218 pub fn lookup_attr(
8219 &self,
8220 offset: usize,
8221 missing_type: Option<u16>,
8222 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
8223 let mut stack = Vec::new();
8224 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
8225 if missing_type.is_some() && cur == offset {
8226 stack.push(("DlDpipeEntryMatchValues", offset));
8227 return (
8228 stack,
8229 missing_type.and_then(|t| DlDpipeEntryMatchValues::attr_from_type(t)),
8230 );
8231 }
8232 if cur > offset || cur + self.buf.len() < offset {
8233 return (stack, None);
8234 }
8235 let mut attrs = self.clone();
8236 let mut last_off = cur + attrs.pos;
8237 let mut missing = None;
8238 while let Some(attr) = attrs.next() {
8239 let Ok(attr) = attr else { break };
8240 match attr {
8241 DlDpipeEntryMatchValues::DpipeMatchValue(val) => {
8242 (stack, missing) = val.lookup_attr(offset, missing_type);
8243 if !stack.is_empty() {
8244 break;
8245 }
8246 }
8247 _ => {}
8248 };
8249 last_off = cur + attrs.pos;
8250 }
8251 if !stack.is_empty() {
8252 stack.push(("DlDpipeEntryMatchValues", cur));
8253 }
8254 (stack, missing)
8255 }
8256}
8257#[derive(Clone)]
8258pub enum DlDpipeEntryActionValues<'a> {
8259 #[doc = "Attribute may repeat multiple times (treat it as array)"]
8260 DpipeActionValue(IterableDlDpipeActionValue<'a>),
8261}
8262impl<'a> IterableDlDpipeEntryActionValues<'a> {
8263 #[doc = "Attribute may repeat multiple times (treat it as array)"]
8264 pub fn get_dpipe_action_value(
8265 &self,
8266 ) -> MultiAttrIterable<Self, DlDpipeEntryActionValues<'a>, IterableDlDpipeActionValue<'a>> {
8267 MultiAttrIterable::new(self.clone(), |variant| {
8268 if let DlDpipeEntryActionValues::DpipeActionValue(val) = variant {
8269 Some(val)
8270 } else {
8271 None
8272 }
8273 })
8274 }
8275}
8276impl DlDpipeEntryActionValues<'_> {
8277 pub fn new<'a>(buf: &'a [u8]) -> IterableDlDpipeEntryActionValues<'a> {
8278 IterableDlDpipeEntryActionValues::with_loc(buf, buf.as_ptr() as usize)
8279 }
8280 fn attr_from_type(r#type: u16) -> Option<&'static str> {
8281 Devlink::attr_from_type(r#type)
8282 }
8283}
8284#[derive(Clone, Copy, Default)]
8285pub struct IterableDlDpipeEntryActionValues<'a> {
8286 buf: &'a [u8],
8287 pos: usize,
8288 orig_loc: usize,
8289}
8290impl<'a> IterableDlDpipeEntryActionValues<'a> {
8291 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
8292 Self {
8293 buf,
8294 pos: 0,
8295 orig_loc,
8296 }
8297 }
8298 pub fn get_buf(&self) -> &'a [u8] {
8299 self.buf
8300 }
8301}
8302impl<'a> Iterator for IterableDlDpipeEntryActionValues<'a> {
8303 type Item = Result<DlDpipeEntryActionValues<'a>, ErrorContext>;
8304 fn next(&mut self) -> Option<Self::Item> {
8305 let mut pos;
8306 let mut r#type;
8307 loop {
8308 pos = self.pos;
8309 r#type = None;
8310 if self.buf.len() == self.pos {
8311 return None;
8312 }
8313 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
8314 self.pos = self.buf.len();
8315 break;
8316 };
8317 r#type = Some(header.r#type);
8318 let res = match header.r#type {
8319 44u16 => DlDpipeEntryActionValues::DpipeActionValue({
8320 let res = Some(IterableDlDpipeActionValue::with_loc(next, self.orig_loc));
8321 let Some(val) = res else { break };
8322 val
8323 }),
8324 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
8325 n => continue,
8326 };
8327 return Some(Ok(res));
8328 }
8329 Some(Err(ErrorContext::new(
8330 "DlDpipeEntryActionValues",
8331 r#type.and_then(|t| DlDpipeEntryActionValues::attr_from_type(t)),
8332 self.orig_loc,
8333 self.buf.as_ptr().wrapping_add(pos) as usize,
8334 )))
8335 }
8336}
8337impl<'a> std::fmt::Debug for IterableDlDpipeEntryActionValues<'_> {
8338 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8339 let mut fmt = f.debug_struct("DlDpipeEntryActionValues");
8340 for attr in self.clone() {
8341 let attr = match attr {
8342 Ok(a) => a,
8343 Err(err) => {
8344 fmt.finish()?;
8345 f.write_str("Err(")?;
8346 err.fmt(f)?;
8347 return f.write_str(")");
8348 }
8349 };
8350 match attr {
8351 DlDpipeEntryActionValues::DpipeActionValue(val) => {
8352 fmt.field("DpipeActionValue", &val)
8353 }
8354 };
8355 }
8356 fmt.finish()
8357 }
8358}
8359impl IterableDlDpipeEntryActionValues<'_> {
8360 pub fn lookup_attr(
8361 &self,
8362 offset: usize,
8363 missing_type: Option<u16>,
8364 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
8365 let mut stack = Vec::new();
8366 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
8367 if missing_type.is_some() && cur == offset {
8368 stack.push(("DlDpipeEntryActionValues", offset));
8369 return (
8370 stack,
8371 missing_type.and_then(|t| DlDpipeEntryActionValues::attr_from_type(t)),
8372 );
8373 }
8374 if cur > offset || cur + self.buf.len() < offset {
8375 return (stack, None);
8376 }
8377 let mut attrs = self.clone();
8378 let mut last_off = cur + attrs.pos;
8379 let mut missing = None;
8380 while let Some(attr) = attrs.next() {
8381 let Ok(attr) = attr else { break };
8382 match attr {
8383 DlDpipeEntryActionValues::DpipeActionValue(val) => {
8384 (stack, missing) = val.lookup_attr(offset, missing_type);
8385 if !stack.is_empty() {
8386 break;
8387 }
8388 }
8389 _ => {}
8390 };
8391 last_off = cur + attrs.pos;
8392 }
8393 if !stack.is_empty() {
8394 stack.push(("DlDpipeEntryActionValues", cur));
8395 }
8396 (stack, missing)
8397 }
8398}
8399#[derive(Clone)]
8400pub enum DlDpipeMatch {
8401 #[doc = "Associated type: [`DpipeMatchType`] (enum)"]
8402 DpipeMatchType(u32),
8403 #[doc = "Associated type: [`DpipeHeaderId`] (enum)"]
8404 DpipeHeaderId(u32),
8405 DpipeHeaderGlobal(u8),
8406 DpipeHeaderIndex(u32),
8407 DpipeFieldId(u32),
8408}
8409impl<'a> IterableDlDpipeMatch<'a> {
8410 #[doc = "Associated type: [`DpipeMatchType`] (enum)"]
8411 pub fn get_dpipe_match_type(&self) -> Result<u32, ErrorContext> {
8412 let mut iter = self.clone();
8413 iter.pos = 0;
8414 for attr in iter {
8415 if let Ok(DlDpipeMatch::DpipeMatchType(val)) = attr {
8416 return Ok(val);
8417 }
8418 }
8419 Err(ErrorContext::new_missing(
8420 "DlDpipeMatch",
8421 "DpipeMatchType",
8422 self.orig_loc,
8423 self.buf.as_ptr() as usize,
8424 ))
8425 }
8426 #[doc = "Associated type: [`DpipeHeaderId`] (enum)"]
8427 pub fn get_dpipe_header_id(&self) -> Result<u32, ErrorContext> {
8428 let mut iter = self.clone();
8429 iter.pos = 0;
8430 for attr in iter {
8431 if let Ok(DlDpipeMatch::DpipeHeaderId(val)) = attr {
8432 return Ok(val);
8433 }
8434 }
8435 Err(ErrorContext::new_missing(
8436 "DlDpipeMatch",
8437 "DpipeHeaderId",
8438 self.orig_loc,
8439 self.buf.as_ptr() as usize,
8440 ))
8441 }
8442 pub fn get_dpipe_header_global(&self) -> Result<u8, ErrorContext> {
8443 let mut iter = self.clone();
8444 iter.pos = 0;
8445 for attr in iter {
8446 if let Ok(DlDpipeMatch::DpipeHeaderGlobal(val)) = attr {
8447 return Ok(val);
8448 }
8449 }
8450 Err(ErrorContext::new_missing(
8451 "DlDpipeMatch",
8452 "DpipeHeaderGlobal",
8453 self.orig_loc,
8454 self.buf.as_ptr() as usize,
8455 ))
8456 }
8457 pub fn get_dpipe_header_index(&self) -> Result<u32, ErrorContext> {
8458 let mut iter = self.clone();
8459 iter.pos = 0;
8460 for attr in iter {
8461 if let Ok(DlDpipeMatch::DpipeHeaderIndex(val)) = attr {
8462 return Ok(val);
8463 }
8464 }
8465 Err(ErrorContext::new_missing(
8466 "DlDpipeMatch",
8467 "DpipeHeaderIndex",
8468 self.orig_loc,
8469 self.buf.as_ptr() as usize,
8470 ))
8471 }
8472 pub fn get_dpipe_field_id(&self) -> Result<u32, ErrorContext> {
8473 let mut iter = self.clone();
8474 iter.pos = 0;
8475 for attr in iter {
8476 if let Ok(DlDpipeMatch::DpipeFieldId(val)) = attr {
8477 return Ok(val);
8478 }
8479 }
8480 Err(ErrorContext::new_missing(
8481 "DlDpipeMatch",
8482 "DpipeFieldId",
8483 self.orig_loc,
8484 self.buf.as_ptr() as usize,
8485 ))
8486 }
8487}
8488impl DlDpipeMatch {
8489 pub fn new<'a>(buf: &'a [u8]) -> IterableDlDpipeMatch<'a> {
8490 IterableDlDpipeMatch::with_loc(buf, buf.as_ptr() as usize)
8491 }
8492 fn attr_from_type(r#type: u16) -> Option<&'static str> {
8493 Devlink::attr_from_type(r#type)
8494 }
8495}
8496#[derive(Clone, Copy, Default)]
8497pub struct IterableDlDpipeMatch<'a> {
8498 buf: &'a [u8],
8499 pos: usize,
8500 orig_loc: usize,
8501}
8502impl<'a> IterableDlDpipeMatch<'a> {
8503 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
8504 Self {
8505 buf,
8506 pos: 0,
8507 orig_loc,
8508 }
8509 }
8510 pub fn get_buf(&self) -> &'a [u8] {
8511 self.buf
8512 }
8513}
8514impl<'a> Iterator for IterableDlDpipeMatch<'a> {
8515 type Item = Result<DlDpipeMatch, ErrorContext>;
8516 fn next(&mut self) -> Option<Self::Item> {
8517 let mut pos;
8518 let mut r#type;
8519 loop {
8520 pos = self.pos;
8521 r#type = None;
8522 if self.buf.len() == self.pos {
8523 return None;
8524 }
8525 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
8526 self.pos = self.buf.len();
8527 break;
8528 };
8529 r#type = Some(header.r#type);
8530 let res = match header.r#type {
8531 42u16 => DlDpipeMatch::DpipeMatchType({
8532 let res = parse_u32(next);
8533 let Some(val) = res else { break };
8534 val
8535 }),
8536 52u16 => DlDpipeMatch::DpipeHeaderId({
8537 let res = parse_u32(next);
8538 let Some(val) = res else { break };
8539 val
8540 }),
8541 54u16 => DlDpipeMatch::DpipeHeaderGlobal({
8542 let res = parse_u8(next);
8543 let Some(val) = res else { break };
8544 val
8545 }),
8546 55u16 => DlDpipeMatch::DpipeHeaderIndex({
8547 let res = parse_u32(next);
8548 let Some(val) = res else { break };
8549 val
8550 }),
8551 58u16 => DlDpipeMatch::DpipeFieldId({
8552 let res = parse_u32(next);
8553 let Some(val) = res else { break };
8554 val
8555 }),
8556 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
8557 n => continue,
8558 };
8559 return Some(Ok(res));
8560 }
8561 Some(Err(ErrorContext::new(
8562 "DlDpipeMatch",
8563 r#type.and_then(|t| DlDpipeMatch::attr_from_type(t)),
8564 self.orig_loc,
8565 self.buf.as_ptr().wrapping_add(pos) as usize,
8566 )))
8567 }
8568}
8569impl std::fmt::Debug for IterableDlDpipeMatch<'_> {
8570 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8571 let mut fmt = f.debug_struct("DlDpipeMatch");
8572 for attr in self.clone() {
8573 let attr = match attr {
8574 Ok(a) => a,
8575 Err(err) => {
8576 fmt.finish()?;
8577 f.write_str("Err(")?;
8578 err.fmt(f)?;
8579 return f.write_str(")");
8580 }
8581 };
8582 match attr {
8583 DlDpipeMatch::DpipeMatchType(val) => fmt.field(
8584 "DpipeMatchType",
8585 &FormatEnum(val.into(), DpipeMatchType::from_value),
8586 ),
8587 DlDpipeMatch::DpipeHeaderId(val) => fmt.field(
8588 "DpipeHeaderId",
8589 &FormatEnum(val.into(), DpipeHeaderId::from_value),
8590 ),
8591 DlDpipeMatch::DpipeHeaderGlobal(val) => fmt.field("DpipeHeaderGlobal", &val),
8592 DlDpipeMatch::DpipeHeaderIndex(val) => fmt.field("DpipeHeaderIndex", &val),
8593 DlDpipeMatch::DpipeFieldId(val) => fmt.field("DpipeFieldId", &val),
8594 };
8595 }
8596 fmt.finish()
8597 }
8598}
8599impl IterableDlDpipeMatch<'_> {
8600 pub fn lookup_attr(
8601 &self,
8602 offset: usize,
8603 missing_type: Option<u16>,
8604 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
8605 let mut stack = Vec::new();
8606 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
8607 if missing_type.is_some() && cur == offset {
8608 stack.push(("DlDpipeMatch", offset));
8609 return (
8610 stack,
8611 missing_type.and_then(|t| DlDpipeMatch::attr_from_type(t)),
8612 );
8613 }
8614 if cur > offset || cur + self.buf.len() < offset {
8615 return (stack, None);
8616 }
8617 let mut attrs = self.clone();
8618 let mut last_off = cur + attrs.pos;
8619 while let Some(attr) = attrs.next() {
8620 let Ok(attr) = attr else { break };
8621 match attr {
8622 DlDpipeMatch::DpipeMatchType(val) => {
8623 if last_off == offset {
8624 stack.push(("DpipeMatchType", last_off));
8625 break;
8626 }
8627 }
8628 DlDpipeMatch::DpipeHeaderId(val) => {
8629 if last_off == offset {
8630 stack.push(("DpipeHeaderId", last_off));
8631 break;
8632 }
8633 }
8634 DlDpipeMatch::DpipeHeaderGlobal(val) => {
8635 if last_off == offset {
8636 stack.push(("DpipeHeaderGlobal", last_off));
8637 break;
8638 }
8639 }
8640 DlDpipeMatch::DpipeHeaderIndex(val) => {
8641 if last_off == offset {
8642 stack.push(("DpipeHeaderIndex", last_off));
8643 break;
8644 }
8645 }
8646 DlDpipeMatch::DpipeFieldId(val) => {
8647 if last_off == offset {
8648 stack.push(("DpipeFieldId", last_off));
8649 break;
8650 }
8651 }
8652 _ => {}
8653 };
8654 last_off = cur + attrs.pos;
8655 }
8656 if !stack.is_empty() {
8657 stack.push(("DlDpipeMatch", cur));
8658 }
8659 (stack, None)
8660 }
8661}
8662#[derive(Clone)]
8663pub enum DlDpipeMatchValue<'a> {
8664 #[doc = "Attribute may repeat multiple times (treat it as array)"]
8665 DpipeMatch(IterableDlDpipeMatch<'a>),
8666 DpipeValue(&'a [u8]),
8667 DpipeValueMask(&'a [u8]),
8668 DpipeValueMapping(u32),
8669}
8670impl<'a> IterableDlDpipeMatchValue<'a> {
8671 #[doc = "Attribute may repeat multiple times (treat it as array)"]
8672 pub fn get_dpipe_match(
8673 &self,
8674 ) -> MultiAttrIterable<Self, DlDpipeMatchValue<'a>, IterableDlDpipeMatch<'a>> {
8675 MultiAttrIterable::new(self.clone(), |variant| {
8676 if let DlDpipeMatchValue::DpipeMatch(val) = variant {
8677 Some(val)
8678 } else {
8679 None
8680 }
8681 })
8682 }
8683 pub fn get_dpipe_value(&self) -> Result<&'a [u8], ErrorContext> {
8684 let mut iter = self.clone();
8685 iter.pos = 0;
8686 for attr in iter {
8687 if let Ok(DlDpipeMatchValue::DpipeValue(val)) = attr {
8688 return Ok(val);
8689 }
8690 }
8691 Err(ErrorContext::new_missing(
8692 "DlDpipeMatchValue",
8693 "DpipeValue",
8694 self.orig_loc,
8695 self.buf.as_ptr() as usize,
8696 ))
8697 }
8698 pub fn get_dpipe_value_mask(&self) -> Result<&'a [u8], ErrorContext> {
8699 let mut iter = self.clone();
8700 iter.pos = 0;
8701 for attr in iter {
8702 if let Ok(DlDpipeMatchValue::DpipeValueMask(val)) = attr {
8703 return Ok(val);
8704 }
8705 }
8706 Err(ErrorContext::new_missing(
8707 "DlDpipeMatchValue",
8708 "DpipeValueMask",
8709 self.orig_loc,
8710 self.buf.as_ptr() as usize,
8711 ))
8712 }
8713 pub fn get_dpipe_value_mapping(&self) -> Result<u32, ErrorContext> {
8714 let mut iter = self.clone();
8715 iter.pos = 0;
8716 for attr in iter {
8717 if let Ok(DlDpipeMatchValue::DpipeValueMapping(val)) = attr {
8718 return Ok(val);
8719 }
8720 }
8721 Err(ErrorContext::new_missing(
8722 "DlDpipeMatchValue",
8723 "DpipeValueMapping",
8724 self.orig_loc,
8725 self.buf.as_ptr() as usize,
8726 ))
8727 }
8728}
8729impl DlDpipeMatchValue<'_> {
8730 pub fn new<'a>(buf: &'a [u8]) -> IterableDlDpipeMatchValue<'a> {
8731 IterableDlDpipeMatchValue::with_loc(buf, buf.as_ptr() as usize)
8732 }
8733 fn attr_from_type(r#type: u16) -> Option<&'static str> {
8734 Devlink::attr_from_type(r#type)
8735 }
8736}
8737#[derive(Clone, Copy, Default)]
8738pub struct IterableDlDpipeMatchValue<'a> {
8739 buf: &'a [u8],
8740 pos: usize,
8741 orig_loc: usize,
8742}
8743impl<'a> IterableDlDpipeMatchValue<'a> {
8744 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
8745 Self {
8746 buf,
8747 pos: 0,
8748 orig_loc,
8749 }
8750 }
8751 pub fn get_buf(&self) -> &'a [u8] {
8752 self.buf
8753 }
8754}
8755impl<'a> Iterator for IterableDlDpipeMatchValue<'a> {
8756 type Item = Result<DlDpipeMatchValue<'a>, ErrorContext>;
8757 fn next(&mut self) -> Option<Self::Item> {
8758 let mut pos;
8759 let mut r#type;
8760 loop {
8761 pos = self.pos;
8762 r#type = None;
8763 if self.buf.len() == self.pos {
8764 return None;
8765 }
8766 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
8767 self.pos = self.buf.len();
8768 break;
8769 };
8770 r#type = Some(header.r#type);
8771 let res = match header.r#type {
8772 40u16 => DlDpipeMatchValue::DpipeMatch({
8773 let res = Some(IterableDlDpipeMatch::with_loc(next, self.orig_loc));
8774 let Some(val) = res else { break };
8775 val
8776 }),
8777 46u16 => DlDpipeMatchValue::DpipeValue({
8778 let res = Some(next);
8779 let Some(val) = res else { break };
8780 val
8781 }),
8782 47u16 => DlDpipeMatchValue::DpipeValueMask({
8783 let res = Some(next);
8784 let Some(val) = res else { break };
8785 val
8786 }),
8787 48u16 => DlDpipeMatchValue::DpipeValueMapping({
8788 let res = parse_u32(next);
8789 let Some(val) = res else { break };
8790 val
8791 }),
8792 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
8793 n => continue,
8794 };
8795 return Some(Ok(res));
8796 }
8797 Some(Err(ErrorContext::new(
8798 "DlDpipeMatchValue",
8799 r#type.and_then(|t| DlDpipeMatchValue::attr_from_type(t)),
8800 self.orig_loc,
8801 self.buf.as_ptr().wrapping_add(pos) as usize,
8802 )))
8803 }
8804}
8805impl<'a> std::fmt::Debug for IterableDlDpipeMatchValue<'_> {
8806 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8807 let mut fmt = f.debug_struct("DlDpipeMatchValue");
8808 for attr in self.clone() {
8809 let attr = match attr {
8810 Ok(a) => a,
8811 Err(err) => {
8812 fmt.finish()?;
8813 f.write_str("Err(")?;
8814 err.fmt(f)?;
8815 return f.write_str(")");
8816 }
8817 };
8818 match attr {
8819 DlDpipeMatchValue::DpipeMatch(val) => fmt.field("DpipeMatch", &val),
8820 DlDpipeMatchValue::DpipeValue(val) => fmt.field("DpipeValue", &val),
8821 DlDpipeMatchValue::DpipeValueMask(val) => fmt.field("DpipeValueMask", &val),
8822 DlDpipeMatchValue::DpipeValueMapping(val) => fmt.field("DpipeValueMapping", &val),
8823 };
8824 }
8825 fmt.finish()
8826 }
8827}
8828impl IterableDlDpipeMatchValue<'_> {
8829 pub fn lookup_attr(
8830 &self,
8831 offset: usize,
8832 missing_type: Option<u16>,
8833 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
8834 let mut stack = Vec::new();
8835 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
8836 if missing_type.is_some() && cur == offset {
8837 stack.push(("DlDpipeMatchValue", offset));
8838 return (
8839 stack,
8840 missing_type.and_then(|t| DlDpipeMatchValue::attr_from_type(t)),
8841 );
8842 }
8843 if cur > offset || cur + self.buf.len() < offset {
8844 return (stack, None);
8845 }
8846 let mut attrs = self.clone();
8847 let mut last_off = cur + attrs.pos;
8848 let mut missing = None;
8849 while let Some(attr) = attrs.next() {
8850 let Ok(attr) = attr else { break };
8851 match attr {
8852 DlDpipeMatchValue::DpipeMatch(val) => {
8853 (stack, missing) = val.lookup_attr(offset, missing_type);
8854 if !stack.is_empty() {
8855 break;
8856 }
8857 }
8858 DlDpipeMatchValue::DpipeValue(val) => {
8859 if last_off == offset {
8860 stack.push(("DpipeValue", last_off));
8861 break;
8862 }
8863 }
8864 DlDpipeMatchValue::DpipeValueMask(val) => {
8865 if last_off == offset {
8866 stack.push(("DpipeValueMask", last_off));
8867 break;
8868 }
8869 }
8870 DlDpipeMatchValue::DpipeValueMapping(val) => {
8871 if last_off == offset {
8872 stack.push(("DpipeValueMapping", last_off));
8873 break;
8874 }
8875 }
8876 _ => {}
8877 };
8878 last_off = cur + attrs.pos;
8879 }
8880 if !stack.is_empty() {
8881 stack.push(("DlDpipeMatchValue", cur));
8882 }
8883 (stack, missing)
8884 }
8885}
8886#[derive(Clone)]
8887pub enum DlDpipeAction {
8888 #[doc = "Associated type: [`DpipeActionType`] (enum)"]
8889 DpipeActionType(u32),
8890 #[doc = "Associated type: [`DpipeHeaderId`] (enum)"]
8891 DpipeHeaderId(u32),
8892 DpipeHeaderGlobal(u8),
8893 DpipeHeaderIndex(u32),
8894 DpipeFieldId(u32),
8895}
8896impl<'a> IterableDlDpipeAction<'a> {
8897 #[doc = "Associated type: [`DpipeActionType`] (enum)"]
8898 pub fn get_dpipe_action_type(&self) -> Result<u32, ErrorContext> {
8899 let mut iter = self.clone();
8900 iter.pos = 0;
8901 for attr in iter {
8902 if let Ok(DlDpipeAction::DpipeActionType(val)) = attr {
8903 return Ok(val);
8904 }
8905 }
8906 Err(ErrorContext::new_missing(
8907 "DlDpipeAction",
8908 "DpipeActionType",
8909 self.orig_loc,
8910 self.buf.as_ptr() as usize,
8911 ))
8912 }
8913 #[doc = "Associated type: [`DpipeHeaderId`] (enum)"]
8914 pub fn get_dpipe_header_id(&self) -> Result<u32, ErrorContext> {
8915 let mut iter = self.clone();
8916 iter.pos = 0;
8917 for attr in iter {
8918 if let Ok(DlDpipeAction::DpipeHeaderId(val)) = attr {
8919 return Ok(val);
8920 }
8921 }
8922 Err(ErrorContext::new_missing(
8923 "DlDpipeAction",
8924 "DpipeHeaderId",
8925 self.orig_loc,
8926 self.buf.as_ptr() as usize,
8927 ))
8928 }
8929 pub fn get_dpipe_header_global(&self) -> Result<u8, ErrorContext> {
8930 let mut iter = self.clone();
8931 iter.pos = 0;
8932 for attr in iter {
8933 if let Ok(DlDpipeAction::DpipeHeaderGlobal(val)) = attr {
8934 return Ok(val);
8935 }
8936 }
8937 Err(ErrorContext::new_missing(
8938 "DlDpipeAction",
8939 "DpipeHeaderGlobal",
8940 self.orig_loc,
8941 self.buf.as_ptr() as usize,
8942 ))
8943 }
8944 pub fn get_dpipe_header_index(&self) -> Result<u32, ErrorContext> {
8945 let mut iter = self.clone();
8946 iter.pos = 0;
8947 for attr in iter {
8948 if let Ok(DlDpipeAction::DpipeHeaderIndex(val)) = attr {
8949 return Ok(val);
8950 }
8951 }
8952 Err(ErrorContext::new_missing(
8953 "DlDpipeAction",
8954 "DpipeHeaderIndex",
8955 self.orig_loc,
8956 self.buf.as_ptr() as usize,
8957 ))
8958 }
8959 pub fn get_dpipe_field_id(&self) -> Result<u32, ErrorContext> {
8960 let mut iter = self.clone();
8961 iter.pos = 0;
8962 for attr in iter {
8963 if let Ok(DlDpipeAction::DpipeFieldId(val)) = attr {
8964 return Ok(val);
8965 }
8966 }
8967 Err(ErrorContext::new_missing(
8968 "DlDpipeAction",
8969 "DpipeFieldId",
8970 self.orig_loc,
8971 self.buf.as_ptr() as usize,
8972 ))
8973 }
8974}
8975impl DlDpipeAction {
8976 pub fn new<'a>(buf: &'a [u8]) -> IterableDlDpipeAction<'a> {
8977 IterableDlDpipeAction::with_loc(buf, buf.as_ptr() as usize)
8978 }
8979 fn attr_from_type(r#type: u16) -> Option<&'static str> {
8980 Devlink::attr_from_type(r#type)
8981 }
8982}
8983#[derive(Clone, Copy, Default)]
8984pub struct IterableDlDpipeAction<'a> {
8985 buf: &'a [u8],
8986 pos: usize,
8987 orig_loc: usize,
8988}
8989impl<'a> IterableDlDpipeAction<'a> {
8990 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
8991 Self {
8992 buf,
8993 pos: 0,
8994 orig_loc,
8995 }
8996 }
8997 pub fn get_buf(&self) -> &'a [u8] {
8998 self.buf
8999 }
9000}
9001impl<'a> Iterator for IterableDlDpipeAction<'a> {
9002 type Item = Result<DlDpipeAction, ErrorContext>;
9003 fn next(&mut self) -> Option<Self::Item> {
9004 let mut pos;
9005 let mut r#type;
9006 loop {
9007 pos = self.pos;
9008 r#type = None;
9009 if self.buf.len() == self.pos {
9010 return None;
9011 }
9012 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
9013 self.pos = self.buf.len();
9014 break;
9015 };
9016 r#type = Some(header.r#type);
9017 let res = match header.r#type {
9018 45u16 => DlDpipeAction::DpipeActionType({
9019 let res = parse_u32(next);
9020 let Some(val) = res else { break };
9021 val
9022 }),
9023 52u16 => DlDpipeAction::DpipeHeaderId({
9024 let res = parse_u32(next);
9025 let Some(val) = res else { break };
9026 val
9027 }),
9028 54u16 => DlDpipeAction::DpipeHeaderGlobal({
9029 let res = parse_u8(next);
9030 let Some(val) = res else { break };
9031 val
9032 }),
9033 55u16 => DlDpipeAction::DpipeHeaderIndex({
9034 let res = parse_u32(next);
9035 let Some(val) = res else { break };
9036 val
9037 }),
9038 58u16 => DlDpipeAction::DpipeFieldId({
9039 let res = parse_u32(next);
9040 let Some(val) = res else { break };
9041 val
9042 }),
9043 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
9044 n => continue,
9045 };
9046 return Some(Ok(res));
9047 }
9048 Some(Err(ErrorContext::new(
9049 "DlDpipeAction",
9050 r#type.and_then(|t| DlDpipeAction::attr_from_type(t)),
9051 self.orig_loc,
9052 self.buf.as_ptr().wrapping_add(pos) as usize,
9053 )))
9054 }
9055}
9056impl std::fmt::Debug for IterableDlDpipeAction<'_> {
9057 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9058 let mut fmt = f.debug_struct("DlDpipeAction");
9059 for attr in self.clone() {
9060 let attr = match attr {
9061 Ok(a) => a,
9062 Err(err) => {
9063 fmt.finish()?;
9064 f.write_str("Err(")?;
9065 err.fmt(f)?;
9066 return f.write_str(")");
9067 }
9068 };
9069 match attr {
9070 DlDpipeAction::DpipeActionType(val) => fmt.field(
9071 "DpipeActionType",
9072 &FormatEnum(val.into(), DpipeActionType::from_value),
9073 ),
9074 DlDpipeAction::DpipeHeaderId(val) => fmt.field(
9075 "DpipeHeaderId",
9076 &FormatEnum(val.into(), DpipeHeaderId::from_value),
9077 ),
9078 DlDpipeAction::DpipeHeaderGlobal(val) => fmt.field("DpipeHeaderGlobal", &val),
9079 DlDpipeAction::DpipeHeaderIndex(val) => fmt.field("DpipeHeaderIndex", &val),
9080 DlDpipeAction::DpipeFieldId(val) => fmt.field("DpipeFieldId", &val),
9081 };
9082 }
9083 fmt.finish()
9084 }
9085}
9086impl IterableDlDpipeAction<'_> {
9087 pub fn lookup_attr(
9088 &self,
9089 offset: usize,
9090 missing_type: Option<u16>,
9091 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
9092 let mut stack = Vec::new();
9093 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
9094 if missing_type.is_some() && cur == offset {
9095 stack.push(("DlDpipeAction", offset));
9096 return (
9097 stack,
9098 missing_type.and_then(|t| DlDpipeAction::attr_from_type(t)),
9099 );
9100 }
9101 if cur > offset || cur + self.buf.len() < offset {
9102 return (stack, None);
9103 }
9104 let mut attrs = self.clone();
9105 let mut last_off = cur + attrs.pos;
9106 while let Some(attr) = attrs.next() {
9107 let Ok(attr) = attr else { break };
9108 match attr {
9109 DlDpipeAction::DpipeActionType(val) => {
9110 if last_off == offset {
9111 stack.push(("DpipeActionType", last_off));
9112 break;
9113 }
9114 }
9115 DlDpipeAction::DpipeHeaderId(val) => {
9116 if last_off == offset {
9117 stack.push(("DpipeHeaderId", last_off));
9118 break;
9119 }
9120 }
9121 DlDpipeAction::DpipeHeaderGlobal(val) => {
9122 if last_off == offset {
9123 stack.push(("DpipeHeaderGlobal", last_off));
9124 break;
9125 }
9126 }
9127 DlDpipeAction::DpipeHeaderIndex(val) => {
9128 if last_off == offset {
9129 stack.push(("DpipeHeaderIndex", last_off));
9130 break;
9131 }
9132 }
9133 DlDpipeAction::DpipeFieldId(val) => {
9134 if last_off == offset {
9135 stack.push(("DpipeFieldId", last_off));
9136 break;
9137 }
9138 }
9139 _ => {}
9140 };
9141 last_off = cur + attrs.pos;
9142 }
9143 if !stack.is_empty() {
9144 stack.push(("DlDpipeAction", cur));
9145 }
9146 (stack, None)
9147 }
9148}
9149#[derive(Clone)]
9150pub enum DlDpipeActionValue<'a> {
9151 #[doc = "Attribute may repeat multiple times (treat it as array)"]
9152 DpipeAction(IterableDlDpipeAction<'a>),
9153 DpipeValue(&'a [u8]),
9154 DpipeValueMask(&'a [u8]),
9155 DpipeValueMapping(u32),
9156}
9157impl<'a> IterableDlDpipeActionValue<'a> {
9158 #[doc = "Attribute may repeat multiple times (treat it as array)"]
9159 pub fn get_dpipe_action(
9160 &self,
9161 ) -> MultiAttrIterable<Self, DlDpipeActionValue<'a>, IterableDlDpipeAction<'a>> {
9162 MultiAttrIterable::new(self.clone(), |variant| {
9163 if let DlDpipeActionValue::DpipeAction(val) = variant {
9164 Some(val)
9165 } else {
9166 None
9167 }
9168 })
9169 }
9170 pub fn get_dpipe_value(&self) -> Result<&'a [u8], ErrorContext> {
9171 let mut iter = self.clone();
9172 iter.pos = 0;
9173 for attr in iter {
9174 if let Ok(DlDpipeActionValue::DpipeValue(val)) = attr {
9175 return Ok(val);
9176 }
9177 }
9178 Err(ErrorContext::new_missing(
9179 "DlDpipeActionValue",
9180 "DpipeValue",
9181 self.orig_loc,
9182 self.buf.as_ptr() as usize,
9183 ))
9184 }
9185 pub fn get_dpipe_value_mask(&self) -> Result<&'a [u8], ErrorContext> {
9186 let mut iter = self.clone();
9187 iter.pos = 0;
9188 for attr in iter {
9189 if let Ok(DlDpipeActionValue::DpipeValueMask(val)) = attr {
9190 return Ok(val);
9191 }
9192 }
9193 Err(ErrorContext::new_missing(
9194 "DlDpipeActionValue",
9195 "DpipeValueMask",
9196 self.orig_loc,
9197 self.buf.as_ptr() as usize,
9198 ))
9199 }
9200 pub fn get_dpipe_value_mapping(&self) -> Result<u32, ErrorContext> {
9201 let mut iter = self.clone();
9202 iter.pos = 0;
9203 for attr in iter {
9204 if let Ok(DlDpipeActionValue::DpipeValueMapping(val)) = attr {
9205 return Ok(val);
9206 }
9207 }
9208 Err(ErrorContext::new_missing(
9209 "DlDpipeActionValue",
9210 "DpipeValueMapping",
9211 self.orig_loc,
9212 self.buf.as_ptr() as usize,
9213 ))
9214 }
9215}
9216impl DlDpipeActionValue<'_> {
9217 pub fn new<'a>(buf: &'a [u8]) -> IterableDlDpipeActionValue<'a> {
9218 IterableDlDpipeActionValue::with_loc(buf, buf.as_ptr() as usize)
9219 }
9220 fn attr_from_type(r#type: u16) -> Option<&'static str> {
9221 Devlink::attr_from_type(r#type)
9222 }
9223}
9224#[derive(Clone, Copy, Default)]
9225pub struct IterableDlDpipeActionValue<'a> {
9226 buf: &'a [u8],
9227 pos: usize,
9228 orig_loc: usize,
9229}
9230impl<'a> IterableDlDpipeActionValue<'a> {
9231 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
9232 Self {
9233 buf,
9234 pos: 0,
9235 orig_loc,
9236 }
9237 }
9238 pub fn get_buf(&self) -> &'a [u8] {
9239 self.buf
9240 }
9241}
9242impl<'a> Iterator for IterableDlDpipeActionValue<'a> {
9243 type Item = Result<DlDpipeActionValue<'a>, ErrorContext>;
9244 fn next(&mut self) -> Option<Self::Item> {
9245 let mut pos;
9246 let mut r#type;
9247 loop {
9248 pos = self.pos;
9249 r#type = None;
9250 if self.buf.len() == self.pos {
9251 return None;
9252 }
9253 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
9254 self.pos = self.buf.len();
9255 break;
9256 };
9257 r#type = Some(header.r#type);
9258 let res = match header.r#type {
9259 43u16 => DlDpipeActionValue::DpipeAction({
9260 let res = Some(IterableDlDpipeAction::with_loc(next, self.orig_loc));
9261 let Some(val) = res else { break };
9262 val
9263 }),
9264 46u16 => DlDpipeActionValue::DpipeValue({
9265 let res = Some(next);
9266 let Some(val) = res else { break };
9267 val
9268 }),
9269 47u16 => DlDpipeActionValue::DpipeValueMask({
9270 let res = Some(next);
9271 let Some(val) = res else { break };
9272 val
9273 }),
9274 48u16 => DlDpipeActionValue::DpipeValueMapping({
9275 let res = parse_u32(next);
9276 let Some(val) = res else { break };
9277 val
9278 }),
9279 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
9280 n => continue,
9281 };
9282 return Some(Ok(res));
9283 }
9284 Some(Err(ErrorContext::new(
9285 "DlDpipeActionValue",
9286 r#type.and_then(|t| DlDpipeActionValue::attr_from_type(t)),
9287 self.orig_loc,
9288 self.buf.as_ptr().wrapping_add(pos) as usize,
9289 )))
9290 }
9291}
9292impl<'a> std::fmt::Debug for IterableDlDpipeActionValue<'_> {
9293 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9294 let mut fmt = f.debug_struct("DlDpipeActionValue");
9295 for attr in self.clone() {
9296 let attr = match attr {
9297 Ok(a) => a,
9298 Err(err) => {
9299 fmt.finish()?;
9300 f.write_str("Err(")?;
9301 err.fmt(f)?;
9302 return f.write_str(")");
9303 }
9304 };
9305 match attr {
9306 DlDpipeActionValue::DpipeAction(val) => fmt.field("DpipeAction", &val),
9307 DlDpipeActionValue::DpipeValue(val) => fmt.field("DpipeValue", &val),
9308 DlDpipeActionValue::DpipeValueMask(val) => fmt.field("DpipeValueMask", &val),
9309 DlDpipeActionValue::DpipeValueMapping(val) => fmt.field("DpipeValueMapping", &val),
9310 };
9311 }
9312 fmt.finish()
9313 }
9314}
9315impl IterableDlDpipeActionValue<'_> {
9316 pub fn lookup_attr(
9317 &self,
9318 offset: usize,
9319 missing_type: Option<u16>,
9320 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
9321 let mut stack = Vec::new();
9322 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
9323 if missing_type.is_some() && cur == offset {
9324 stack.push(("DlDpipeActionValue", offset));
9325 return (
9326 stack,
9327 missing_type.and_then(|t| DlDpipeActionValue::attr_from_type(t)),
9328 );
9329 }
9330 if cur > offset || cur + self.buf.len() < offset {
9331 return (stack, None);
9332 }
9333 let mut attrs = self.clone();
9334 let mut last_off = cur + attrs.pos;
9335 let mut missing = None;
9336 while let Some(attr) = attrs.next() {
9337 let Ok(attr) = attr else { break };
9338 match attr {
9339 DlDpipeActionValue::DpipeAction(val) => {
9340 (stack, missing) = val.lookup_attr(offset, missing_type);
9341 if !stack.is_empty() {
9342 break;
9343 }
9344 }
9345 DlDpipeActionValue::DpipeValue(val) => {
9346 if last_off == offset {
9347 stack.push(("DpipeValue", last_off));
9348 break;
9349 }
9350 }
9351 DlDpipeActionValue::DpipeValueMask(val) => {
9352 if last_off == offset {
9353 stack.push(("DpipeValueMask", last_off));
9354 break;
9355 }
9356 }
9357 DlDpipeActionValue::DpipeValueMapping(val) => {
9358 if last_off == offset {
9359 stack.push(("DpipeValueMapping", last_off));
9360 break;
9361 }
9362 }
9363 _ => {}
9364 };
9365 last_off = cur + attrs.pos;
9366 }
9367 if !stack.is_empty() {
9368 stack.push(("DlDpipeActionValue", cur));
9369 }
9370 (stack, missing)
9371 }
9372}
9373#[derive(Clone)]
9374pub enum DlDpipeHeaders<'a> {
9375 #[doc = "Attribute may repeat multiple times (treat it as array)"]
9376 DpipeHeader(IterableDlDpipeHeader<'a>),
9377}
9378impl<'a> IterableDlDpipeHeaders<'a> {
9379 #[doc = "Attribute may repeat multiple times (treat it as array)"]
9380 pub fn get_dpipe_header(
9381 &self,
9382 ) -> MultiAttrIterable<Self, DlDpipeHeaders<'a>, IterableDlDpipeHeader<'a>> {
9383 MultiAttrIterable::new(self.clone(), |variant| {
9384 if let DlDpipeHeaders::DpipeHeader(val) = variant {
9385 Some(val)
9386 } else {
9387 None
9388 }
9389 })
9390 }
9391}
9392impl DlDpipeHeaders<'_> {
9393 pub fn new<'a>(buf: &'a [u8]) -> IterableDlDpipeHeaders<'a> {
9394 IterableDlDpipeHeaders::with_loc(buf, buf.as_ptr() as usize)
9395 }
9396 fn attr_from_type(r#type: u16) -> Option<&'static str> {
9397 Devlink::attr_from_type(r#type)
9398 }
9399}
9400#[derive(Clone, Copy, Default)]
9401pub struct IterableDlDpipeHeaders<'a> {
9402 buf: &'a [u8],
9403 pos: usize,
9404 orig_loc: usize,
9405}
9406impl<'a> IterableDlDpipeHeaders<'a> {
9407 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
9408 Self {
9409 buf,
9410 pos: 0,
9411 orig_loc,
9412 }
9413 }
9414 pub fn get_buf(&self) -> &'a [u8] {
9415 self.buf
9416 }
9417}
9418impl<'a> Iterator for IterableDlDpipeHeaders<'a> {
9419 type Item = Result<DlDpipeHeaders<'a>, ErrorContext>;
9420 fn next(&mut self) -> Option<Self::Item> {
9421 let mut pos;
9422 let mut r#type;
9423 loop {
9424 pos = self.pos;
9425 r#type = None;
9426 if self.buf.len() == self.pos {
9427 return None;
9428 }
9429 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
9430 self.pos = self.buf.len();
9431 break;
9432 };
9433 r#type = Some(header.r#type);
9434 let res = match header.r#type {
9435 50u16 => DlDpipeHeaders::DpipeHeader({
9436 let res = Some(IterableDlDpipeHeader::with_loc(next, self.orig_loc));
9437 let Some(val) = res else { break };
9438 val
9439 }),
9440 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
9441 n => continue,
9442 };
9443 return Some(Ok(res));
9444 }
9445 Some(Err(ErrorContext::new(
9446 "DlDpipeHeaders",
9447 r#type.and_then(|t| DlDpipeHeaders::attr_from_type(t)),
9448 self.orig_loc,
9449 self.buf.as_ptr().wrapping_add(pos) as usize,
9450 )))
9451 }
9452}
9453impl<'a> std::fmt::Debug for IterableDlDpipeHeaders<'_> {
9454 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9455 let mut fmt = f.debug_struct("DlDpipeHeaders");
9456 for attr in self.clone() {
9457 let attr = match attr {
9458 Ok(a) => a,
9459 Err(err) => {
9460 fmt.finish()?;
9461 f.write_str("Err(")?;
9462 err.fmt(f)?;
9463 return f.write_str(")");
9464 }
9465 };
9466 match attr {
9467 DlDpipeHeaders::DpipeHeader(val) => fmt.field("DpipeHeader", &val),
9468 };
9469 }
9470 fmt.finish()
9471 }
9472}
9473impl IterableDlDpipeHeaders<'_> {
9474 pub fn lookup_attr(
9475 &self,
9476 offset: usize,
9477 missing_type: Option<u16>,
9478 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
9479 let mut stack = Vec::new();
9480 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
9481 if missing_type.is_some() && cur == offset {
9482 stack.push(("DlDpipeHeaders", offset));
9483 return (
9484 stack,
9485 missing_type.and_then(|t| DlDpipeHeaders::attr_from_type(t)),
9486 );
9487 }
9488 if cur > offset || cur + self.buf.len() < offset {
9489 return (stack, None);
9490 }
9491 let mut attrs = self.clone();
9492 let mut last_off = cur + attrs.pos;
9493 let mut missing = None;
9494 while let Some(attr) = attrs.next() {
9495 let Ok(attr) = attr else { break };
9496 match attr {
9497 DlDpipeHeaders::DpipeHeader(val) => {
9498 (stack, missing) = val.lookup_attr(offset, missing_type);
9499 if !stack.is_empty() {
9500 break;
9501 }
9502 }
9503 _ => {}
9504 };
9505 last_off = cur + attrs.pos;
9506 }
9507 if !stack.is_empty() {
9508 stack.push(("DlDpipeHeaders", cur));
9509 }
9510 (stack, missing)
9511 }
9512}
9513#[derive(Clone)]
9514pub enum DlDpipeHeader<'a> {
9515 DpipeHeaderName(&'a CStr),
9516 #[doc = "Associated type: [`DpipeHeaderId`] (enum)"]
9517 DpipeHeaderId(u32),
9518 DpipeHeaderFields(IterableDlDpipeHeaderFields<'a>),
9519 DpipeHeaderGlobal(u8),
9520}
9521impl<'a> IterableDlDpipeHeader<'a> {
9522 pub fn get_dpipe_header_name(&self) -> Result<&'a CStr, ErrorContext> {
9523 let mut iter = self.clone();
9524 iter.pos = 0;
9525 for attr in iter {
9526 if let Ok(DlDpipeHeader::DpipeHeaderName(val)) = attr {
9527 return Ok(val);
9528 }
9529 }
9530 Err(ErrorContext::new_missing(
9531 "DlDpipeHeader",
9532 "DpipeHeaderName",
9533 self.orig_loc,
9534 self.buf.as_ptr() as usize,
9535 ))
9536 }
9537 #[doc = "Associated type: [`DpipeHeaderId`] (enum)"]
9538 pub fn get_dpipe_header_id(&self) -> Result<u32, ErrorContext> {
9539 let mut iter = self.clone();
9540 iter.pos = 0;
9541 for attr in iter {
9542 if let Ok(DlDpipeHeader::DpipeHeaderId(val)) = attr {
9543 return Ok(val);
9544 }
9545 }
9546 Err(ErrorContext::new_missing(
9547 "DlDpipeHeader",
9548 "DpipeHeaderId",
9549 self.orig_loc,
9550 self.buf.as_ptr() as usize,
9551 ))
9552 }
9553 pub fn get_dpipe_header_fields(&self) -> Result<IterableDlDpipeHeaderFields<'a>, ErrorContext> {
9554 let mut iter = self.clone();
9555 iter.pos = 0;
9556 for attr in iter {
9557 if let Ok(DlDpipeHeader::DpipeHeaderFields(val)) = attr {
9558 return Ok(val);
9559 }
9560 }
9561 Err(ErrorContext::new_missing(
9562 "DlDpipeHeader",
9563 "DpipeHeaderFields",
9564 self.orig_loc,
9565 self.buf.as_ptr() as usize,
9566 ))
9567 }
9568 pub fn get_dpipe_header_global(&self) -> Result<u8, ErrorContext> {
9569 let mut iter = self.clone();
9570 iter.pos = 0;
9571 for attr in iter {
9572 if let Ok(DlDpipeHeader::DpipeHeaderGlobal(val)) = attr {
9573 return Ok(val);
9574 }
9575 }
9576 Err(ErrorContext::new_missing(
9577 "DlDpipeHeader",
9578 "DpipeHeaderGlobal",
9579 self.orig_loc,
9580 self.buf.as_ptr() as usize,
9581 ))
9582 }
9583}
9584impl DlDpipeHeader<'_> {
9585 pub fn new<'a>(buf: &'a [u8]) -> IterableDlDpipeHeader<'a> {
9586 IterableDlDpipeHeader::with_loc(buf, buf.as_ptr() as usize)
9587 }
9588 fn attr_from_type(r#type: u16) -> Option<&'static str> {
9589 Devlink::attr_from_type(r#type)
9590 }
9591}
9592#[derive(Clone, Copy, Default)]
9593pub struct IterableDlDpipeHeader<'a> {
9594 buf: &'a [u8],
9595 pos: usize,
9596 orig_loc: usize,
9597}
9598impl<'a> IterableDlDpipeHeader<'a> {
9599 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
9600 Self {
9601 buf,
9602 pos: 0,
9603 orig_loc,
9604 }
9605 }
9606 pub fn get_buf(&self) -> &'a [u8] {
9607 self.buf
9608 }
9609}
9610impl<'a> Iterator for IterableDlDpipeHeader<'a> {
9611 type Item = Result<DlDpipeHeader<'a>, ErrorContext>;
9612 fn next(&mut self) -> Option<Self::Item> {
9613 let mut pos;
9614 let mut r#type;
9615 loop {
9616 pos = self.pos;
9617 r#type = None;
9618 if self.buf.len() == self.pos {
9619 return None;
9620 }
9621 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
9622 self.pos = self.buf.len();
9623 break;
9624 };
9625 r#type = Some(header.r#type);
9626 let res = match header.r#type {
9627 51u16 => DlDpipeHeader::DpipeHeaderName({
9628 let res = CStr::from_bytes_with_nul(next).ok();
9629 let Some(val) = res else { break };
9630 val
9631 }),
9632 52u16 => DlDpipeHeader::DpipeHeaderId({
9633 let res = parse_u32(next);
9634 let Some(val) = res else { break };
9635 val
9636 }),
9637 53u16 => DlDpipeHeader::DpipeHeaderFields({
9638 let res = Some(IterableDlDpipeHeaderFields::with_loc(next, self.orig_loc));
9639 let Some(val) = res else { break };
9640 val
9641 }),
9642 54u16 => DlDpipeHeader::DpipeHeaderGlobal({
9643 let res = parse_u8(next);
9644 let Some(val) = res else { break };
9645 val
9646 }),
9647 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
9648 n => continue,
9649 };
9650 return Some(Ok(res));
9651 }
9652 Some(Err(ErrorContext::new(
9653 "DlDpipeHeader",
9654 r#type.and_then(|t| DlDpipeHeader::attr_from_type(t)),
9655 self.orig_loc,
9656 self.buf.as_ptr().wrapping_add(pos) as usize,
9657 )))
9658 }
9659}
9660impl<'a> std::fmt::Debug for IterableDlDpipeHeader<'_> {
9661 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9662 let mut fmt = f.debug_struct("DlDpipeHeader");
9663 for attr in self.clone() {
9664 let attr = match attr {
9665 Ok(a) => a,
9666 Err(err) => {
9667 fmt.finish()?;
9668 f.write_str("Err(")?;
9669 err.fmt(f)?;
9670 return f.write_str(")");
9671 }
9672 };
9673 match attr {
9674 DlDpipeHeader::DpipeHeaderName(val) => fmt.field("DpipeHeaderName", &val),
9675 DlDpipeHeader::DpipeHeaderId(val) => fmt.field(
9676 "DpipeHeaderId",
9677 &FormatEnum(val.into(), DpipeHeaderId::from_value),
9678 ),
9679 DlDpipeHeader::DpipeHeaderFields(val) => fmt.field("DpipeHeaderFields", &val),
9680 DlDpipeHeader::DpipeHeaderGlobal(val) => fmt.field("DpipeHeaderGlobal", &val),
9681 };
9682 }
9683 fmt.finish()
9684 }
9685}
9686impl IterableDlDpipeHeader<'_> {
9687 pub fn lookup_attr(
9688 &self,
9689 offset: usize,
9690 missing_type: Option<u16>,
9691 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
9692 let mut stack = Vec::new();
9693 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
9694 if missing_type.is_some() && cur == offset {
9695 stack.push(("DlDpipeHeader", offset));
9696 return (
9697 stack,
9698 missing_type.and_then(|t| DlDpipeHeader::attr_from_type(t)),
9699 );
9700 }
9701 if cur > offset || cur + self.buf.len() < offset {
9702 return (stack, None);
9703 }
9704 let mut attrs = self.clone();
9705 let mut last_off = cur + attrs.pos;
9706 let mut missing = None;
9707 while let Some(attr) = attrs.next() {
9708 let Ok(attr) = attr else { break };
9709 match attr {
9710 DlDpipeHeader::DpipeHeaderName(val) => {
9711 if last_off == offset {
9712 stack.push(("DpipeHeaderName", last_off));
9713 break;
9714 }
9715 }
9716 DlDpipeHeader::DpipeHeaderId(val) => {
9717 if last_off == offset {
9718 stack.push(("DpipeHeaderId", last_off));
9719 break;
9720 }
9721 }
9722 DlDpipeHeader::DpipeHeaderFields(val) => {
9723 (stack, missing) = val.lookup_attr(offset, missing_type);
9724 if !stack.is_empty() {
9725 break;
9726 }
9727 }
9728 DlDpipeHeader::DpipeHeaderGlobal(val) => {
9729 if last_off == offset {
9730 stack.push(("DpipeHeaderGlobal", last_off));
9731 break;
9732 }
9733 }
9734 _ => {}
9735 };
9736 last_off = cur + attrs.pos;
9737 }
9738 if !stack.is_empty() {
9739 stack.push(("DlDpipeHeader", cur));
9740 }
9741 (stack, missing)
9742 }
9743}
9744#[derive(Clone)]
9745pub enum DlDpipeHeaderFields<'a> {
9746 #[doc = "Attribute may repeat multiple times (treat it as array)"]
9747 DpipeField(IterableDlDpipeField<'a>),
9748}
9749impl<'a> IterableDlDpipeHeaderFields<'a> {
9750 #[doc = "Attribute may repeat multiple times (treat it as array)"]
9751 pub fn get_dpipe_field(
9752 &self,
9753 ) -> MultiAttrIterable<Self, DlDpipeHeaderFields<'a>, IterableDlDpipeField<'a>> {
9754 MultiAttrIterable::new(self.clone(), |variant| {
9755 if let DlDpipeHeaderFields::DpipeField(val) = variant {
9756 Some(val)
9757 } else {
9758 None
9759 }
9760 })
9761 }
9762}
9763impl DlDpipeHeaderFields<'_> {
9764 pub fn new<'a>(buf: &'a [u8]) -> IterableDlDpipeHeaderFields<'a> {
9765 IterableDlDpipeHeaderFields::with_loc(buf, buf.as_ptr() as usize)
9766 }
9767 fn attr_from_type(r#type: u16) -> Option<&'static str> {
9768 Devlink::attr_from_type(r#type)
9769 }
9770}
9771#[derive(Clone, Copy, Default)]
9772pub struct IterableDlDpipeHeaderFields<'a> {
9773 buf: &'a [u8],
9774 pos: usize,
9775 orig_loc: usize,
9776}
9777impl<'a> IterableDlDpipeHeaderFields<'a> {
9778 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
9779 Self {
9780 buf,
9781 pos: 0,
9782 orig_loc,
9783 }
9784 }
9785 pub fn get_buf(&self) -> &'a [u8] {
9786 self.buf
9787 }
9788}
9789impl<'a> Iterator for IterableDlDpipeHeaderFields<'a> {
9790 type Item = Result<DlDpipeHeaderFields<'a>, ErrorContext>;
9791 fn next(&mut self) -> Option<Self::Item> {
9792 let mut pos;
9793 let mut r#type;
9794 loop {
9795 pos = self.pos;
9796 r#type = None;
9797 if self.buf.len() == self.pos {
9798 return None;
9799 }
9800 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
9801 self.pos = self.buf.len();
9802 break;
9803 };
9804 r#type = Some(header.r#type);
9805 let res = match header.r#type {
9806 56u16 => DlDpipeHeaderFields::DpipeField({
9807 let res = Some(IterableDlDpipeField::with_loc(next, self.orig_loc));
9808 let Some(val) = res else { break };
9809 val
9810 }),
9811 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
9812 n => continue,
9813 };
9814 return Some(Ok(res));
9815 }
9816 Some(Err(ErrorContext::new(
9817 "DlDpipeHeaderFields",
9818 r#type.and_then(|t| DlDpipeHeaderFields::attr_from_type(t)),
9819 self.orig_loc,
9820 self.buf.as_ptr().wrapping_add(pos) as usize,
9821 )))
9822 }
9823}
9824impl<'a> std::fmt::Debug for IterableDlDpipeHeaderFields<'_> {
9825 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9826 let mut fmt = f.debug_struct("DlDpipeHeaderFields");
9827 for attr in self.clone() {
9828 let attr = match attr {
9829 Ok(a) => a,
9830 Err(err) => {
9831 fmt.finish()?;
9832 f.write_str("Err(")?;
9833 err.fmt(f)?;
9834 return f.write_str(")");
9835 }
9836 };
9837 match attr {
9838 DlDpipeHeaderFields::DpipeField(val) => fmt.field("DpipeField", &val),
9839 };
9840 }
9841 fmt.finish()
9842 }
9843}
9844impl IterableDlDpipeHeaderFields<'_> {
9845 pub fn lookup_attr(
9846 &self,
9847 offset: usize,
9848 missing_type: Option<u16>,
9849 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
9850 let mut stack = Vec::new();
9851 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
9852 if missing_type.is_some() && cur == offset {
9853 stack.push(("DlDpipeHeaderFields", offset));
9854 return (
9855 stack,
9856 missing_type.and_then(|t| DlDpipeHeaderFields::attr_from_type(t)),
9857 );
9858 }
9859 if cur > offset || cur + self.buf.len() < offset {
9860 return (stack, None);
9861 }
9862 let mut attrs = self.clone();
9863 let mut last_off = cur + attrs.pos;
9864 let mut missing = None;
9865 while let Some(attr) = attrs.next() {
9866 let Ok(attr) = attr else { break };
9867 match attr {
9868 DlDpipeHeaderFields::DpipeField(val) => {
9869 (stack, missing) = val.lookup_attr(offset, missing_type);
9870 if !stack.is_empty() {
9871 break;
9872 }
9873 }
9874 _ => {}
9875 };
9876 last_off = cur + attrs.pos;
9877 }
9878 if !stack.is_empty() {
9879 stack.push(("DlDpipeHeaderFields", cur));
9880 }
9881 (stack, missing)
9882 }
9883}
9884#[derive(Clone)]
9885pub enum DlDpipeField<'a> {
9886 DpipeFieldName(&'a CStr),
9887 DpipeFieldId(u32),
9888 DpipeFieldBitwidth(u32),
9889 #[doc = "Associated type: [`DpipeFieldMappingType`] (enum)"]
9890 DpipeFieldMappingType(u32),
9891}
9892impl<'a> IterableDlDpipeField<'a> {
9893 pub fn get_dpipe_field_name(&self) -> Result<&'a CStr, ErrorContext> {
9894 let mut iter = self.clone();
9895 iter.pos = 0;
9896 for attr in iter {
9897 if let Ok(DlDpipeField::DpipeFieldName(val)) = attr {
9898 return Ok(val);
9899 }
9900 }
9901 Err(ErrorContext::new_missing(
9902 "DlDpipeField",
9903 "DpipeFieldName",
9904 self.orig_loc,
9905 self.buf.as_ptr() as usize,
9906 ))
9907 }
9908 pub fn get_dpipe_field_id(&self) -> Result<u32, ErrorContext> {
9909 let mut iter = self.clone();
9910 iter.pos = 0;
9911 for attr in iter {
9912 if let Ok(DlDpipeField::DpipeFieldId(val)) = attr {
9913 return Ok(val);
9914 }
9915 }
9916 Err(ErrorContext::new_missing(
9917 "DlDpipeField",
9918 "DpipeFieldId",
9919 self.orig_loc,
9920 self.buf.as_ptr() as usize,
9921 ))
9922 }
9923 pub fn get_dpipe_field_bitwidth(&self) -> Result<u32, ErrorContext> {
9924 let mut iter = self.clone();
9925 iter.pos = 0;
9926 for attr in iter {
9927 if let Ok(DlDpipeField::DpipeFieldBitwidth(val)) = attr {
9928 return Ok(val);
9929 }
9930 }
9931 Err(ErrorContext::new_missing(
9932 "DlDpipeField",
9933 "DpipeFieldBitwidth",
9934 self.orig_loc,
9935 self.buf.as_ptr() as usize,
9936 ))
9937 }
9938 #[doc = "Associated type: [`DpipeFieldMappingType`] (enum)"]
9939 pub fn get_dpipe_field_mapping_type(&self) -> Result<u32, ErrorContext> {
9940 let mut iter = self.clone();
9941 iter.pos = 0;
9942 for attr in iter {
9943 if let Ok(DlDpipeField::DpipeFieldMappingType(val)) = attr {
9944 return Ok(val);
9945 }
9946 }
9947 Err(ErrorContext::new_missing(
9948 "DlDpipeField",
9949 "DpipeFieldMappingType",
9950 self.orig_loc,
9951 self.buf.as_ptr() as usize,
9952 ))
9953 }
9954}
9955impl DlDpipeField<'_> {
9956 pub fn new<'a>(buf: &'a [u8]) -> IterableDlDpipeField<'a> {
9957 IterableDlDpipeField::with_loc(buf, buf.as_ptr() as usize)
9958 }
9959 fn attr_from_type(r#type: u16) -> Option<&'static str> {
9960 Devlink::attr_from_type(r#type)
9961 }
9962}
9963#[derive(Clone, Copy, Default)]
9964pub struct IterableDlDpipeField<'a> {
9965 buf: &'a [u8],
9966 pos: usize,
9967 orig_loc: usize,
9968}
9969impl<'a> IterableDlDpipeField<'a> {
9970 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
9971 Self {
9972 buf,
9973 pos: 0,
9974 orig_loc,
9975 }
9976 }
9977 pub fn get_buf(&self) -> &'a [u8] {
9978 self.buf
9979 }
9980}
9981impl<'a> Iterator for IterableDlDpipeField<'a> {
9982 type Item = Result<DlDpipeField<'a>, ErrorContext>;
9983 fn next(&mut self) -> Option<Self::Item> {
9984 let mut pos;
9985 let mut r#type;
9986 loop {
9987 pos = self.pos;
9988 r#type = None;
9989 if self.buf.len() == self.pos {
9990 return None;
9991 }
9992 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
9993 self.pos = self.buf.len();
9994 break;
9995 };
9996 r#type = Some(header.r#type);
9997 let res = match header.r#type {
9998 57u16 => DlDpipeField::DpipeFieldName({
9999 let res = CStr::from_bytes_with_nul(next).ok();
10000 let Some(val) = res else { break };
10001 val
10002 }),
10003 58u16 => DlDpipeField::DpipeFieldId({
10004 let res = parse_u32(next);
10005 let Some(val) = res else { break };
10006 val
10007 }),
10008 59u16 => DlDpipeField::DpipeFieldBitwidth({
10009 let res = parse_u32(next);
10010 let Some(val) = res else { break };
10011 val
10012 }),
10013 60u16 => DlDpipeField::DpipeFieldMappingType({
10014 let res = parse_u32(next);
10015 let Some(val) = res else { break };
10016 val
10017 }),
10018 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
10019 n => continue,
10020 };
10021 return Some(Ok(res));
10022 }
10023 Some(Err(ErrorContext::new(
10024 "DlDpipeField",
10025 r#type.and_then(|t| DlDpipeField::attr_from_type(t)),
10026 self.orig_loc,
10027 self.buf.as_ptr().wrapping_add(pos) as usize,
10028 )))
10029 }
10030}
10031impl<'a> std::fmt::Debug for IterableDlDpipeField<'_> {
10032 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10033 let mut fmt = f.debug_struct("DlDpipeField");
10034 for attr in self.clone() {
10035 let attr = match attr {
10036 Ok(a) => a,
10037 Err(err) => {
10038 fmt.finish()?;
10039 f.write_str("Err(")?;
10040 err.fmt(f)?;
10041 return f.write_str(")");
10042 }
10043 };
10044 match attr {
10045 DlDpipeField::DpipeFieldName(val) => fmt.field("DpipeFieldName", &val),
10046 DlDpipeField::DpipeFieldId(val) => fmt.field("DpipeFieldId", &val),
10047 DlDpipeField::DpipeFieldBitwidth(val) => fmt.field("DpipeFieldBitwidth", &val),
10048 DlDpipeField::DpipeFieldMappingType(val) => fmt.field(
10049 "DpipeFieldMappingType",
10050 &FormatEnum(val.into(), DpipeFieldMappingType::from_value),
10051 ),
10052 };
10053 }
10054 fmt.finish()
10055 }
10056}
10057impl IterableDlDpipeField<'_> {
10058 pub fn lookup_attr(
10059 &self,
10060 offset: usize,
10061 missing_type: Option<u16>,
10062 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
10063 let mut stack = Vec::new();
10064 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
10065 if missing_type.is_some() && cur == offset {
10066 stack.push(("DlDpipeField", offset));
10067 return (
10068 stack,
10069 missing_type.and_then(|t| DlDpipeField::attr_from_type(t)),
10070 );
10071 }
10072 if cur > offset || cur + self.buf.len() < offset {
10073 return (stack, None);
10074 }
10075 let mut attrs = self.clone();
10076 let mut last_off = cur + attrs.pos;
10077 while let Some(attr) = attrs.next() {
10078 let Ok(attr) = attr else { break };
10079 match attr {
10080 DlDpipeField::DpipeFieldName(val) => {
10081 if last_off == offset {
10082 stack.push(("DpipeFieldName", last_off));
10083 break;
10084 }
10085 }
10086 DlDpipeField::DpipeFieldId(val) => {
10087 if last_off == offset {
10088 stack.push(("DpipeFieldId", last_off));
10089 break;
10090 }
10091 }
10092 DlDpipeField::DpipeFieldBitwidth(val) => {
10093 if last_off == offset {
10094 stack.push(("DpipeFieldBitwidth", last_off));
10095 break;
10096 }
10097 }
10098 DlDpipeField::DpipeFieldMappingType(val) => {
10099 if last_off == offset {
10100 stack.push(("DpipeFieldMappingType", last_off));
10101 break;
10102 }
10103 }
10104 _ => {}
10105 };
10106 last_off = cur + attrs.pos;
10107 }
10108 if !stack.is_empty() {
10109 stack.push(("DlDpipeField", cur));
10110 }
10111 (stack, None)
10112 }
10113}
10114#[derive(Clone)]
10115pub enum DlResource<'a> {
10116 ResourceName(&'a CStr),
10117 ResourceId(u64),
10118 ResourceSize(u64),
10119 ResourceSizeNew(u64),
10120 ResourceSizeValid(u8),
10121 ResourceSizeMin(u64),
10122 ResourceSizeMax(u64),
10123 ResourceSizeGran(u64),
10124 #[doc = "Associated type: [`ResourceUnit`] (enum)"]
10125 ResourceUnit(u8),
10126 ResourceOcc(u64),
10127}
10128impl<'a> IterableDlResource<'a> {
10129 pub fn get_resource_name(&self) -> Result<&'a CStr, ErrorContext> {
10130 let mut iter = self.clone();
10131 iter.pos = 0;
10132 for attr in iter {
10133 if let Ok(DlResource::ResourceName(val)) = attr {
10134 return Ok(val);
10135 }
10136 }
10137 Err(ErrorContext::new_missing(
10138 "DlResource",
10139 "ResourceName",
10140 self.orig_loc,
10141 self.buf.as_ptr() as usize,
10142 ))
10143 }
10144 pub fn get_resource_id(&self) -> Result<u64, ErrorContext> {
10145 let mut iter = self.clone();
10146 iter.pos = 0;
10147 for attr in iter {
10148 if let Ok(DlResource::ResourceId(val)) = attr {
10149 return Ok(val);
10150 }
10151 }
10152 Err(ErrorContext::new_missing(
10153 "DlResource",
10154 "ResourceId",
10155 self.orig_loc,
10156 self.buf.as_ptr() as usize,
10157 ))
10158 }
10159 pub fn get_resource_size(&self) -> Result<u64, ErrorContext> {
10160 let mut iter = self.clone();
10161 iter.pos = 0;
10162 for attr in iter {
10163 if let Ok(DlResource::ResourceSize(val)) = attr {
10164 return Ok(val);
10165 }
10166 }
10167 Err(ErrorContext::new_missing(
10168 "DlResource",
10169 "ResourceSize",
10170 self.orig_loc,
10171 self.buf.as_ptr() as usize,
10172 ))
10173 }
10174 pub fn get_resource_size_new(&self) -> Result<u64, ErrorContext> {
10175 let mut iter = self.clone();
10176 iter.pos = 0;
10177 for attr in iter {
10178 if let Ok(DlResource::ResourceSizeNew(val)) = attr {
10179 return Ok(val);
10180 }
10181 }
10182 Err(ErrorContext::new_missing(
10183 "DlResource",
10184 "ResourceSizeNew",
10185 self.orig_loc,
10186 self.buf.as_ptr() as usize,
10187 ))
10188 }
10189 pub fn get_resource_size_valid(&self) -> Result<u8, ErrorContext> {
10190 let mut iter = self.clone();
10191 iter.pos = 0;
10192 for attr in iter {
10193 if let Ok(DlResource::ResourceSizeValid(val)) = attr {
10194 return Ok(val);
10195 }
10196 }
10197 Err(ErrorContext::new_missing(
10198 "DlResource",
10199 "ResourceSizeValid",
10200 self.orig_loc,
10201 self.buf.as_ptr() as usize,
10202 ))
10203 }
10204 pub fn get_resource_size_min(&self) -> Result<u64, ErrorContext> {
10205 let mut iter = self.clone();
10206 iter.pos = 0;
10207 for attr in iter {
10208 if let Ok(DlResource::ResourceSizeMin(val)) = attr {
10209 return Ok(val);
10210 }
10211 }
10212 Err(ErrorContext::new_missing(
10213 "DlResource",
10214 "ResourceSizeMin",
10215 self.orig_loc,
10216 self.buf.as_ptr() as usize,
10217 ))
10218 }
10219 pub fn get_resource_size_max(&self) -> Result<u64, ErrorContext> {
10220 let mut iter = self.clone();
10221 iter.pos = 0;
10222 for attr in iter {
10223 if let Ok(DlResource::ResourceSizeMax(val)) = attr {
10224 return Ok(val);
10225 }
10226 }
10227 Err(ErrorContext::new_missing(
10228 "DlResource",
10229 "ResourceSizeMax",
10230 self.orig_loc,
10231 self.buf.as_ptr() as usize,
10232 ))
10233 }
10234 pub fn get_resource_size_gran(&self) -> Result<u64, ErrorContext> {
10235 let mut iter = self.clone();
10236 iter.pos = 0;
10237 for attr in iter {
10238 if let Ok(DlResource::ResourceSizeGran(val)) = attr {
10239 return Ok(val);
10240 }
10241 }
10242 Err(ErrorContext::new_missing(
10243 "DlResource",
10244 "ResourceSizeGran",
10245 self.orig_loc,
10246 self.buf.as_ptr() as usize,
10247 ))
10248 }
10249 #[doc = "Associated type: [`ResourceUnit`] (enum)"]
10250 pub fn get_resource_unit(&self) -> Result<u8, ErrorContext> {
10251 let mut iter = self.clone();
10252 iter.pos = 0;
10253 for attr in iter {
10254 if let Ok(DlResource::ResourceUnit(val)) = attr {
10255 return Ok(val);
10256 }
10257 }
10258 Err(ErrorContext::new_missing(
10259 "DlResource",
10260 "ResourceUnit",
10261 self.orig_loc,
10262 self.buf.as_ptr() as usize,
10263 ))
10264 }
10265 pub fn get_resource_occ(&self) -> Result<u64, ErrorContext> {
10266 let mut iter = self.clone();
10267 iter.pos = 0;
10268 for attr in iter {
10269 if let Ok(DlResource::ResourceOcc(val)) = attr {
10270 return Ok(val);
10271 }
10272 }
10273 Err(ErrorContext::new_missing(
10274 "DlResource",
10275 "ResourceOcc",
10276 self.orig_loc,
10277 self.buf.as_ptr() as usize,
10278 ))
10279 }
10280}
10281impl DlResource<'_> {
10282 pub fn new<'a>(buf: &'a [u8]) -> IterableDlResource<'a> {
10283 IterableDlResource::with_loc(buf, buf.as_ptr() as usize)
10284 }
10285 fn attr_from_type(r#type: u16) -> Option<&'static str> {
10286 Devlink::attr_from_type(r#type)
10287 }
10288}
10289#[derive(Clone, Copy, Default)]
10290pub struct IterableDlResource<'a> {
10291 buf: &'a [u8],
10292 pos: usize,
10293 orig_loc: usize,
10294}
10295impl<'a> IterableDlResource<'a> {
10296 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
10297 Self {
10298 buf,
10299 pos: 0,
10300 orig_loc,
10301 }
10302 }
10303 pub fn get_buf(&self) -> &'a [u8] {
10304 self.buf
10305 }
10306}
10307impl<'a> Iterator for IterableDlResource<'a> {
10308 type Item = Result<DlResource<'a>, ErrorContext>;
10309 fn next(&mut self) -> Option<Self::Item> {
10310 let mut pos;
10311 let mut r#type;
10312 loop {
10313 pos = self.pos;
10314 r#type = None;
10315 if self.buf.len() == self.pos {
10316 return None;
10317 }
10318 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
10319 self.pos = self.buf.len();
10320 break;
10321 };
10322 r#type = Some(header.r#type);
10323 let res = match header.r#type {
10324 65u16 => DlResource::ResourceName({
10325 let res = CStr::from_bytes_with_nul(next).ok();
10326 let Some(val) = res else { break };
10327 val
10328 }),
10329 66u16 => DlResource::ResourceId({
10330 let res = parse_u64(next);
10331 let Some(val) = res else { break };
10332 val
10333 }),
10334 67u16 => DlResource::ResourceSize({
10335 let res = parse_u64(next);
10336 let Some(val) = res else { break };
10337 val
10338 }),
10339 68u16 => DlResource::ResourceSizeNew({
10340 let res = parse_u64(next);
10341 let Some(val) = res else { break };
10342 val
10343 }),
10344 69u16 => DlResource::ResourceSizeValid({
10345 let res = parse_u8(next);
10346 let Some(val) = res else { break };
10347 val
10348 }),
10349 70u16 => DlResource::ResourceSizeMin({
10350 let res = parse_u64(next);
10351 let Some(val) = res else { break };
10352 val
10353 }),
10354 71u16 => DlResource::ResourceSizeMax({
10355 let res = parse_u64(next);
10356 let Some(val) = res else { break };
10357 val
10358 }),
10359 72u16 => DlResource::ResourceSizeGran({
10360 let res = parse_u64(next);
10361 let Some(val) = res else { break };
10362 val
10363 }),
10364 73u16 => DlResource::ResourceUnit({
10365 let res = parse_u8(next);
10366 let Some(val) = res else { break };
10367 val
10368 }),
10369 74u16 => DlResource::ResourceOcc({
10370 let res = parse_u64(next);
10371 let Some(val) = res else { break };
10372 val
10373 }),
10374 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
10375 n => continue,
10376 };
10377 return Some(Ok(res));
10378 }
10379 Some(Err(ErrorContext::new(
10380 "DlResource",
10381 r#type.and_then(|t| DlResource::attr_from_type(t)),
10382 self.orig_loc,
10383 self.buf.as_ptr().wrapping_add(pos) as usize,
10384 )))
10385 }
10386}
10387impl<'a> std::fmt::Debug for IterableDlResource<'_> {
10388 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10389 let mut fmt = f.debug_struct("DlResource");
10390 for attr in self.clone() {
10391 let attr = match attr {
10392 Ok(a) => a,
10393 Err(err) => {
10394 fmt.finish()?;
10395 f.write_str("Err(")?;
10396 err.fmt(f)?;
10397 return f.write_str(")");
10398 }
10399 };
10400 match attr {
10401 DlResource::ResourceName(val) => fmt.field("ResourceName", &val),
10402 DlResource::ResourceId(val) => fmt.field("ResourceId", &val),
10403 DlResource::ResourceSize(val) => fmt.field("ResourceSize", &val),
10404 DlResource::ResourceSizeNew(val) => fmt.field("ResourceSizeNew", &val),
10405 DlResource::ResourceSizeValid(val) => fmt.field("ResourceSizeValid", &val),
10406 DlResource::ResourceSizeMin(val) => fmt.field("ResourceSizeMin", &val),
10407 DlResource::ResourceSizeMax(val) => fmt.field("ResourceSizeMax", &val),
10408 DlResource::ResourceSizeGran(val) => fmt.field("ResourceSizeGran", &val),
10409 DlResource::ResourceUnit(val) => fmt.field(
10410 "ResourceUnit",
10411 &FormatEnum(val.into(), ResourceUnit::from_value),
10412 ),
10413 DlResource::ResourceOcc(val) => fmt.field("ResourceOcc", &val),
10414 };
10415 }
10416 fmt.finish()
10417 }
10418}
10419impl IterableDlResource<'_> {
10420 pub fn lookup_attr(
10421 &self,
10422 offset: usize,
10423 missing_type: Option<u16>,
10424 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
10425 let mut stack = Vec::new();
10426 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
10427 if missing_type.is_some() && cur == offset {
10428 stack.push(("DlResource", offset));
10429 return (
10430 stack,
10431 missing_type.and_then(|t| DlResource::attr_from_type(t)),
10432 );
10433 }
10434 if cur > offset || cur + self.buf.len() < offset {
10435 return (stack, None);
10436 }
10437 let mut attrs = self.clone();
10438 let mut last_off = cur + attrs.pos;
10439 while let Some(attr) = attrs.next() {
10440 let Ok(attr) = attr else { break };
10441 match attr {
10442 DlResource::ResourceName(val) => {
10443 if last_off == offset {
10444 stack.push(("ResourceName", last_off));
10445 break;
10446 }
10447 }
10448 DlResource::ResourceId(val) => {
10449 if last_off == offset {
10450 stack.push(("ResourceId", last_off));
10451 break;
10452 }
10453 }
10454 DlResource::ResourceSize(val) => {
10455 if last_off == offset {
10456 stack.push(("ResourceSize", last_off));
10457 break;
10458 }
10459 }
10460 DlResource::ResourceSizeNew(val) => {
10461 if last_off == offset {
10462 stack.push(("ResourceSizeNew", last_off));
10463 break;
10464 }
10465 }
10466 DlResource::ResourceSizeValid(val) => {
10467 if last_off == offset {
10468 stack.push(("ResourceSizeValid", last_off));
10469 break;
10470 }
10471 }
10472 DlResource::ResourceSizeMin(val) => {
10473 if last_off == offset {
10474 stack.push(("ResourceSizeMin", last_off));
10475 break;
10476 }
10477 }
10478 DlResource::ResourceSizeMax(val) => {
10479 if last_off == offset {
10480 stack.push(("ResourceSizeMax", last_off));
10481 break;
10482 }
10483 }
10484 DlResource::ResourceSizeGran(val) => {
10485 if last_off == offset {
10486 stack.push(("ResourceSizeGran", last_off));
10487 break;
10488 }
10489 }
10490 DlResource::ResourceUnit(val) => {
10491 if last_off == offset {
10492 stack.push(("ResourceUnit", last_off));
10493 break;
10494 }
10495 }
10496 DlResource::ResourceOcc(val) => {
10497 if last_off == offset {
10498 stack.push(("ResourceOcc", last_off));
10499 break;
10500 }
10501 }
10502 _ => {}
10503 };
10504 last_off = cur + attrs.pos;
10505 }
10506 if !stack.is_empty() {
10507 stack.push(("DlResource", cur));
10508 }
10509 (stack, None)
10510 }
10511}
10512#[derive(Clone)]
10513pub enum DlResourceList<'a> {
10514 #[doc = "Attribute may repeat multiple times (treat it as array)"]
10515 Resource(IterableDlResource<'a>),
10516}
10517impl<'a> IterableDlResourceList<'a> {
10518 #[doc = "Attribute may repeat multiple times (treat it as array)"]
10519 pub fn get_resource(
10520 &self,
10521 ) -> MultiAttrIterable<Self, DlResourceList<'a>, IterableDlResource<'a>> {
10522 MultiAttrIterable::new(self.clone(), |variant| {
10523 if let DlResourceList::Resource(val) = variant {
10524 Some(val)
10525 } else {
10526 None
10527 }
10528 })
10529 }
10530}
10531impl DlResourceList<'_> {
10532 pub fn new<'a>(buf: &'a [u8]) -> IterableDlResourceList<'a> {
10533 IterableDlResourceList::with_loc(buf, buf.as_ptr() as usize)
10534 }
10535 fn attr_from_type(r#type: u16) -> Option<&'static str> {
10536 Devlink::attr_from_type(r#type)
10537 }
10538}
10539#[derive(Clone, Copy, Default)]
10540pub struct IterableDlResourceList<'a> {
10541 buf: &'a [u8],
10542 pos: usize,
10543 orig_loc: usize,
10544}
10545impl<'a> IterableDlResourceList<'a> {
10546 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
10547 Self {
10548 buf,
10549 pos: 0,
10550 orig_loc,
10551 }
10552 }
10553 pub fn get_buf(&self) -> &'a [u8] {
10554 self.buf
10555 }
10556}
10557impl<'a> Iterator for IterableDlResourceList<'a> {
10558 type Item = Result<DlResourceList<'a>, ErrorContext>;
10559 fn next(&mut self) -> Option<Self::Item> {
10560 let mut pos;
10561 let mut r#type;
10562 loop {
10563 pos = self.pos;
10564 r#type = None;
10565 if self.buf.len() == self.pos {
10566 return None;
10567 }
10568 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
10569 self.pos = self.buf.len();
10570 break;
10571 };
10572 r#type = Some(header.r#type);
10573 let res = match header.r#type {
10574 64u16 => DlResourceList::Resource({
10575 let res = Some(IterableDlResource::with_loc(next, self.orig_loc));
10576 let Some(val) = res else { break };
10577 val
10578 }),
10579 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
10580 n => continue,
10581 };
10582 return Some(Ok(res));
10583 }
10584 Some(Err(ErrorContext::new(
10585 "DlResourceList",
10586 r#type.and_then(|t| DlResourceList::attr_from_type(t)),
10587 self.orig_loc,
10588 self.buf.as_ptr().wrapping_add(pos) as usize,
10589 )))
10590 }
10591}
10592impl<'a> std::fmt::Debug for IterableDlResourceList<'_> {
10593 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10594 let mut fmt = f.debug_struct("DlResourceList");
10595 for attr in self.clone() {
10596 let attr = match attr {
10597 Ok(a) => a,
10598 Err(err) => {
10599 fmt.finish()?;
10600 f.write_str("Err(")?;
10601 err.fmt(f)?;
10602 return f.write_str(")");
10603 }
10604 };
10605 match attr {
10606 DlResourceList::Resource(val) => fmt.field("Resource", &val),
10607 };
10608 }
10609 fmt.finish()
10610 }
10611}
10612impl IterableDlResourceList<'_> {
10613 pub fn lookup_attr(
10614 &self,
10615 offset: usize,
10616 missing_type: Option<u16>,
10617 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
10618 let mut stack = Vec::new();
10619 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
10620 if missing_type.is_some() && cur == offset {
10621 stack.push(("DlResourceList", offset));
10622 return (
10623 stack,
10624 missing_type.and_then(|t| DlResourceList::attr_from_type(t)),
10625 );
10626 }
10627 if cur > offset || cur + self.buf.len() < offset {
10628 return (stack, None);
10629 }
10630 let mut attrs = self.clone();
10631 let mut last_off = cur + attrs.pos;
10632 let mut missing = None;
10633 while let Some(attr) = attrs.next() {
10634 let Ok(attr) = attr else { break };
10635 match attr {
10636 DlResourceList::Resource(val) => {
10637 (stack, missing) = val.lookup_attr(offset, missing_type);
10638 if !stack.is_empty() {
10639 break;
10640 }
10641 }
10642 _ => {}
10643 };
10644 last_off = cur + attrs.pos;
10645 }
10646 if !stack.is_empty() {
10647 stack.push(("DlResourceList", cur));
10648 }
10649 (stack, missing)
10650 }
10651}
10652#[derive(Clone)]
10653pub enum DlParam<'a> {
10654 ParamName(&'a CStr),
10655 ParamGeneric(()),
10656 #[doc = "Associated type: [`VarAttrType`] (enum)"]
10657 ParamType(u8),
10658}
10659impl<'a> IterableDlParam<'a> {
10660 pub fn get_param_name(&self) -> Result<&'a CStr, ErrorContext> {
10661 let mut iter = self.clone();
10662 iter.pos = 0;
10663 for attr in iter {
10664 if let Ok(DlParam::ParamName(val)) = attr {
10665 return Ok(val);
10666 }
10667 }
10668 Err(ErrorContext::new_missing(
10669 "DlParam",
10670 "ParamName",
10671 self.orig_loc,
10672 self.buf.as_ptr() as usize,
10673 ))
10674 }
10675 pub fn get_param_generic(&self) -> Result<(), ErrorContext> {
10676 let mut iter = self.clone();
10677 iter.pos = 0;
10678 for attr in iter {
10679 if let Ok(DlParam::ParamGeneric(val)) = attr {
10680 return Ok(val);
10681 }
10682 }
10683 Err(ErrorContext::new_missing(
10684 "DlParam",
10685 "ParamGeneric",
10686 self.orig_loc,
10687 self.buf.as_ptr() as usize,
10688 ))
10689 }
10690 #[doc = "Associated type: [`VarAttrType`] (enum)"]
10691 pub fn get_param_type(&self) -> Result<u8, ErrorContext> {
10692 let mut iter = self.clone();
10693 iter.pos = 0;
10694 for attr in iter {
10695 if let Ok(DlParam::ParamType(val)) = attr {
10696 return Ok(val);
10697 }
10698 }
10699 Err(ErrorContext::new_missing(
10700 "DlParam",
10701 "ParamType",
10702 self.orig_loc,
10703 self.buf.as_ptr() as usize,
10704 ))
10705 }
10706}
10707impl DlParam<'_> {
10708 pub fn new<'a>(buf: &'a [u8]) -> IterableDlParam<'a> {
10709 IterableDlParam::with_loc(buf, buf.as_ptr() as usize)
10710 }
10711 fn attr_from_type(r#type: u16) -> Option<&'static str> {
10712 Devlink::attr_from_type(r#type)
10713 }
10714}
10715#[derive(Clone, Copy, Default)]
10716pub struct IterableDlParam<'a> {
10717 buf: &'a [u8],
10718 pos: usize,
10719 orig_loc: usize,
10720}
10721impl<'a> IterableDlParam<'a> {
10722 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
10723 Self {
10724 buf,
10725 pos: 0,
10726 orig_loc,
10727 }
10728 }
10729 pub fn get_buf(&self) -> &'a [u8] {
10730 self.buf
10731 }
10732}
10733impl<'a> Iterator for IterableDlParam<'a> {
10734 type Item = Result<DlParam<'a>, ErrorContext>;
10735 fn next(&mut self) -> Option<Self::Item> {
10736 let mut pos;
10737 let mut r#type;
10738 loop {
10739 pos = self.pos;
10740 r#type = None;
10741 if self.buf.len() == self.pos {
10742 return None;
10743 }
10744 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
10745 self.pos = self.buf.len();
10746 break;
10747 };
10748 r#type = Some(header.r#type);
10749 let res = match header.r#type {
10750 81u16 => DlParam::ParamName({
10751 let res = CStr::from_bytes_with_nul(next).ok();
10752 let Some(val) = res else { break };
10753 val
10754 }),
10755 82u16 => DlParam::ParamGeneric(()),
10756 83u16 => DlParam::ParamType({
10757 let res = parse_u8(next);
10758 let Some(val) = res else { break };
10759 val
10760 }),
10761 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
10762 n => continue,
10763 };
10764 return Some(Ok(res));
10765 }
10766 Some(Err(ErrorContext::new(
10767 "DlParam",
10768 r#type.and_then(|t| DlParam::attr_from_type(t)),
10769 self.orig_loc,
10770 self.buf.as_ptr().wrapping_add(pos) as usize,
10771 )))
10772 }
10773}
10774impl<'a> std::fmt::Debug for IterableDlParam<'_> {
10775 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10776 let mut fmt = f.debug_struct("DlParam");
10777 for attr in self.clone() {
10778 let attr = match attr {
10779 Ok(a) => a,
10780 Err(err) => {
10781 fmt.finish()?;
10782 f.write_str("Err(")?;
10783 err.fmt(f)?;
10784 return f.write_str(")");
10785 }
10786 };
10787 match attr {
10788 DlParam::ParamName(val) => fmt.field("ParamName", &val),
10789 DlParam::ParamGeneric(val) => fmt.field("ParamGeneric", &val),
10790 DlParam::ParamType(val) => fmt.field(
10791 "ParamType",
10792 &FormatEnum(val.into(), VarAttrType::from_value),
10793 ),
10794 };
10795 }
10796 fmt.finish()
10797 }
10798}
10799impl IterableDlParam<'_> {
10800 pub fn lookup_attr(
10801 &self,
10802 offset: usize,
10803 missing_type: Option<u16>,
10804 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
10805 let mut stack = Vec::new();
10806 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
10807 if missing_type.is_some() && cur == offset {
10808 stack.push(("DlParam", offset));
10809 return (stack, missing_type.and_then(|t| DlParam::attr_from_type(t)));
10810 }
10811 if cur > offset || cur + self.buf.len() < offset {
10812 return (stack, None);
10813 }
10814 let mut attrs = self.clone();
10815 let mut last_off = cur + attrs.pos;
10816 while let Some(attr) = attrs.next() {
10817 let Ok(attr) = attr else { break };
10818 match attr {
10819 DlParam::ParamName(val) => {
10820 if last_off == offset {
10821 stack.push(("ParamName", last_off));
10822 break;
10823 }
10824 }
10825 DlParam::ParamGeneric(val) => {
10826 if last_off == offset {
10827 stack.push(("ParamGeneric", last_off));
10828 break;
10829 }
10830 }
10831 DlParam::ParamType(val) => {
10832 if last_off == offset {
10833 stack.push(("ParamType", last_off));
10834 break;
10835 }
10836 }
10837 _ => {}
10838 };
10839 last_off = cur + attrs.pos;
10840 }
10841 if !stack.is_empty() {
10842 stack.push(("DlParam", cur));
10843 }
10844 (stack, None)
10845 }
10846}
10847#[derive(Clone)]
10848pub enum DlRegionSnapshots<'a> {
10849 RegionSnapshot(IterableDlRegionSnapshot<'a>),
10850}
10851impl<'a> IterableDlRegionSnapshots<'a> {
10852 pub fn get_region_snapshot(&self) -> Result<IterableDlRegionSnapshot<'a>, ErrorContext> {
10853 let mut iter = self.clone();
10854 iter.pos = 0;
10855 for attr in iter {
10856 if let Ok(DlRegionSnapshots::RegionSnapshot(val)) = attr {
10857 return Ok(val);
10858 }
10859 }
10860 Err(ErrorContext::new_missing(
10861 "DlRegionSnapshots",
10862 "RegionSnapshot",
10863 self.orig_loc,
10864 self.buf.as_ptr() as usize,
10865 ))
10866 }
10867}
10868impl DlRegionSnapshots<'_> {
10869 pub fn new<'a>(buf: &'a [u8]) -> IterableDlRegionSnapshots<'a> {
10870 IterableDlRegionSnapshots::with_loc(buf, buf.as_ptr() as usize)
10871 }
10872 fn attr_from_type(r#type: u16) -> Option<&'static str> {
10873 Devlink::attr_from_type(r#type)
10874 }
10875}
10876#[derive(Clone, Copy, Default)]
10877pub struct IterableDlRegionSnapshots<'a> {
10878 buf: &'a [u8],
10879 pos: usize,
10880 orig_loc: usize,
10881}
10882impl<'a> IterableDlRegionSnapshots<'a> {
10883 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
10884 Self {
10885 buf,
10886 pos: 0,
10887 orig_loc,
10888 }
10889 }
10890 pub fn get_buf(&self) -> &'a [u8] {
10891 self.buf
10892 }
10893}
10894impl<'a> Iterator for IterableDlRegionSnapshots<'a> {
10895 type Item = Result<DlRegionSnapshots<'a>, ErrorContext>;
10896 fn next(&mut self) -> Option<Self::Item> {
10897 let mut pos;
10898 let mut r#type;
10899 loop {
10900 pos = self.pos;
10901 r#type = None;
10902 if self.buf.len() == self.pos {
10903 return None;
10904 }
10905 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
10906 self.pos = self.buf.len();
10907 break;
10908 };
10909 r#type = Some(header.r#type);
10910 let res = match header.r#type {
10911 91u16 => DlRegionSnapshots::RegionSnapshot({
10912 let res = Some(IterableDlRegionSnapshot::with_loc(next, self.orig_loc));
10913 let Some(val) = res else { break };
10914 val
10915 }),
10916 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
10917 n => continue,
10918 };
10919 return Some(Ok(res));
10920 }
10921 Some(Err(ErrorContext::new(
10922 "DlRegionSnapshots",
10923 r#type.and_then(|t| DlRegionSnapshots::attr_from_type(t)),
10924 self.orig_loc,
10925 self.buf.as_ptr().wrapping_add(pos) as usize,
10926 )))
10927 }
10928}
10929impl<'a> std::fmt::Debug for IterableDlRegionSnapshots<'_> {
10930 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10931 let mut fmt = f.debug_struct("DlRegionSnapshots");
10932 for attr in self.clone() {
10933 let attr = match attr {
10934 Ok(a) => a,
10935 Err(err) => {
10936 fmt.finish()?;
10937 f.write_str("Err(")?;
10938 err.fmt(f)?;
10939 return f.write_str(")");
10940 }
10941 };
10942 match attr {
10943 DlRegionSnapshots::RegionSnapshot(val) => fmt.field("RegionSnapshot", &val),
10944 };
10945 }
10946 fmt.finish()
10947 }
10948}
10949impl IterableDlRegionSnapshots<'_> {
10950 pub fn lookup_attr(
10951 &self,
10952 offset: usize,
10953 missing_type: Option<u16>,
10954 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
10955 let mut stack = Vec::new();
10956 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
10957 if missing_type.is_some() && cur == offset {
10958 stack.push(("DlRegionSnapshots", offset));
10959 return (
10960 stack,
10961 missing_type.and_then(|t| DlRegionSnapshots::attr_from_type(t)),
10962 );
10963 }
10964 if cur > offset || cur + self.buf.len() < offset {
10965 return (stack, None);
10966 }
10967 let mut attrs = self.clone();
10968 let mut last_off = cur + attrs.pos;
10969 let mut missing = None;
10970 while let Some(attr) = attrs.next() {
10971 let Ok(attr) = attr else { break };
10972 match attr {
10973 DlRegionSnapshots::RegionSnapshot(val) => {
10974 (stack, missing) = val.lookup_attr(offset, missing_type);
10975 if !stack.is_empty() {
10976 break;
10977 }
10978 }
10979 _ => {}
10980 };
10981 last_off = cur + attrs.pos;
10982 }
10983 if !stack.is_empty() {
10984 stack.push(("DlRegionSnapshots", cur));
10985 }
10986 (stack, missing)
10987 }
10988}
10989#[derive(Clone)]
10990pub enum DlRegionSnapshot {
10991 RegionSnapshotId(u32),
10992}
10993impl<'a> IterableDlRegionSnapshot<'a> {
10994 pub fn get_region_snapshot_id(&self) -> Result<u32, ErrorContext> {
10995 let mut iter = self.clone();
10996 iter.pos = 0;
10997 for attr in iter {
10998 if let Ok(DlRegionSnapshot::RegionSnapshotId(val)) = attr {
10999 return Ok(val);
11000 }
11001 }
11002 Err(ErrorContext::new_missing(
11003 "DlRegionSnapshot",
11004 "RegionSnapshotId",
11005 self.orig_loc,
11006 self.buf.as_ptr() as usize,
11007 ))
11008 }
11009}
11010impl DlRegionSnapshot {
11011 pub fn new<'a>(buf: &'a [u8]) -> IterableDlRegionSnapshot<'a> {
11012 IterableDlRegionSnapshot::with_loc(buf, buf.as_ptr() as usize)
11013 }
11014 fn attr_from_type(r#type: u16) -> Option<&'static str> {
11015 Devlink::attr_from_type(r#type)
11016 }
11017}
11018#[derive(Clone, Copy, Default)]
11019pub struct IterableDlRegionSnapshot<'a> {
11020 buf: &'a [u8],
11021 pos: usize,
11022 orig_loc: usize,
11023}
11024impl<'a> IterableDlRegionSnapshot<'a> {
11025 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
11026 Self {
11027 buf,
11028 pos: 0,
11029 orig_loc,
11030 }
11031 }
11032 pub fn get_buf(&self) -> &'a [u8] {
11033 self.buf
11034 }
11035}
11036impl<'a> Iterator for IterableDlRegionSnapshot<'a> {
11037 type Item = Result<DlRegionSnapshot, ErrorContext>;
11038 fn next(&mut self) -> Option<Self::Item> {
11039 let mut pos;
11040 let mut r#type;
11041 loop {
11042 pos = self.pos;
11043 r#type = None;
11044 if self.buf.len() == self.pos {
11045 return None;
11046 }
11047 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
11048 self.pos = self.buf.len();
11049 break;
11050 };
11051 r#type = Some(header.r#type);
11052 let res = match header.r#type {
11053 92u16 => DlRegionSnapshot::RegionSnapshotId({
11054 let res = parse_u32(next);
11055 let Some(val) = res else { break };
11056 val
11057 }),
11058 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
11059 n => continue,
11060 };
11061 return Some(Ok(res));
11062 }
11063 Some(Err(ErrorContext::new(
11064 "DlRegionSnapshot",
11065 r#type.and_then(|t| DlRegionSnapshot::attr_from_type(t)),
11066 self.orig_loc,
11067 self.buf.as_ptr().wrapping_add(pos) as usize,
11068 )))
11069 }
11070}
11071impl std::fmt::Debug for IterableDlRegionSnapshot<'_> {
11072 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11073 let mut fmt = f.debug_struct("DlRegionSnapshot");
11074 for attr in self.clone() {
11075 let attr = match attr {
11076 Ok(a) => a,
11077 Err(err) => {
11078 fmt.finish()?;
11079 f.write_str("Err(")?;
11080 err.fmt(f)?;
11081 return f.write_str(")");
11082 }
11083 };
11084 match attr {
11085 DlRegionSnapshot::RegionSnapshotId(val) => fmt.field("RegionSnapshotId", &val),
11086 };
11087 }
11088 fmt.finish()
11089 }
11090}
11091impl IterableDlRegionSnapshot<'_> {
11092 pub fn lookup_attr(
11093 &self,
11094 offset: usize,
11095 missing_type: Option<u16>,
11096 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
11097 let mut stack = Vec::new();
11098 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
11099 if missing_type.is_some() && cur == offset {
11100 stack.push(("DlRegionSnapshot", offset));
11101 return (
11102 stack,
11103 missing_type.and_then(|t| DlRegionSnapshot::attr_from_type(t)),
11104 );
11105 }
11106 if cur > offset || cur + self.buf.len() < offset {
11107 return (stack, None);
11108 }
11109 let mut attrs = self.clone();
11110 let mut last_off = cur + attrs.pos;
11111 while let Some(attr) = attrs.next() {
11112 let Ok(attr) = attr else { break };
11113 match attr {
11114 DlRegionSnapshot::RegionSnapshotId(val) => {
11115 if last_off == offset {
11116 stack.push(("RegionSnapshotId", last_off));
11117 break;
11118 }
11119 }
11120 _ => {}
11121 };
11122 last_off = cur + attrs.pos;
11123 }
11124 if !stack.is_empty() {
11125 stack.push(("DlRegionSnapshot", cur));
11126 }
11127 (stack, None)
11128 }
11129}
11130#[derive(Clone)]
11131pub enum DlRegionChunks<'a> {
11132 RegionChunk(IterableDlRegionChunk<'a>),
11133}
11134impl<'a> IterableDlRegionChunks<'a> {
11135 pub fn get_region_chunk(&self) -> Result<IterableDlRegionChunk<'a>, ErrorContext> {
11136 let mut iter = self.clone();
11137 iter.pos = 0;
11138 for attr in iter {
11139 if let Ok(DlRegionChunks::RegionChunk(val)) = attr {
11140 return Ok(val);
11141 }
11142 }
11143 Err(ErrorContext::new_missing(
11144 "DlRegionChunks",
11145 "RegionChunk",
11146 self.orig_loc,
11147 self.buf.as_ptr() as usize,
11148 ))
11149 }
11150}
11151impl DlRegionChunks<'_> {
11152 pub fn new<'a>(buf: &'a [u8]) -> IterableDlRegionChunks<'a> {
11153 IterableDlRegionChunks::with_loc(buf, buf.as_ptr() as usize)
11154 }
11155 fn attr_from_type(r#type: u16) -> Option<&'static str> {
11156 Devlink::attr_from_type(r#type)
11157 }
11158}
11159#[derive(Clone, Copy, Default)]
11160pub struct IterableDlRegionChunks<'a> {
11161 buf: &'a [u8],
11162 pos: usize,
11163 orig_loc: usize,
11164}
11165impl<'a> IterableDlRegionChunks<'a> {
11166 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
11167 Self {
11168 buf,
11169 pos: 0,
11170 orig_loc,
11171 }
11172 }
11173 pub fn get_buf(&self) -> &'a [u8] {
11174 self.buf
11175 }
11176}
11177impl<'a> Iterator for IterableDlRegionChunks<'a> {
11178 type Item = Result<DlRegionChunks<'a>, ErrorContext>;
11179 fn next(&mut self) -> Option<Self::Item> {
11180 let mut pos;
11181 let mut r#type;
11182 loop {
11183 pos = self.pos;
11184 r#type = None;
11185 if self.buf.len() == self.pos {
11186 return None;
11187 }
11188 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
11189 self.pos = self.buf.len();
11190 break;
11191 };
11192 r#type = Some(header.r#type);
11193 let res = match header.r#type {
11194 94u16 => DlRegionChunks::RegionChunk({
11195 let res = Some(IterableDlRegionChunk::with_loc(next, self.orig_loc));
11196 let Some(val) = res else { break };
11197 val
11198 }),
11199 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
11200 n => continue,
11201 };
11202 return Some(Ok(res));
11203 }
11204 Some(Err(ErrorContext::new(
11205 "DlRegionChunks",
11206 r#type.and_then(|t| DlRegionChunks::attr_from_type(t)),
11207 self.orig_loc,
11208 self.buf.as_ptr().wrapping_add(pos) as usize,
11209 )))
11210 }
11211}
11212impl<'a> std::fmt::Debug for IterableDlRegionChunks<'_> {
11213 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11214 let mut fmt = f.debug_struct("DlRegionChunks");
11215 for attr in self.clone() {
11216 let attr = match attr {
11217 Ok(a) => a,
11218 Err(err) => {
11219 fmt.finish()?;
11220 f.write_str("Err(")?;
11221 err.fmt(f)?;
11222 return f.write_str(")");
11223 }
11224 };
11225 match attr {
11226 DlRegionChunks::RegionChunk(val) => fmt.field("RegionChunk", &val),
11227 };
11228 }
11229 fmt.finish()
11230 }
11231}
11232impl IterableDlRegionChunks<'_> {
11233 pub fn lookup_attr(
11234 &self,
11235 offset: usize,
11236 missing_type: Option<u16>,
11237 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
11238 let mut stack = Vec::new();
11239 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
11240 if missing_type.is_some() && cur == offset {
11241 stack.push(("DlRegionChunks", offset));
11242 return (
11243 stack,
11244 missing_type.and_then(|t| DlRegionChunks::attr_from_type(t)),
11245 );
11246 }
11247 if cur > offset || cur + self.buf.len() < offset {
11248 return (stack, None);
11249 }
11250 let mut attrs = self.clone();
11251 let mut last_off = cur + attrs.pos;
11252 let mut missing = None;
11253 while let Some(attr) = attrs.next() {
11254 let Ok(attr) = attr else { break };
11255 match attr {
11256 DlRegionChunks::RegionChunk(val) => {
11257 (stack, missing) = val.lookup_attr(offset, missing_type);
11258 if !stack.is_empty() {
11259 break;
11260 }
11261 }
11262 _ => {}
11263 };
11264 last_off = cur + attrs.pos;
11265 }
11266 if !stack.is_empty() {
11267 stack.push(("DlRegionChunks", cur));
11268 }
11269 (stack, missing)
11270 }
11271}
11272#[derive(Clone)]
11273pub enum DlRegionChunk<'a> {
11274 RegionChunkData(&'a [u8]),
11275 RegionChunkAddr(u64),
11276}
11277impl<'a> IterableDlRegionChunk<'a> {
11278 pub fn get_region_chunk_data(&self) -> Result<&'a [u8], ErrorContext> {
11279 let mut iter = self.clone();
11280 iter.pos = 0;
11281 for attr in iter {
11282 if let Ok(DlRegionChunk::RegionChunkData(val)) = attr {
11283 return Ok(val);
11284 }
11285 }
11286 Err(ErrorContext::new_missing(
11287 "DlRegionChunk",
11288 "RegionChunkData",
11289 self.orig_loc,
11290 self.buf.as_ptr() as usize,
11291 ))
11292 }
11293 pub fn get_region_chunk_addr(&self) -> Result<u64, ErrorContext> {
11294 let mut iter = self.clone();
11295 iter.pos = 0;
11296 for attr in iter {
11297 if let Ok(DlRegionChunk::RegionChunkAddr(val)) = attr {
11298 return Ok(val);
11299 }
11300 }
11301 Err(ErrorContext::new_missing(
11302 "DlRegionChunk",
11303 "RegionChunkAddr",
11304 self.orig_loc,
11305 self.buf.as_ptr() as usize,
11306 ))
11307 }
11308}
11309impl DlRegionChunk<'_> {
11310 pub fn new<'a>(buf: &'a [u8]) -> IterableDlRegionChunk<'a> {
11311 IterableDlRegionChunk::with_loc(buf, buf.as_ptr() as usize)
11312 }
11313 fn attr_from_type(r#type: u16) -> Option<&'static str> {
11314 Devlink::attr_from_type(r#type)
11315 }
11316}
11317#[derive(Clone, Copy, Default)]
11318pub struct IterableDlRegionChunk<'a> {
11319 buf: &'a [u8],
11320 pos: usize,
11321 orig_loc: usize,
11322}
11323impl<'a> IterableDlRegionChunk<'a> {
11324 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
11325 Self {
11326 buf,
11327 pos: 0,
11328 orig_loc,
11329 }
11330 }
11331 pub fn get_buf(&self) -> &'a [u8] {
11332 self.buf
11333 }
11334}
11335impl<'a> Iterator for IterableDlRegionChunk<'a> {
11336 type Item = Result<DlRegionChunk<'a>, ErrorContext>;
11337 fn next(&mut self) -> Option<Self::Item> {
11338 let mut pos;
11339 let mut r#type;
11340 loop {
11341 pos = self.pos;
11342 r#type = None;
11343 if self.buf.len() == self.pos {
11344 return None;
11345 }
11346 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
11347 self.pos = self.buf.len();
11348 break;
11349 };
11350 r#type = Some(header.r#type);
11351 let res = match header.r#type {
11352 95u16 => DlRegionChunk::RegionChunkData({
11353 let res = Some(next);
11354 let Some(val) = res else { break };
11355 val
11356 }),
11357 96u16 => DlRegionChunk::RegionChunkAddr({
11358 let res = parse_u64(next);
11359 let Some(val) = res else { break };
11360 val
11361 }),
11362 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
11363 n => continue,
11364 };
11365 return Some(Ok(res));
11366 }
11367 Some(Err(ErrorContext::new(
11368 "DlRegionChunk",
11369 r#type.and_then(|t| DlRegionChunk::attr_from_type(t)),
11370 self.orig_loc,
11371 self.buf.as_ptr().wrapping_add(pos) as usize,
11372 )))
11373 }
11374}
11375impl<'a> std::fmt::Debug for IterableDlRegionChunk<'_> {
11376 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11377 let mut fmt = f.debug_struct("DlRegionChunk");
11378 for attr in self.clone() {
11379 let attr = match attr {
11380 Ok(a) => a,
11381 Err(err) => {
11382 fmt.finish()?;
11383 f.write_str("Err(")?;
11384 err.fmt(f)?;
11385 return f.write_str(")");
11386 }
11387 };
11388 match attr {
11389 DlRegionChunk::RegionChunkData(val) => fmt.field("RegionChunkData", &val),
11390 DlRegionChunk::RegionChunkAddr(val) => fmt.field("RegionChunkAddr", &val),
11391 };
11392 }
11393 fmt.finish()
11394 }
11395}
11396impl IterableDlRegionChunk<'_> {
11397 pub fn lookup_attr(
11398 &self,
11399 offset: usize,
11400 missing_type: Option<u16>,
11401 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
11402 let mut stack = Vec::new();
11403 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
11404 if missing_type.is_some() && cur == offset {
11405 stack.push(("DlRegionChunk", offset));
11406 return (
11407 stack,
11408 missing_type.and_then(|t| DlRegionChunk::attr_from_type(t)),
11409 );
11410 }
11411 if cur > offset || cur + self.buf.len() < offset {
11412 return (stack, None);
11413 }
11414 let mut attrs = self.clone();
11415 let mut last_off = cur + attrs.pos;
11416 while let Some(attr) = attrs.next() {
11417 let Ok(attr) = attr else { break };
11418 match attr {
11419 DlRegionChunk::RegionChunkData(val) => {
11420 if last_off == offset {
11421 stack.push(("RegionChunkData", last_off));
11422 break;
11423 }
11424 }
11425 DlRegionChunk::RegionChunkAddr(val) => {
11426 if last_off == offset {
11427 stack.push(("RegionChunkAddr", last_off));
11428 break;
11429 }
11430 }
11431 _ => {}
11432 };
11433 last_off = cur + attrs.pos;
11434 }
11435 if !stack.is_empty() {
11436 stack.push(("DlRegionChunk", cur));
11437 }
11438 (stack, None)
11439 }
11440}
11441#[derive(Clone)]
11442pub enum DlFmsg<'a> {
11443 FmsgObjNestStart(()),
11444 FmsgPairNestStart(()),
11445 FmsgArrNestStart(()),
11446 FmsgNestEnd(()),
11447 FmsgObjName(&'a CStr),
11448}
11449impl<'a> IterableDlFmsg<'a> {
11450 pub fn get_fmsg_obj_nest_start(&self) -> Result<(), ErrorContext> {
11451 let mut iter = self.clone();
11452 iter.pos = 0;
11453 for attr in iter {
11454 if let Ok(DlFmsg::FmsgObjNestStart(val)) = attr {
11455 return Ok(val);
11456 }
11457 }
11458 Err(ErrorContext::new_missing(
11459 "DlFmsg",
11460 "FmsgObjNestStart",
11461 self.orig_loc,
11462 self.buf.as_ptr() as usize,
11463 ))
11464 }
11465 pub fn get_fmsg_pair_nest_start(&self) -> Result<(), ErrorContext> {
11466 let mut iter = self.clone();
11467 iter.pos = 0;
11468 for attr in iter {
11469 if let Ok(DlFmsg::FmsgPairNestStart(val)) = attr {
11470 return Ok(val);
11471 }
11472 }
11473 Err(ErrorContext::new_missing(
11474 "DlFmsg",
11475 "FmsgPairNestStart",
11476 self.orig_loc,
11477 self.buf.as_ptr() as usize,
11478 ))
11479 }
11480 pub fn get_fmsg_arr_nest_start(&self) -> Result<(), ErrorContext> {
11481 let mut iter = self.clone();
11482 iter.pos = 0;
11483 for attr in iter {
11484 if let Ok(DlFmsg::FmsgArrNestStart(val)) = attr {
11485 return Ok(val);
11486 }
11487 }
11488 Err(ErrorContext::new_missing(
11489 "DlFmsg",
11490 "FmsgArrNestStart",
11491 self.orig_loc,
11492 self.buf.as_ptr() as usize,
11493 ))
11494 }
11495 pub fn get_fmsg_nest_end(&self) -> Result<(), ErrorContext> {
11496 let mut iter = self.clone();
11497 iter.pos = 0;
11498 for attr in iter {
11499 if let Ok(DlFmsg::FmsgNestEnd(val)) = attr {
11500 return Ok(val);
11501 }
11502 }
11503 Err(ErrorContext::new_missing(
11504 "DlFmsg",
11505 "FmsgNestEnd",
11506 self.orig_loc,
11507 self.buf.as_ptr() as usize,
11508 ))
11509 }
11510 pub fn get_fmsg_obj_name(&self) -> Result<&'a CStr, ErrorContext> {
11511 let mut iter = self.clone();
11512 iter.pos = 0;
11513 for attr in iter {
11514 if let Ok(DlFmsg::FmsgObjName(val)) = attr {
11515 return Ok(val);
11516 }
11517 }
11518 Err(ErrorContext::new_missing(
11519 "DlFmsg",
11520 "FmsgObjName",
11521 self.orig_loc,
11522 self.buf.as_ptr() as usize,
11523 ))
11524 }
11525}
11526impl DlFmsg<'_> {
11527 pub fn new<'a>(buf: &'a [u8]) -> IterableDlFmsg<'a> {
11528 IterableDlFmsg::with_loc(buf, buf.as_ptr() as usize)
11529 }
11530 fn attr_from_type(r#type: u16) -> Option<&'static str> {
11531 Devlink::attr_from_type(r#type)
11532 }
11533}
11534#[derive(Clone, Copy, Default)]
11535pub struct IterableDlFmsg<'a> {
11536 buf: &'a [u8],
11537 pos: usize,
11538 orig_loc: usize,
11539}
11540impl<'a> IterableDlFmsg<'a> {
11541 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
11542 Self {
11543 buf,
11544 pos: 0,
11545 orig_loc,
11546 }
11547 }
11548 pub fn get_buf(&self) -> &'a [u8] {
11549 self.buf
11550 }
11551}
11552impl<'a> Iterator for IterableDlFmsg<'a> {
11553 type Item = Result<DlFmsg<'a>, ErrorContext>;
11554 fn next(&mut self) -> Option<Self::Item> {
11555 let mut pos;
11556 let mut r#type;
11557 loop {
11558 pos = self.pos;
11559 r#type = None;
11560 if self.buf.len() == self.pos {
11561 return None;
11562 }
11563 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
11564 self.pos = self.buf.len();
11565 break;
11566 };
11567 r#type = Some(header.r#type);
11568 let res = match header.r#type {
11569 107u16 => DlFmsg::FmsgObjNestStart(()),
11570 108u16 => DlFmsg::FmsgPairNestStart(()),
11571 109u16 => DlFmsg::FmsgArrNestStart(()),
11572 110u16 => DlFmsg::FmsgNestEnd(()),
11573 111u16 => DlFmsg::FmsgObjName({
11574 let res = CStr::from_bytes_with_nul(next).ok();
11575 let Some(val) = res else { break };
11576 val
11577 }),
11578 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
11579 n => continue,
11580 };
11581 return Some(Ok(res));
11582 }
11583 Some(Err(ErrorContext::new(
11584 "DlFmsg",
11585 r#type.and_then(|t| DlFmsg::attr_from_type(t)),
11586 self.orig_loc,
11587 self.buf.as_ptr().wrapping_add(pos) as usize,
11588 )))
11589 }
11590}
11591impl<'a> std::fmt::Debug for IterableDlFmsg<'_> {
11592 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11593 let mut fmt = f.debug_struct("DlFmsg");
11594 for attr in self.clone() {
11595 let attr = match attr {
11596 Ok(a) => a,
11597 Err(err) => {
11598 fmt.finish()?;
11599 f.write_str("Err(")?;
11600 err.fmt(f)?;
11601 return f.write_str(")");
11602 }
11603 };
11604 match attr {
11605 DlFmsg::FmsgObjNestStart(val) => fmt.field("FmsgObjNestStart", &val),
11606 DlFmsg::FmsgPairNestStart(val) => fmt.field("FmsgPairNestStart", &val),
11607 DlFmsg::FmsgArrNestStart(val) => fmt.field("FmsgArrNestStart", &val),
11608 DlFmsg::FmsgNestEnd(val) => fmt.field("FmsgNestEnd", &val),
11609 DlFmsg::FmsgObjName(val) => fmt.field("FmsgObjName", &val),
11610 };
11611 }
11612 fmt.finish()
11613 }
11614}
11615impl IterableDlFmsg<'_> {
11616 pub fn lookup_attr(
11617 &self,
11618 offset: usize,
11619 missing_type: Option<u16>,
11620 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
11621 let mut stack = Vec::new();
11622 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
11623 if missing_type.is_some() && cur == offset {
11624 stack.push(("DlFmsg", offset));
11625 return (stack, missing_type.and_then(|t| DlFmsg::attr_from_type(t)));
11626 }
11627 if cur > offset || cur + self.buf.len() < offset {
11628 return (stack, None);
11629 }
11630 let mut attrs = self.clone();
11631 let mut last_off = cur + attrs.pos;
11632 while let Some(attr) = attrs.next() {
11633 let Ok(attr) = attr else { break };
11634 match attr {
11635 DlFmsg::FmsgObjNestStart(val) => {
11636 if last_off == offset {
11637 stack.push(("FmsgObjNestStart", last_off));
11638 break;
11639 }
11640 }
11641 DlFmsg::FmsgPairNestStart(val) => {
11642 if last_off == offset {
11643 stack.push(("FmsgPairNestStart", last_off));
11644 break;
11645 }
11646 }
11647 DlFmsg::FmsgArrNestStart(val) => {
11648 if last_off == offset {
11649 stack.push(("FmsgArrNestStart", last_off));
11650 break;
11651 }
11652 }
11653 DlFmsg::FmsgNestEnd(val) => {
11654 if last_off == offset {
11655 stack.push(("FmsgNestEnd", last_off));
11656 break;
11657 }
11658 }
11659 DlFmsg::FmsgObjName(val) => {
11660 if last_off == offset {
11661 stack.push(("FmsgObjName", last_off));
11662 break;
11663 }
11664 }
11665 _ => {}
11666 };
11667 last_off = cur + attrs.pos;
11668 }
11669 if !stack.is_empty() {
11670 stack.push(("DlFmsg", cur));
11671 }
11672 (stack, None)
11673 }
11674}
11675#[derive(Clone)]
11676pub enum DlHealthReporter<'a> {
11677 HealthReporterName(&'a CStr),
11678 HealthReporterState(u8),
11679 HealthReporterErrCount(u64),
11680 HealthReporterRecoverCount(u64),
11681 HealthReporterDumpTs(u64),
11682 HealthReporterGracefulPeriod(u64),
11683 HealthReporterAutoRecover(u8),
11684 HealthReporterDumpTsNs(u64),
11685 HealthReporterAutoDump(u8),
11686 #[doc = "Time (in msec) for recoveries before starting the grace period.\n"]
11687 HealthReporterBurstPeriod(u64),
11688}
11689impl<'a> IterableDlHealthReporter<'a> {
11690 pub fn get_health_reporter_name(&self) -> Result<&'a CStr, ErrorContext> {
11691 let mut iter = self.clone();
11692 iter.pos = 0;
11693 for attr in iter {
11694 if let Ok(DlHealthReporter::HealthReporterName(val)) = attr {
11695 return Ok(val);
11696 }
11697 }
11698 Err(ErrorContext::new_missing(
11699 "DlHealthReporter",
11700 "HealthReporterName",
11701 self.orig_loc,
11702 self.buf.as_ptr() as usize,
11703 ))
11704 }
11705 pub fn get_health_reporter_state(&self) -> Result<u8, ErrorContext> {
11706 let mut iter = self.clone();
11707 iter.pos = 0;
11708 for attr in iter {
11709 if let Ok(DlHealthReporter::HealthReporterState(val)) = attr {
11710 return Ok(val);
11711 }
11712 }
11713 Err(ErrorContext::new_missing(
11714 "DlHealthReporter",
11715 "HealthReporterState",
11716 self.orig_loc,
11717 self.buf.as_ptr() as usize,
11718 ))
11719 }
11720 pub fn get_health_reporter_err_count(&self) -> Result<u64, ErrorContext> {
11721 let mut iter = self.clone();
11722 iter.pos = 0;
11723 for attr in iter {
11724 if let Ok(DlHealthReporter::HealthReporterErrCount(val)) = attr {
11725 return Ok(val);
11726 }
11727 }
11728 Err(ErrorContext::new_missing(
11729 "DlHealthReporter",
11730 "HealthReporterErrCount",
11731 self.orig_loc,
11732 self.buf.as_ptr() as usize,
11733 ))
11734 }
11735 pub fn get_health_reporter_recover_count(&self) -> Result<u64, ErrorContext> {
11736 let mut iter = self.clone();
11737 iter.pos = 0;
11738 for attr in iter {
11739 if let Ok(DlHealthReporter::HealthReporterRecoverCount(val)) = attr {
11740 return Ok(val);
11741 }
11742 }
11743 Err(ErrorContext::new_missing(
11744 "DlHealthReporter",
11745 "HealthReporterRecoverCount",
11746 self.orig_loc,
11747 self.buf.as_ptr() as usize,
11748 ))
11749 }
11750 pub fn get_health_reporter_dump_ts(&self) -> Result<u64, ErrorContext> {
11751 let mut iter = self.clone();
11752 iter.pos = 0;
11753 for attr in iter {
11754 if let Ok(DlHealthReporter::HealthReporterDumpTs(val)) = attr {
11755 return Ok(val);
11756 }
11757 }
11758 Err(ErrorContext::new_missing(
11759 "DlHealthReporter",
11760 "HealthReporterDumpTs",
11761 self.orig_loc,
11762 self.buf.as_ptr() as usize,
11763 ))
11764 }
11765 pub fn get_health_reporter_graceful_period(&self) -> Result<u64, ErrorContext> {
11766 let mut iter = self.clone();
11767 iter.pos = 0;
11768 for attr in iter {
11769 if let Ok(DlHealthReporter::HealthReporterGracefulPeriod(val)) = attr {
11770 return Ok(val);
11771 }
11772 }
11773 Err(ErrorContext::new_missing(
11774 "DlHealthReporter",
11775 "HealthReporterGracefulPeriod",
11776 self.orig_loc,
11777 self.buf.as_ptr() as usize,
11778 ))
11779 }
11780 pub fn get_health_reporter_auto_recover(&self) -> Result<u8, ErrorContext> {
11781 let mut iter = self.clone();
11782 iter.pos = 0;
11783 for attr in iter {
11784 if let Ok(DlHealthReporter::HealthReporterAutoRecover(val)) = attr {
11785 return Ok(val);
11786 }
11787 }
11788 Err(ErrorContext::new_missing(
11789 "DlHealthReporter",
11790 "HealthReporterAutoRecover",
11791 self.orig_loc,
11792 self.buf.as_ptr() as usize,
11793 ))
11794 }
11795 pub fn get_health_reporter_dump_ts_ns(&self) -> Result<u64, ErrorContext> {
11796 let mut iter = self.clone();
11797 iter.pos = 0;
11798 for attr in iter {
11799 if let Ok(DlHealthReporter::HealthReporterDumpTsNs(val)) = attr {
11800 return Ok(val);
11801 }
11802 }
11803 Err(ErrorContext::new_missing(
11804 "DlHealthReporter",
11805 "HealthReporterDumpTsNs",
11806 self.orig_loc,
11807 self.buf.as_ptr() as usize,
11808 ))
11809 }
11810 pub fn get_health_reporter_auto_dump(&self) -> Result<u8, ErrorContext> {
11811 let mut iter = self.clone();
11812 iter.pos = 0;
11813 for attr in iter {
11814 if let Ok(DlHealthReporter::HealthReporterAutoDump(val)) = attr {
11815 return Ok(val);
11816 }
11817 }
11818 Err(ErrorContext::new_missing(
11819 "DlHealthReporter",
11820 "HealthReporterAutoDump",
11821 self.orig_loc,
11822 self.buf.as_ptr() as usize,
11823 ))
11824 }
11825 #[doc = "Time (in msec) for recoveries before starting the grace period.\n"]
11826 pub fn get_health_reporter_burst_period(&self) -> Result<u64, ErrorContext> {
11827 let mut iter = self.clone();
11828 iter.pos = 0;
11829 for attr in iter {
11830 if let Ok(DlHealthReporter::HealthReporterBurstPeriod(val)) = attr {
11831 return Ok(val);
11832 }
11833 }
11834 Err(ErrorContext::new_missing(
11835 "DlHealthReporter",
11836 "HealthReporterBurstPeriod",
11837 self.orig_loc,
11838 self.buf.as_ptr() as usize,
11839 ))
11840 }
11841}
11842impl DlHealthReporter<'_> {
11843 pub fn new<'a>(buf: &'a [u8]) -> IterableDlHealthReporter<'a> {
11844 IterableDlHealthReporter::with_loc(buf, buf.as_ptr() as usize)
11845 }
11846 fn attr_from_type(r#type: u16) -> Option<&'static str> {
11847 Devlink::attr_from_type(r#type)
11848 }
11849}
11850#[derive(Clone, Copy, Default)]
11851pub struct IterableDlHealthReporter<'a> {
11852 buf: &'a [u8],
11853 pos: usize,
11854 orig_loc: usize,
11855}
11856impl<'a> IterableDlHealthReporter<'a> {
11857 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
11858 Self {
11859 buf,
11860 pos: 0,
11861 orig_loc,
11862 }
11863 }
11864 pub fn get_buf(&self) -> &'a [u8] {
11865 self.buf
11866 }
11867}
11868impl<'a> Iterator for IterableDlHealthReporter<'a> {
11869 type Item = Result<DlHealthReporter<'a>, ErrorContext>;
11870 fn next(&mut self) -> Option<Self::Item> {
11871 let mut pos;
11872 let mut r#type;
11873 loop {
11874 pos = self.pos;
11875 r#type = None;
11876 if self.buf.len() == self.pos {
11877 return None;
11878 }
11879 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
11880 self.pos = self.buf.len();
11881 break;
11882 };
11883 r#type = Some(header.r#type);
11884 let res = match header.r#type {
11885 115u16 => DlHealthReporter::HealthReporterName({
11886 let res = CStr::from_bytes_with_nul(next).ok();
11887 let Some(val) = res else { break };
11888 val
11889 }),
11890 116u16 => DlHealthReporter::HealthReporterState({
11891 let res = parse_u8(next);
11892 let Some(val) = res else { break };
11893 val
11894 }),
11895 117u16 => DlHealthReporter::HealthReporterErrCount({
11896 let res = parse_u64(next);
11897 let Some(val) = res else { break };
11898 val
11899 }),
11900 118u16 => DlHealthReporter::HealthReporterRecoverCount({
11901 let res = parse_u64(next);
11902 let Some(val) = res else { break };
11903 val
11904 }),
11905 119u16 => DlHealthReporter::HealthReporterDumpTs({
11906 let res = parse_u64(next);
11907 let Some(val) = res else { break };
11908 val
11909 }),
11910 120u16 => DlHealthReporter::HealthReporterGracefulPeriod({
11911 let res = parse_u64(next);
11912 let Some(val) = res else { break };
11913 val
11914 }),
11915 121u16 => DlHealthReporter::HealthReporterAutoRecover({
11916 let res = parse_u8(next);
11917 let Some(val) = res else { break };
11918 val
11919 }),
11920 137u16 => DlHealthReporter::HealthReporterDumpTsNs({
11921 let res = parse_u64(next);
11922 let Some(val) = res else { break };
11923 val
11924 }),
11925 141u16 => DlHealthReporter::HealthReporterAutoDump({
11926 let res = parse_u8(next);
11927 let Some(val) = res else { break };
11928 val
11929 }),
11930 181u16 => DlHealthReporter::HealthReporterBurstPeriod({
11931 let res = parse_u64(next);
11932 let Some(val) = res else { break };
11933 val
11934 }),
11935 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
11936 n => continue,
11937 };
11938 return Some(Ok(res));
11939 }
11940 Some(Err(ErrorContext::new(
11941 "DlHealthReporter",
11942 r#type.and_then(|t| DlHealthReporter::attr_from_type(t)),
11943 self.orig_loc,
11944 self.buf.as_ptr().wrapping_add(pos) as usize,
11945 )))
11946 }
11947}
11948impl<'a> std::fmt::Debug for IterableDlHealthReporter<'_> {
11949 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11950 let mut fmt = f.debug_struct("DlHealthReporter");
11951 for attr in self.clone() {
11952 let attr = match attr {
11953 Ok(a) => a,
11954 Err(err) => {
11955 fmt.finish()?;
11956 f.write_str("Err(")?;
11957 err.fmt(f)?;
11958 return f.write_str(")");
11959 }
11960 };
11961 match attr {
11962 DlHealthReporter::HealthReporterName(val) => fmt.field("HealthReporterName", &val),
11963 DlHealthReporter::HealthReporterState(val) => {
11964 fmt.field("HealthReporterState", &val)
11965 }
11966 DlHealthReporter::HealthReporterErrCount(val) => {
11967 fmt.field("HealthReporterErrCount", &val)
11968 }
11969 DlHealthReporter::HealthReporterRecoverCount(val) => {
11970 fmt.field("HealthReporterRecoverCount", &val)
11971 }
11972 DlHealthReporter::HealthReporterDumpTs(val) => {
11973 fmt.field("HealthReporterDumpTs", &val)
11974 }
11975 DlHealthReporter::HealthReporterGracefulPeriod(val) => {
11976 fmt.field("HealthReporterGracefulPeriod", &val)
11977 }
11978 DlHealthReporter::HealthReporterAutoRecover(val) => {
11979 fmt.field("HealthReporterAutoRecover", &val)
11980 }
11981 DlHealthReporter::HealthReporterDumpTsNs(val) => {
11982 fmt.field("HealthReporterDumpTsNs", &val)
11983 }
11984 DlHealthReporter::HealthReporterAutoDump(val) => {
11985 fmt.field("HealthReporterAutoDump", &val)
11986 }
11987 DlHealthReporter::HealthReporterBurstPeriod(val) => {
11988 fmt.field("HealthReporterBurstPeriod", &val)
11989 }
11990 };
11991 }
11992 fmt.finish()
11993 }
11994}
11995impl IterableDlHealthReporter<'_> {
11996 pub fn lookup_attr(
11997 &self,
11998 offset: usize,
11999 missing_type: Option<u16>,
12000 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
12001 let mut stack = Vec::new();
12002 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
12003 if missing_type.is_some() && cur == offset {
12004 stack.push(("DlHealthReporter", offset));
12005 return (
12006 stack,
12007 missing_type.and_then(|t| DlHealthReporter::attr_from_type(t)),
12008 );
12009 }
12010 if cur > offset || cur + self.buf.len() < offset {
12011 return (stack, None);
12012 }
12013 let mut attrs = self.clone();
12014 let mut last_off = cur + attrs.pos;
12015 while let Some(attr) = attrs.next() {
12016 let Ok(attr) = attr else { break };
12017 match attr {
12018 DlHealthReporter::HealthReporterName(val) => {
12019 if last_off == offset {
12020 stack.push(("HealthReporterName", last_off));
12021 break;
12022 }
12023 }
12024 DlHealthReporter::HealthReporterState(val) => {
12025 if last_off == offset {
12026 stack.push(("HealthReporterState", last_off));
12027 break;
12028 }
12029 }
12030 DlHealthReporter::HealthReporterErrCount(val) => {
12031 if last_off == offset {
12032 stack.push(("HealthReporterErrCount", last_off));
12033 break;
12034 }
12035 }
12036 DlHealthReporter::HealthReporterRecoverCount(val) => {
12037 if last_off == offset {
12038 stack.push(("HealthReporterRecoverCount", last_off));
12039 break;
12040 }
12041 }
12042 DlHealthReporter::HealthReporterDumpTs(val) => {
12043 if last_off == offset {
12044 stack.push(("HealthReporterDumpTs", last_off));
12045 break;
12046 }
12047 }
12048 DlHealthReporter::HealthReporterGracefulPeriod(val) => {
12049 if last_off == offset {
12050 stack.push(("HealthReporterGracefulPeriod", last_off));
12051 break;
12052 }
12053 }
12054 DlHealthReporter::HealthReporterAutoRecover(val) => {
12055 if last_off == offset {
12056 stack.push(("HealthReporterAutoRecover", last_off));
12057 break;
12058 }
12059 }
12060 DlHealthReporter::HealthReporterDumpTsNs(val) => {
12061 if last_off == offset {
12062 stack.push(("HealthReporterDumpTsNs", last_off));
12063 break;
12064 }
12065 }
12066 DlHealthReporter::HealthReporterAutoDump(val) => {
12067 if last_off == offset {
12068 stack.push(("HealthReporterAutoDump", last_off));
12069 break;
12070 }
12071 }
12072 DlHealthReporter::HealthReporterBurstPeriod(val) => {
12073 if last_off == offset {
12074 stack.push(("HealthReporterBurstPeriod", last_off));
12075 break;
12076 }
12077 }
12078 _ => {}
12079 };
12080 last_off = cur + attrs.pos;
12081 }
12082 if !stack.is_empty() {
12083 stack.push(("DlHealthReporter", cur));
12084 }
12085 (stack, None)
12086 }
12087}
12088#[derive(Clone)]
12089pub enum DlAttrStats {
12090 StatsRxPackets(u64),
12091 StatsRxBytes(u64),
12092 StatsRxDropped(u64),
12093}
12094impl<'a> IterableDlAttrStats<'a> {
12095 pub fn get_stats_rx_packets(&self) -> Result<u64, ErrorContext> {
12096 let mut iter = self.clone();
12097 iter.pos = 0;
12098 for attr in iter {
12099 if let Ok(DlAttrStats::StatsRxPackets(val)) = attr {
12100 return Ok(val);
12101 }
12102 }
12103 Err(ErrorContext::new_missing(
12104 "DlAttrStats",
12105 "StatsRxPackets",
12106 self.orig_loc,
12107 self.buf.as_ptr() as usize,
12108 ))
12109 }
12110 pub fn get_stats_rx_bytes(&self) -> Result<u64, ErrorContext> {
12111 let mut iter = self.clone();
12112 iter.pos = 0;
12113 for attr in iter {
12114 if let Ok(DlAttrStats::StatsRxBytes(val)) = attr {
12115 return Ok(val);
12116 }
12117 }
12118 Err(ErrorContext::new_missing(
12119 "DlAttrStats",
12120 "StatsRxBytes",
12121 self.orig_loc,
12122 self.buf.as_ptr() as usize,
12123 ))
12124 }
12125 pub fn get_stats_rx_dropped(&self) -> Result<u64, ErrorContext> {
12126 let mut iter = self.clone();
12127 iter.pos = 0;
12128 for attr in iter {
12129 if let Ok(DlAttrStats::StatsRxDropped(val)) = attr {
12130 return Ok(val);
12131 }
12132 }
12133 Err(ErrorContext::new_missing(
12134 "DlAttrStats",
12135 "StatsRxDropped",
12136 self.orig_loc,
12137 self.buf.as_ptr() as usize,
12138 ))
12139 }
12140}
12141impl DlAttrStats {
12142 pub fn new<'a>(buf: &'a [u8]) -> IterableDlAttrStats<'a> {
12143 IterableDlAttrStats::with_loc(buf, buf.as_ptr() as usize)
12144 }
12145 fn attr_from_type(r#type: u16) -> Option<&'static str> {
12146 let res = match r#type {
12147 0u16 => "StatsRxPackets",
12148 1u16 => "StatsRxBytes",
12149 2u16 => "StatsRxDropped",
12150 _ => return None,
12151 };
12152 Some(res)
12153 }
12154}
12155#[derive(Clone, Copy, Default)]
12156pub struct IterableDlAttrStats<'a> {
12157 buf: &'a [u8],
12158 pos: usize,
12159 orig_loc: usize,
12160}
12161impl<'a> IterableDlAttrStats<'a> {
12162 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
12163 Self {
12164 buf,
12165 pos: 0,
12166 orig_loc,
12167 }
12168 }
12169 pub fn get_buf(&self) -> &'a [u8] {
12170 self.buf
12171 }
12172}
12173impl<'a> Iterator for IterableDlAttrStats<'a> {
12174 type Item = Result<DlAttrStats, ErrorContext>;
12175 fn next(&mut self) -> Option<Self::Item> {
12176 let mut pos;
12177 let mut r#type;
12178 loop {
12179 pos = self.pos;
12180 r#type = None;
12181 if self.buf.len() == self.pos {
12182 return None;
12183 }
12184 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
12185 self.pos = self.buf.len();
12186 break;
12187 };
12188 r#type = Some(header.r#type);
12189 let res = match header.r#type {
12190 0u16 => DlAttrStats::StatsRxPackets({
12191 let res = parse_u64(next);
12192 let Some(val) = res else { break };
12193 val
12194 }),
12195 1u16 => DlAttrStats::StatsRxBytes({
12196 let res = parse_u64(next);
12197 let Some(val) = res else { break };
12198 val
12199 }),
12200 2u16 => DlAttrStats::StatsRxDropped({
12201 let res = parse_u64(next);
12202 let Some(val) = res else { break };
12203 val
12204 }),
12205 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
12206 n => continue,
12207 };
12208 return Some(Ok(res));
12209 }
12210 Some(Err(ErrorContext::new(
12211 "DlAttrStats",
12212 r#type.and_then(|t| DlAttrStats::attr_from_type(t)),
12213 self.orig_loc,
12214 self.buf.as_ptr().wrapping_add(pos) as usize,
12215 )))
12216 }
12217}
12218impl std::fmt::Debug for IterableDlAttrStats<'_> {
12219 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12220 let mut fmt = f.debug_struct("DlAttrStats");
12221 for attr in self.clone() {
12222 let attr = match attr {
12223 Ok(a) => a,
12224 Err(err) => {
12225 fmt.finish()?;
12226 f.write_str("Err(")?;
12227 err.fmt(f)?;
12228 return f.write_str(")");
12229 }
12230 };
12231 match attr {
12232 DlAttrStats::StatsRxPackets(val) => fmt.field("StatsRxPackets", &val),
12233 DlAttrStats::StatsRxBytes(val) => fmt.field("StatsRxBytes", &val),
12234 DlAttrStats::StatsRxDropped(val) => fmt.field("StatsRxDropped", &val),
12235 };
12236 }
12237 fmt.finish()
12238 }
12239}
12240impl IterableDlAttrStats<'_> {
12241 pub fn lookup_attr(
12242 &self,
12243 offset: usize,
12244 missing_type: Option<u16>,
12245 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
12246 let mut stack = Vec::new();
12247 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
12248 if missing_type.is_some() && cur == offset {
12249 stack.push(("DlAttrStats", offset));
12250 return (
12251 stack,
12252 missing_type.and_then(|t| DlAttrStats::attr_from_type(t)),
12253 );
12254 }
12255 if cur > offset || cur + self.buf.len() < offset {
12256 return (stack, None);
12257 }
12258 let mut attrs = self.clone();
12259 let mut last_off = cur + attrs.pos;
12260 while let Some(attr) = attrs.next() {
12261 let Ok(attr) = attr else { break };
12262 match attr {
12263 DlAttrStats::StatsRxPackets(val) => {
12264 if last_off == offset {
12265 stack.push(("StatsRxPackets", last_off));
12266 break;
12267 }
12268 }
12269 DlAttrStats::StatsRxBytes(val) => {
12270 if last_off == offset {
12271 stack.push(("StatsRxBytes", last_off));
12272 break;
12273 }
12274 }
12275 DlAttrStats::StatsRxDropped(val) => {
12276 if last_off == offset {
12277 stack.push(("StatsRxDropped", last_off));
12278 break;
12279 }
12280 }
12281 _ => {}
12282 };
12283 last_off = cur + attrs.pos;
12284 }
12285 if !stack.is_empty() {
12286 stack.push(("DlAttrStats", cur));
12287 }
12288 (stack, None)
12289 }
12290}
12291#[derive(Clone)]
12292pub enum DlTrapMetadata {
12293 TrapMetadataTypeInPort(()),
12294 TrapMetadataTypeFaCookie(()),
12295}
12296impl<'a> IterableDlTrapMetadata<'a> {
12297 pub fn get_trap_metadata_type_in_port(&self) -> Result<(), ErrorContext> {
12298 let mut iter = self.clone();
12299 iter.pos = 0;
12300 for attr in iter {
12301 if let Ok(DlTrapMetadata::TrapMetadataTypeInPort(val)) = attr {
12302 return Ok(val);
12303 }
12304 }
12305 Err(ErrorContext::new_missing(
12306 "DlTrapMetadata",
12307 "TrapMetadataTypeInPort",
12308 self.orig_loc,
12309 self.buf.as_ptr() as usize,
12310 ))
12311 }
12312 pub fn get_trap_metadata_type_fa_cookie(&self) -> Result<(), ErrorContext> {
12313 let mut iter = self.clone();
12314 iter.pos = 0;
12315 for attr in iter {
12316 if let Ok(DlTrapMetadata::TrapMetadataTypeFaCookie(val)) = attr {
12317 return Ok(val);
12318 }
12319 }
12320 Err(ErrorContext::new_missing(
12321 "DlTrapMetadata",
12322 "TrapMetadataTypeFaCookie",
12323 self.orig_loc,
12324 self.buf.as_ptr() as usize,
12325 ))
12326 }
12327}
12328impl DlTrapMetadata {
12329 pub fn new<'a>(buf: &'a [u8]) -> IterableDlTrapMetadata<'a> {
12330 IterableDlTrapMetadata::with_loc(buf, buf.as_ptr() as usize)
12331 }
12332 fn attr_from_type(r#type: u16) -> Option<&'static str> {
12333 let res = match r#type {
12334 0u16 => "TrapMetadataTypeInPort",
12335 1u16 => "TrapMetadataTypeFaCookie",
12336 _ => return None,
12337 };
12338 Some(res)
12339 }
12340}
12341#[derive(Clone, Copy, Default)]
12342pub struct IterableDlTrapMetadata<'a> {
12343 buf: &'a [u8],
12344 pos: usize,
12345 orig_loc: usize,
12346}
12347impl<'a> IterableDlTrapMetadata<'a> {
12348 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
12349 Self {
12350 buf,
12351 pos: 0,
12352 orig_loc,
12353 }
12354 }
12355 pub fn get_buf(&self) -> &'a [u8] {
12356 self.buf
12357 }
12358}
12359impl<'a> Iterator for IterableDlTrapMetadata<'a> {
12360 type Item = Result<DlTrapMetadata, ErrorContext>;
12361 fn next(&mut self) -> Option<Self::Item> {
12362 let mut pos;
12363 let mut r#type;
12364 loop {
12365 pos = self.pos;
12366 r#type = None;
12367 if self.buf.len() == self.pos {
12368 return None;
12369 }
12370 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
12371 self.pos = self.buf.len();
12372 break;
12373 };
12374 r#type = Some(header.r#type);
12375 let res = match header.r#type {
12376 0u16 => DlTrapMetadata::TrapMetadataTypeInPort(()),
12377 1u16 => DlTrapMetadata::TrapMetadataTypeFaCookie(()),
12378 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
12379 n => continue,
12380 };
12381 return Some(Ok(res));
12382 }
12383 Some(Err(ErrorContext::new(
12384 "DlTrapMetadata",
12385 r#type.and_then(|t| DlTrapMetadata::attr_from_type(t)),
12386 self.orig_loc,
12387 self.buf.as_ptr().wrapping_add(pos) as usize,
12388 )))
12389 }
12390}
12391impl std::fmt::Debug for IterableDlTrapMetadata<'_> {
12392 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12393 let mut fmt = f.debug_struct("DlTrapMetadata");
12394 for attr in self.clone() {
12395 let attr = match attr {
12396 Ok(a) => a,
12397 Err(err) => {
12398 fmt.finish()?;
12399 f.write_str("Err(")?;
12400 err.fmt(f)?;
12401 return f.write_str(")");
12402 }
12403 };
12404 match attr {
12405 DlTrapMetadata::TrapMetadataTypeInPort(val) => {
12406 fmt.field("TrapMetadataTypeInPort", &val)
12407 }
12408 DlTrapMetadata::TrapMetadataTypeFaCookie(val) => {
12409 fmt.field("TrapMetadataTypeFaCookie", &val)
12410 }
12411 };
12412 }
12413 fmt.finish()
12414 }
12415}
12416impl IterableDlTrapMetadata<'_> {
12417 pub fn lookup_attr(
12418 &self,
12419 offset: usize,
12420 missing_type: Option<u16>,
12421 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
12422 let mut stack = Vec::new();
12423 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
12424 if missing_type.is_some() && cur == offset {
12425 stack.push(("DlTrapMetadata", offset));
12426 return (
12427 stack,
12428 missing_type.and_then(|t| DlTrapMetadata::attr_from_type(t)),
12429 );
12430 }
12431 if cur > offset || cur + self.buf.len() < offset {
12432 return (stack, None);
12433 }
12434 let mut attrs = self.clone();
12435 let mut last_off = cur + attrs.pos;
12436 while let Some(attr) = attrs.next() {
12437 let Ok(attr) = attr else { break };
12438 match attr {
12439 DlTrapMetadata::TrapMetadataTypeInPort(val) => {
12440 if last_off == offset {
12441 stack.push(("TrapMetadataTypeInPort", last_off));
12442 break;
12443 }
12444 }
12445 DlTrapMetadata::TrapMetadataTypeFaCookie(val) => {
12446 if last_off == offset {
12447 stack.push(("TrapMetadataTypeFaCookie", last_off));
12448 break;
12449 }
12450 }
12451 _ => {}
12452 };
12453 last_off = cur + attrs.pos;
12454 }
12455 if !stack.is_empty() {
12456 stack.push(("DlTrapMetadata", cur));
12457 }
12458 (stack, None)
12459 }
12460}
12461#[derive(Clone)]
12462pub enum DlLinecardSupportedTypes<'a> {
12463 LinecardType(&'a CStr),
12464}
12465impl<'a> IterableDlLinecardSupportedTypes<'a> {
12466 pub fn get_linecard_type(&self) -> Result<&'a CStr, ErrorContext> {
12467 let mut iter = self.clone();
12468 iter.pos = 0;
12469 for attr in iter {
12470 if let Ok(DlLinecardSupportedTypes::LinecardType(val)) = attr {
12471 return Ok(val);
12472 }
12473 }
12474 Err(ErrorContext::new_missing(
12475 "DlLinecardSupportedTypes",
12476 "LinecardType",
12477 self.orig_loc,
12478 self.buf.as_ptr() as usize,
12479 ))
12480 }
12481}
12482impl DlLinecardSupportedTypes<'_> {
12483 pub fn new<'a>(buf: &'a [u8]) -> IterableDlLinecardSupportedTypes<'a> {
12484 IterableDlLinecardSupportedTypes::with_loc(buf, buf.as_ptr() as usize)
12485 }
12486 fn attr_from_type(r#type: u16) -> Option<&'static str> {
12487 Devlink::attr_from_type(r#type)
12488 }
12489}
12490#[derive(Clone, Copy, Default)]
12491pub struct IterableDlLinecardSupportedTypes<'a> {
12492 buf: &'a [u8],
12493 pos: usize,
12494 orig_loc: usize,
12495}
12496impl<'a> IterableDlLinecardSupportedTypes<'a> {
12497 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
12498 Self {
12499 buf,
12500 pos: 0,
12501 orig_loc,
12502 }
12503 }
12504 pub fn get_buf(&self) -> &'a [u8] {
12505 self.buf
12506 }
12507}
12508impl<'a> Iterator for IterableDlLinecardSupportedTypes<'a> {
12509 type Item = Result<DlLinecardSupportedTypes<'a>, ErrorContext>;
12510 fn next(&mut self) -> Option<Self::Item> {
12511 let mut pos;
12512 let mut r#type;
12513 loop {
12514 pos = self.pos;
12515 r#type = None;
12516 if self.buf.len() == self.pos {
12517 return None;
12518 }
12519 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
12520 self.pos = self.buf.len();
12521 break;
12522 };
12523 r#type = Some(header.r#type);
12524 let res = match header.r#type {
12525 173u16 => DlLinecardSupportedTypes::LinecardType({
12526 let res = CStr::from_bytes_with_nul(next).ok();
12527 let Some(val) = res else { break };
12528 val
12529 }),
12530 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
12531 n => continue,
12532 };
12533 return Some(Ok(res));
12534 }
12535 Some(Err(ErrorContext::new(
12536 "DlLinecardSupportedTypes",
12537 r#type.and_then(|t| DlLinecardSupportedTypes::attr_from_type(t)),
12538 self.orig_loc,
12539 self.buf.as_ptr().wrapping_add(pos) as usize,
12540 )))
12541 }
12542}
12543impl<'a> std::fmt::Debug for IterableDlLinecardSupportedTypes<'_> {
12544 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12545 let mut fmt = f.debug_struct("DlLinecardSupportedTypes");
12546 for attr in self.clone() {
12547 let attr = match attr {
12548 Ok(a) => a,
12549 Err(err) => {
12550 fmt.finish()?;
12551 f.write_str("Err(")?;
12552 err.fmt(f)?;
12553 return f.write_str(")");
12554 }
12555 };
12556 match attr {
12557 DlLinecardSupportedTypes::LinecardType(val) => fmt.field("LinecardType", &val),
12558 };
12559 }
12560 fmt.finish()
12561 }
12562}
12563impl IterableDlLinecardSupportedTypes<'_> {
12564 pub fn lookup_attr(
12565 &self,
12566 offset: usize,
12567 missing_type: Option<u16>,
12568 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
12569 let mut stack = Vec::new();
12570 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
12571 if missing_type.is_some() && cur == offset {
12572 stack.push(("DlLinecardSupportedTypes", offset));
12573 return (
12574 stack,
12575 missing_type.and_then(|t| DlLinecardSupportedTypes::attr_from_type(t)),
12576 );
12577 }
12578 if cur > offset || cur + self.buf.len() < offset {
12579 return (stack, None);
12580 }
12581 let mut attrs = self.clone();
12582 let mut last_off = cur + attrs.pos;
12583 while let Some(attr) = attrs.next() {
12584 let Ok(attr) = attr else { break };
12585 match attr {
12586 DlLinecardSupportedTypes::LinecardType(val) => {
12587 if last_off == offset {
12588 stack.push(("LinecardType", last_off));
12589 break;
12590 }
12591 }
12592 _ => {}
12593 };
12594 last_off = cur + attrs.pos;
12595 }
12596 if !stack.is_empty() {
12597 stack.push(("DlLinecardSupportedTypes", cur));
12598 }
12599 (stack, None)
12600 }
12601}
12602#[derive(Clone)]
12603pub enum DlSelftestId {
12604 Flash(()),
12605}
12606impl<'a> IterableDlSelftestId<'a> {
12607 pub fn get_flash(&self) -> Result<(), ErrorContext> {
12608 let mut iter = self.clone();
12609 iter.pos = 0;
12610 for attr in iter {
12611 if let Ok(DlSelftestId::Flash(val)) = attr {
12612 return Ok(val);
12613 }
12614 }
12615 Err(ErrorContext::new_missing(
12616 "DlSelftestId",
12617 "Flash",
12618 self.orig_loc,
12619 self.buf.as_ptr() as usize,
12620 ))
12621 }
12622}
12623impl DlSelftestId {
12624 pub fn new<'a>(buf: &'a [u8]) -> IterableDlSelftestId<'a> {
12625 IterableDlSelftestId::with_loc(buf, buf.as_ptr() as usize)
12626 }
12627 fn attr_from_type(r#type: u16) -> Option<&'static str> {
12628 let res = match r#type {
12629 1u16 => "Flash",
12630 _ => return None,
12631 };
12632 Some(res)
12633 }
12634}
12635#[derive(Clone, Copy, Default)]
12636pub struct IterableDlSelftestId<'a> {
12637 buf: &'a [u8],
12638 pos: usize,
12639 orig_loc: usize,
12640}
12641impl<'a> IterableDlSelftestId<'a> {
12642 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
12643 Self {
12644 buf,
12645 pos: 0,
12646 orig_loc,
12647 }
12648 }
12649 pub fn get_buf(&self) -> &'a [u8] {
12650 self.buf
12651 }
12652}
12653impl<'a> Iterator for IterableDlSelftestId<'a> {
12654 type Item = Result<DlSelftestId, ErrorContext>;
12655 fn next(&mut self) -> Option<Self::Item> {
12656 let mut pos;
12657 let mut r#type;
12658 loop {
12659 pos = self.pos;
12660 r#type = None;
12661 if self.buf.len() == self.pos {
12662 return None;
12663 }
12664 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
12665 self.pos = self.buf.len();
12666 break;
12667 };
12668 r#type = Some(header.r#type);
12669 let res = match header.r#type {
12670 1u16 => DlSelftestId::Flash(()),
12671 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
12672 n => continue,
12673 };
12674 return Some(Ok(res));
12675 }
12676 Some(Err(ErrorContext::new(
12677 "DlSelftestId",
12678 r#type.and_then(|t| DlSelftestId::attr_from_type(t)),
12679 self.orig_loc,
12680 self.buf.as_ptr().wrapping_add(pos) as usize,
12681 )))
12682 }
12683}
12684impl std::fmt::Debug for IterableDlSelftestId<'_> {
12685 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12686 let mut fmt = f.debug_struct("DlSelftestId");
12687 for attr in self.clone() {
12688 let attr = match attr {
12689 Ok(a) => a,
12690 Err(err) => {
12691 fmt.finish()?;
12692 f.write_str("Err(")?;
12693 err.fmt(f)?;
12694 return f.write_str(")");
12695 }
12696 };
12697 match attr {
12698 DlSelftestId::Flash(val) => fmt.field("Flash", &val),
12699 };
12700 }
12701 fmt.finish()
12702 }
12703}
12704impl IterableDlSelftestId<'_> {
12705 pub fn lookup_attr(
12706 &self,
12707 offset: usize,
12708 missing_type: Option<u16>,
12709 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
12710 let mut stack = Vec::new();
12711 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
12712 if missing_type.is_some() && cur == offset {
12713 stack.push(("DlSelftestId", offset));
12714 return (
12715 stack,
12716 missing_type.and_then(|t| DlSelftestId::attr_from_type(t)),
12717 );
12718 }
12719 if cur > offset || cur + self.buf.len() < offset {
12720 return (stack, None);
12721 }
12722 let mut attrs = self.clone();
12723 let mut last_off = cur + attrs.pos;
12724 while let Some(attr) = attrs.next() {
12725 let Ok(attr) = attr else { break };
12726 match attr {
12727 DlSelftestId::Flash(val) => {
12728 if last_off == offset {
12729 stack.push(("Flash", last_off));
12730 break;
12731 }
12732 }
12733 _ => {}
12734 };
12735 last_off = cur + attrs.pos;
12736 }
12737 if !stack.is_empty() {
12738 stack.push(("DlSelftestId", cur));
12739 }
12740 (stack, None)
12741 }
12742}
12743#[derive(Clone)]
12744pub enum DlRateTcBws {
12745 Index(u8),
12746 #[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"]
12747 Bw(u32),
12748}
12749impl<'a> IterableDlRateTcBws<'a> {
12750 pub fn get_index(&self) -> Result<u8, ErrorContext> {
12751 let mut iter = self.clone();
12752 iter.pos = 0;
12753 for attr in iter {
12754 if let Ok(DlRateTcBws::Index(val)) = attr {
12755 return Ok(val);
12756 }
12757 }
12758 Err(ErrorContext::new_missing(
12759 "DlRateTcBws",
12760 "Index",
12761 self.orig_loc,
12762 self.buf.as_ptr() as usize,
12763 ))
12764 }
12765 #[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"]
12766 pub fn get_bw(&self) -> Result<u32, ErrorContext> {
12767 let mut iter = self.clone();
12768 iter.pos = 0;
12769 for attr in iter {
12770 if let Ok(DlRateTcBws::Bw(val)) = attr {
12771 return Ok(val);
12772 }
12773 }
12774 Err(ErrorContext::new_missing(
12775 "DlRateTcBws",
12776 "Bw",
12777 self.orig_loc,
12778 self.buf.as_ptr() as usize,
12779 ))
12780 }
12781}
12782impl DlRateTcBws {
12783 pub fn new<'a>(buf: &'a [u8]) -> IterableDlRateTcBws<'a> {
12784 IterableDlRateTcBws::with_loc(buf, buf.as_ptr() as usize)
12785 }
12786 fn attr_from_type(r#type: u16) -> Option<&'static str> {
12787 let res = match r#type {
12788 1u16 => "Index",
12789 2u16 => "Bw",
12790 _ => return None,
12791 };
12792 Some(res)
12793 }
12794}
12795#[derive(Clone, Copy, Default)]
12796pub struct IterableDlRateTcBws<'a> {
12797 buf: &'a [u8],
12798 pos: usize,
12799 orig_loc: usize,
12800}
12801impl<'a> IterableDlRateTcBws<'a> {
12802 fn with_loc(buf: &'a [u8], orig_loc: usize) -> Self {
12803 Self {
12804 buf,
12805 pos: 0,
12806 orig_loc,
12807 }
12808 }
12809 pub fn get_buf(&self) -> &'a [u8] {
12810 self.buf
12811 }
12812}
12813impl<'a> Iterator for IterableDlRateTcBws<'a> {
12814 type Item = Result<DlRateTcBws, ErrorContext>;
12815 fn next(&mut self) -> Option<Self::Item> {
12816 let mut pos;
12817 let mut r#type;
12818 loop {
12819 pos = self.pos;
12820 r#type = None;
12821 if self.buf.len() == self.pos {
12822 return None;
12823 }
12824 let Some((header, next)) = chop_header(self.buf, &mut self.pos) else {
12825 self.pos = self.buf.len();
12826 break;
12827 };
12828 r#type = Some(header.r#type);
12829 let res = match header.r#type {
12830 1u16 => DlRateTcBws::Index({
12831 let res = parse_u8(next);
12832 let Some(val) = res else { break };
12833 val
12834 }),
12835 2u16 => DlRateTcBws::Bw({
12836 let res = parse_u32(next);
12837 let Some(val) = res else { break };
12838 val
12839 }),
12840 n if cfg!(any(test, feature = "deny-unknown-attrs")) => break,
12841 n => continue,
12842 };
12843 return Some(Ok(res));
12844 }
12845 Some(Err(ErrorContext::new(
12846 "DlRateTcBws",
12847 r#type.and_then(|t| DlRateTcBws::attr_from_type(t)),
12848 self.orig_loc,
12849 self.buf.as_ptr().wrapping_add(pos) as usize,
12850 )))
12851 }
12852}
12853impl std::fmt::Debug for IterableDlRateTcBws<'_> {
12854 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12855 let mut fmt = f.debug_struct("DlRateTcBws");
12856 for attr in self.clone() {
12857 let attr = match attr {
12858 Ok(a) => a,
12859 Err(err) => {
12860 fmt.finish()?;
12861 f.write_str("Err(")?;
12862 err.fmt(f)?;
12863 return f.write_str(")");
12864 }
12865 };
12866 match attr {
12867 DlRateTcBws::Index(val) => fmt.field("Index", &val),
12868 DlRateTcBws::Bw(val) => fmt.field("Bw", &val),
12869 };
12870 }
12871 fmt.finish()
12872 }
12873}
12874impl IterableDlRateTcBws<'_> {
12875 pub fn lookup_attr(
12876 &self,
12877 offset: usize,
12878 missing_type: Option<u16>,
12879 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
12880 let mut stack = Vec::new();
12881 let cur = ErrorContext::calc_offset(self.orig_loc, self.buf.as_ptr() as usize);
12882 if missing_type.is_some() && cur == offset {
12883 stack.push(("DlRateTcBws", offset));
12884 return (
12885 stack,
12886 missing_type.and_then(|t| DlRateTcBws::attr_from_type(t)),
12887 );
12888 }
12889 if cur > offset || cur + self.buf.len() < offset {
12890 return (stack, None);
12891 }
12892 let mut attrs = self.clone();
12893 let mut last_off = cur + attrs.pos;
12894 while let Some(attr) = attrs.next() {
12895 let Ok(attr) = attr else { break };
12896 match attr {
12897 DlRateTcBws::Index(val) => {
12898 if last_off == offset {
12899 stack.push(("Index", last_off));
12900 break;
12901 }
12902 }
12903 DlRateTcBws::Bw(val) => {
12904 if last_off == offset {
12905 stack.push(("Bw", last_off));
12906 break;
12907 }
12908 }
12909 _ => {}
12910 };
12911 last_off = cur + attrs.pos;
12912 }
12913 if !stack.is_empty() {
12914 stack.push(("DlRateTcBws", cur));
12915 }
12916 (stack, None)
12917 }
12918}
12919pub struct PushDevlink<Prev: Rec> {
12920 pub(crate) prev: Option<Prev>,
12921 pub(crate) header_offset: Option<usize>,
12922}
12923impl<Prev: Rec> Rec for PushDevlink<Prev> {
12924 fn as_rec_mut(&mut self) -> &mut Vec<u8> {
12925 self.prev.as_mut().unwrap().as_rec_mut()
12926 }
12927 fn as_rec(&self) -> &Vec<u8> {
12928 self.prev.as_ref().unwrap().as_rec()
12929 }
12930}
12931impl<Prev: Rec> PushDevlink<Prev> {
12932 pub fn new(prev: Prev) -> Self {
12933 Self {
12934 prev: Some(prev),
12935 header_offset: None,
12936 }
12937 }
12938 pub fn end_nested(mut self) -> Prev {
12939 let mut prev = self.prev.take().unwrap();
12940 if let Some(header_offset) = &self.header_offset {
12941 finalize_nested_header(prev.as_rec_mut(), *header_offset);
12942 }
12943 prev
12944 }
12945 pub fn push_bus_name(mut self, value: &CStr) -> Self {
12946 push_header(
12947 self.as_rec_mut(),
12948 1u16,
12949 value.to_bytes_with_nul().len() as u16,
12950 );
12951 self.as_rec_mut().extend(value.to_bytes_with_nul());
12952 self
12953 }
12954 pub fn push_bus_name_bytes(mut self, value: &[u8]) -> Self {
12955 push_header(self.as_rec_mut(), 1u16, (value.len() + 1) as u16);
12956 self.as_rec_mut().extend(value);
12957 self.as_rec_mut().push(0);
12958 self
12959 }
12960 pub fn push_dev_name(mut self, value: &CStr) -> Self {
12961 push_header(
12962 self.as_rec_mut(),
12963 2u16,
12964 value.to_bytes_with_nul().len() as u16,
12965 );
12966 self.as_rec_mut().extend(value.to_bytes_with_nul());
12967 self
12968 }
12969 pub fn push_dev_name_bytes(mut self, value: &[u8]) -> Self {
12970 push_header(self.as_rec_mut(), 2u16, (value.len() + 1) as u16);
12971 self.as_rec_mut().extend(value);
12972 self.as_rec_mut().push(0);
12973 self
12974 }
12975 pub fn push_port_index(mut self, value: u32) -> Self {
12976 push_header(self.as_rec_mut(), 3u16, 4 as u16);
12977 self.as_rec_mut().extend(value.to_ne_bytes());
12978 self
12979 }
12980 #[doc = "Associated type: [`PortType`] (enum)"]
12981 pub fn push_port_type(mut self, value: u16) -> Self {
12982 push_header(self.as_rec_mut(), 4u16, 2 as u16);
12983 self.as_rec_mut().extend(value.to_ne_bytes());
12984 self
12985 }
12986 pub fn push_port_desired_type(mut self, value: u16) -> Self {
12987 push_header(self.as_rec_mut(), 5u16, 2 as u16);
12988 self.as_rec_mut().extend(value.to_ne_bytes());
12989 self
12990 }
12991 pub fn push_port_netdev_ifindex(mut self, value: u32) -> Self {
12992 push_header(self.as_rec_mut(), 6u16, 4 as u16);
12993 self.as_rec_mut().extend(value.to_ne_bytes());
12994 self
12995 }
12996 pub fn push_port_netdev_name(mut self, value: &CStr) -> Self {
12997 push_header(
12998 self.as_rec_mut(),
12999 7u16,
13000 value.to_bytes_with_nul().len() as u16,
13001 );
13002 self.as_rec_mut().extend(value.to_bytes_with_nul());
13003 self
13004 }
13005 pub fn push_port_netdev_name_bytes(mut self, value: &[u8]) -> Self {
13006 push_header(self.as_rec_mut(), 7u16, (value.len() + 1) as u16);
13007 self.as_rec_mut().extend(value);
13008 self.as_rec_mut().push(0);
13009 self
13010 }
13011 pub fn push_port_ibdev_name(mut self, value: &CStr) -> Self {
13012 push_header(
13013 self.as_rec_mut(),
13014 8u16,
13015 value.to_bytes_with_nul().len() as u16,
13016 );
13017 self.as_rec_mut().extend(value.to_bytes_with_nul());
13018 self
13019 }
13020 pub fn push_port_ibdev_name_bytes(mut self, value: &[u8]) -> Self {
13021 push_header(self.as_rec_mut(), 8u16, (value.len() + 1) as u16);
13022 self.as_rec_mut().extend(value);
13023 self.as_rec_mut().push(0);
13024 self
13025 }
13026 pub fn push_port_split_count(mut self, value: u32) -> Self {
13027 push_header(self.as_rec_mut(), 9u16, 4 as u16);
13028 self.as_rec_mut().extend(value.to_ne_bytes());
13029 self
13030 }
13031 pub fn push_port_split_group(mut self, value: u32) -> Self {
13032 push_header(self.as_rec_mut(), 10u16, 4 as u16);
13033 self.as_rec_mut().extend(value.to_ne_bytes());
13034 self
13035 }
13036 pub fn push_sb_index(mut self, value: u32) -> Self {
13037 push_header(self.as_rec_mut(), 11u16, 4 as u16);
13038 self.as_rec_mut().extend(value.to_ne_bytes());
13039 self
13040 }
13041 pub fn push_sb_size(mut self, value: u32) -> Self {
13042 push_header(self.as_rec_mut(), 12u16, 4 as u16);
13043 self.as_rec_mut().extend(value.to_ne_bytes());
13044 self
13045 }
13046 pub fn push_sb_ingress_pool_count(mut self, value: u16) -> Self {
13047 push_header(self.as_rec_mut(), 13u16, 2 as u16);
13048 self.as_rec_mut().extend(value.to_ne_bytes());
13049 self
13050 }
13051 pub fn push_sb_egress_pool_count(mut self, value: u16) -> Self {
13052 push_header(self.as_rec_mut(), 14u16, 2 as u16);
13053 self.as_rec_mut().extend(value.to_ne_bytes());
13054 self
13055 }
13056 pub fn push_sb_ingress_tc_count(mut self, value: u16) -> Self {
13057 push_header(self.as_rec_mut(), 15u16, 2 as u16);
13058 self.as_rec_mut().extend(value.to_ne_bytes());
13059 self
13060 }
13061 pub fn push_sb_egress_tc_count(mut self, value: u16) -> Self {
13062 push_header(self.as_rec_mut(), 16u16, 2 as u16);
13063 self.as_rec_mut().extend(value.to_ne_bytes());
13064 self
13065 }
13066 pub fn push_sb_pool_index(mut self, value: u16) -> Self {
13067 push_header(self.as_rec_mut(), 17u16, 2 as u16);
13068 self.as_rec_mut().extend(value.to_ne_bytes());
13069 self
13070 }
13071 #[doc = "Associated type: [`SbPoolType`] (enum)"]
13072 pub fn push_sb_pool_type(mut self, value: u8) -> Self {
13073 push_header(self.as_rec_mut(), 18u16, 1 as u16);
13074 self.as_rec_mut().extend(value.to_ne_bytes());
13075 self
13076 }
13077 pub fn push_sb_pool_size(mut self, value: u32) -> Self {
13078 push_header(self.as_rec_mut(), 19u16, 4 as u16);
13079 self.as_rec_mut().extend(value.to_ne_bytes());
13080 self
13081 }
13082 #[doc = "Associated type: [`SbThresholdType`] (enum)"]
13083 pub fn push_sb_pool_threshold_type(mut self, value: u8) -> Self {
13084 push_header(self.as_rec_mut(), 20u16, 1 as u16);
13085 self.as_rec_mut().extend(value.to_ne_bytes());
13086 self
13087 }
13088 pub fn push_sb_threshold(mut self, value: u32) -> Self {
13089 push_header(self.as_rec_mut(), 21u16, 4 as u16);
13090 self.as_rec_mut().extend(value.to_ne_bytes());
13091 self
13092 }
13093 pub fn push_sb_tc_index(mut self, value: u16) -> Self {
13094 push_header(self.as_rec_mut(), 22u16, 2 as u16);
13095 self.as_rec_mut().extend(value.to_ne_bytes());
13096 self
13097 }
13098 pub fn push_sb_occ_cur(mut self, value: u32) -> Self {
13099 push_header(self.as_rec_mut(), 23u16, 4 as u16);
13100 self.as_rec_mut().extend(value.to_ne_bytes());
13101 self
13102 }
13103 pub fn push_sb_occ_max(mut self, value: u32) -> Self {
13104 push_header(self.as_rec_mut(), 24u16, 4 as u16);
13105 self.as_rec_mut().extend(value.to_ne_bytes());
13106 self
13107 }
13108 #[doc = "Associated type: [`EswitchMode`] (enum)"]
13109 pub fn push_eswitch_mode(mut self, value: u16) -> Self {
13110 push_header(self.as_rec_mut(), 25u16, 2 as u16);
13111 self.as_rec_mut().extend(value.to_ne_bytes());
13112 self
13113 }
13114 #[doc = "Associated type: [`EswitchInlineMode`] (enum)"]
13115 pub fn push_eswitch_inline_mode(mut self, value: u8) -> Self {
13116 push_header(self.as_rec_mut(), 26u16, 1 as u16);
13117 self.as_rec_mut().extend(value.to_ne_bytes());
13118 self
13119 }
13120 pub fn nested_dpipe_tables(mut self) -> PushDlDpipeTables<Self> {
13121 let header_offset = push_nested_header(self.as_rec_mut(), 27u16);
13122 PushDlDpipeTables {
13123 prev: Some(self),
13124 header_offset: Some(header_offset),
13125 }
13126 }
13127 #[doc = "Attribute may repeat multiple times (treat it as array)"]
13128 pub fn nested_dpipe_table(mut self) -> PushDlDpipeTable<Self> {
13129 let header_offset = push_nested_header(self.as_rec_mut(), 28u16);
13130 PushDlDpipeTable {
13131 prev: Some(self),
13132 header_offset: Some(header_offset),
13133 }
13134 }
13135 pub fn push_dpipe_table_name(mut self, value: &CStr) -> Self {
13136 push_header(
13137 self.as_rec_mut(),
13138 29u16,
13139 value.to_bytes_with_nul().len() as u16,
13140 );
13141 self.as_rec_mut().extend(value.to_bytes_with_nul());
13142 self
13143 }
13144 pub fn push_dpipe_table_name_bytes(mut self, value: &[u8]) -> Self {
13145 push_header(self.as_rec_mut(), 29u16, (value.len() + 1) as u16);
13146 self.as_rec_mut().extend(value);
13147 self.as_rec_mut().push(0);
13148 self
13149 }
13150 pub fn push_dpipe_table_size(mut self, value: u64) -> Self {
13151 push_header(self.as_rec_mut(), 30u16, 8 as u16);
13152 self.as_rec_mut().extend(value.to_ne_bytes());
13153 self
13154 }
13155 pub fn nested_dpipe_table_matches(mut self) -> PushDlDpipeTableMatches<Self> {
13156 let header_offset = push_nested_header(self.as_rec_mut(), 31u16);
13157 PushDlDpipeTableMatches {
13158 prev: Some(self),
13159 header_offset: Some(header_offset),
13160 }
13161 }
13162 pub fn nested_dpipe_table_actions(mut self) -> PushDlDpipeTableActions<Self> {
13163 let header_offset = push_nested_header(self.as_rec_mut(), 32u16);
13164 PushDlDpipeTableActions {
13165 prev: Some(self),
13166 header_offset: Some(header_offset),
13167 }
13168 }
13169 pub fn push_dpipe_table_counters_enabled(mut self, value: u8) -> Self {
13170 push_header(self.as_rec_mut(), 33u16, 1 as u16);
13171 self.as_rec_mut().extend(value.to_ne_bytes());
13172 self
13173 }
13174 pub fn nested_dpipe_entries(mut self) -> PushDlDpipeEntries<Self> {
13175 let header_offset = push_nested_header(self.as_rec_mut(), 34u16);
13176 PushDlDpipeEntries {
13177 prev: Some(self),
13178 header_offset: Some(header_offset),
13179 }
13180 }
13181 #[doc = "Attribute may repeat multiple times (treat it as array)"]
13182 pub fn nested_dpipe_entry(mut self) -> PushDlDpipeEntry<Self> {
13183 let header_offset = push_nested_header(self.as_rec_mut(), 35u16);
13184 PushDlDpipeEntry {
13185 prev: Some(self),
13186 header_offset: Some(header_offset),
13187 }
13188 }
13189 pub fn push_dpipe_entry_index(mut self, value: u64) -> Self {
13190 push_header(self.as_rec_mut(), 36u16, 8 as u16);
13191 self.as_rec_mut().extend(value.to_ne_bytes());
13192 self
13193 }
13194 pub fn nested_dpipe_entry_match_values(mut self) -> PushDlDpipeEntryMatchValues<Self> {
13195 let header_offset = push_nested_header(self.as_rec_mut(), 37u16);
13196 PushDlDpipeEntryMatchValues {
13197 prev: Some(self),
13198 header_offset: Some(header_offset),
13199 }
13200 }
13201 pub fn nested_dpipe_entry_action_values(mut self) -> PushDlDpipeEntryActionValues<Self> {
13202 let header_offset = push_nested_header(self.as_rec_mut(), 38u16);
13203 PushDlDpipeEntryActionValues {
13204 prev: Some(self),
13205 header_offset: Some(header_offset),
13206 }
13207 }
13208 pub fn push_dpipe_entry_counter(mut self, value: u64) -> Self {
13209 push_header(self.as_rec_mut(), 39u16, 8 as u16);
13210 self.as_rec_mut().extend(value.to_ne_bytes());
13211 self
13212 }
13213 #[doc = "Attribute may repeat multiple times (treat it as array)"]
13214 pub fn nested_dpipe_match(mut self) -> PushDlDpipeMatch<Self> {
13215 let header_offset = push_nested_header(self.as_rec_mut(), 40u16);
13216 PushDlDpipeMatch {
13217 prev: Some(self),
13218 header_offset: Some(header_offset),
13219 }
13220 }
13221 #[doc = "Attribute may repeat multiple times (treat it as array)"]
13222 pub fn nested_dpipe_match_value(mut self) -> PushDlDpipeMatchValue<Self> {
13223 let header_offset = push_nested_header(self.as_rec_mut(), 41u16);
13224 PushDlDpipeMatchValue {
13225 prev: Some(self),
13226 header_offset: Some(header_offset),
13227 }
13228 }
13229 #[doc = "Associated type: [`DpipeMatchType`] (enum)"]
13230 pub fn push_dpipe_match_type(mut self, value: u32) -> Self {
13231 push_header(self.as_rec_mut(), 42u16, 4 as u16);
13232 self.as_rec_mut().extend(value.to_ne_bytes());
13233 self
13234 }
13235 #[doc = "Attribute may repeat multiple times (treat it as array)"]
13236 pub fn nested_dpipe_action(mut self) -> PushDlDpipeAction<Self> {
13237 let header_offset = push_nested_header(self.as_rec_mut(), 43u16);
13238 PushDlDpipeAction {
13239 prev: Some(self),
13240 header_offset: Some(header_offset),
13241 }
13242 }
13243 #[doc = "Attribute may repeat multiple times (treat it as array)"]
13244 pub fn nested_dpipe_action_value(mut self) -> PushDlDpipeActionValue<Self> {
13245 let header_offset = push_nested_header(self.as_rec_mut(), 44u16);
13246 PushDlDpipeActionValue {
13247 prev: Some(self),
13248 header_offset: Some(header_offset),
13249 }
13250 }
13251 #[doc = "Associated type: [`DpipeActionType`] (enum)"]
13252 pub fn push_dpipe_action_type(mut self, value: u32) -> Self {
13253 push_header(self.as_rec_mut(), 45u16, 4 as u16);
13254 self.as_rec_mut().extend(value.to_ne_bytes());
13255 self
13256 }
13257 pub fn push_dpipe_value(mut self, value: &[u8]) -> Self {
13258 push_header(self.as_rec_mut(), 46u16, value.len() as u16);
13259 self.as_rec_mut().extend(value);
13260 self
13261 }
13262 pub fn push_dpipe_value_mask(mut self, value: &[u8]) -> Self {
13263 push_header(self.as_rec_mut(), 47u16, value.len() as u16);
13264 self.as_rec_mut().extend(value);
13265 self
13266 }
13267 pub fn push_dpipe_value_mapping(mut self, value: u32) -> Self {
13268 push_header(self.as_rec_mut(), 48u16, 4 as u16);
13269 self.as_rec_mut().extend(value.to_ne_bytes());
13270 self
13271 }
13272 pub fn nested_dpipe_headers(mut self) -> PushDlDpipeHeaders<Self> {
13273 let header_offset = push_nested_header(self.as_rec_mut(), 49u16);
13274 PushDlDpipeHeaders {
13275 prev: Some(self),
13276 header_offset: Some(header_offset),
13277 }
13278 }
13279 #[doc = "Attribute may repeat multiple times (treat it as array)"]
13280 pub fn nested_dpipe_header(mut self) -> PushDlDpipeHeader<Self> {
13281 let header_offset = push_nested_header(self.as_rec_mut(), 50u16);
13282 PushDlDpipeHeader {
13283 prev: Some(self),
13284 header_offset: Some(header_offset),
13285 }
13286 }
13287 pub fn push_dpipe_header_name(mut self, value: &CStr) -> Self {
13288 push_header(
13289 self.as_rec_mut(),
13290 51u16,
13291 value.to_bytes_with_nul().len() as u16,
13292 );
13293 self.as_rec_mut().extend(value.to_bytes_with_nul());
13294 self
13295 }
13296 pub fn push_dpipe_header_name_bytes(mut self, value: &[u8]) -> Self {
13297 push_header(self.as_rec_mut(), 51u16, (value.len() + 1) as u16);
13298 self.as_rec_mut().extend(value);
13299 self.as_rec_mut().push(0);
13300 self
13301 }
13302 #[doc = "Associated type: [`DpipeHeaderId`] (enum)"]
13303 pub fn push_dpipe_header_id(mut self, value: u32) -> Self {
13304 push_header(self.as_rec_mut(), 52u16, 4 as u16);
13305 self.as_rec_mut().extend(value.to_ne_bytes());
13306 self
13307 }
13308 pub fn nested_dpipe_header_fields(mut self) -> PushDlDpipeHeaderFields<Self> {
13309 let header_offset = push_nested_header(self.as_rec_mut(), 53u16);
13310 PushDlDpipeHeaderFields {
13311 prev: Some(self),
13312 header_offset: Some(header_offset),
13313 }
13314 }
13315 pub fn push_dpipe_header_global(mut self, value: u8) -> Self {
13316 push_header(self.as_rec_mut(), 54u16, 1 as u16);
13317 self.as_rec_mut().extend(value.to_ne_bytes());
13318 self
13319 }
13320 pub fn push_dpipe_header_index(mut self, value: u32) -> Self {
13321 push_header(self.as_rec_mut(), 55u16, 4 as u16);
13322 self.as_rec_mut().extend(value.to_ne_bytes());
13323 self
13324 }
13325 #[doc = "Attribute may repeat multiple times (treat it as array)"]
13326 pub fn nested_dpipe_field(mut self) -> PushDlDpipeField<Self> {
13327 let header_offset = push_nested_header(self.as_rec_mut(), 56u16);
13328 PushDlDpipeField {
13329 prev: Some(self),
13330 header_offset: Some(header_offset),
13331 }
13332 }
13333 pub fn push_dpipe_field_name(mut self, value: &CStr) -> Self {
13334 push_header(
13335 self.as_rec_mut(),
13336 57u16,
13337 value.to_bytes_with_nul().len() as u16,
13338 );
13339 self.as_rec_mut().extend(value.to_bytes_with_nul());
13340 self
13341 }
13342 pub fn push_dpipe_field_name_bytes(mut self, value: &[u8]) -> Self {
13343 push_header(self.as_rec_mut(), 57u16, (value.len() + 1) as u16);
13344 self.as_rec_mut().extend(value);
13345 self.as_rec_mut().push(0);
13346 self
13347 }
13348 pub fn push_dpipe_field_id(mut self, value: u32) -> Self {
13349 push_header(self.as_rec_mut(), 58u16, 4 as u16);
13350 self.as_rec_mut().extend(value.to_ne_bytes());
13351 self
13352 }
13353 pub fn push_dpipe_field_bitwidth(mut self, value: u32) -> Self {
13354 push_header(self.as_rec_mut(), 59u16, 4 as u16);
13355 self.as_rec_mut().extend(value.to_ne_bytes());
13356 self
13357 }
13358 #[doc = "Associated type: [`DpipeFieldMappingType`] (enum)"]
13359 pub fn push_dpipe_field_mapping_type(mut self, value: u32) -> Self {
13360 push_header(self.as_rec_mut(), 60u16, 4 as u16);
13361 self.as_rec_mut().extend(value.to_ne_bytes());
13362 self
13363 }
13364 pub fn push_pad(mut self, value: &[u8]) -> Self {
13365 push_header(self.as_rec_mut(), 61u16, value.len() as u16);
13366 self.as_rec_mut().extend(value);
13367 self
13368 }
13369 #[doc = "Associated type: [`EswitchEncapMode`] (enum)"]
13370 pub fn push_eswitch_encap_mode(mut self, value: u8) -> Self {
13371 push_header(self.as_rec_mut(), 62u16, 1 as u16);
13372 self.as_rec_mut().extend(value.to_ne_bytes());
13373 self
13374 }
13375 pub fn nested_resource_list(mut self) -> PushDlResourceList<Self> {
13376 let header_offset = push_nested_header(self.as_rec_mut(), 63u16);
13377 PushDlResourceList {
13378 prev: Some(self),
13379 header_offset: Some(header_offset),
13380 }
13381 }
13382 #[doc = "Attribute may repeat multiple times (treat it as array)"]
13383 pub fn nested_resource(mut self) -> PushDlResource<Self> {
13384 let header_offset = push_nested_header(self.as_rec_mut(), 64u16);
13385 PushDlResource {
13386 prev: Some(self),
13387 header_offset: Some(header_offset),
13388 }
13389 }
13390 pub fn push_resource_name(mut self, value: &CStr) -> Self {
13391 push_header(
13392 self.as_rec_mut(),
13393 65u16,
13394 value.to_bytes_with_nul().len() as u16,
13395 );
13396 self.as_rec_mut().extend(value.to_bytes_with_nul());
13397 self
13398 }
13399 pub fn push_resource_name_bytes(mut self, value: &[u8]) -> Self {
13400 push_header(self.as_rec_mut(), 65u16, (value.len() + 1) as u16);
13401 self.as_rec_mut().extend(value);
13402 self.as_rec_mut().push(0);
13403 self
13404 }
13405 pub fn push_resource_id(mut self, value: u64) -> Self {
13406 push_header(self.as_rec_mut(), 66u16, 8 as u16);
13407 self.as_rec_mut().extend(value.to_ne_bytes());
13408 self
13409 }
13410 pub fn push_resource_size(mut self, value: u64) -> Self {
13411 push_header(self.as_rec_mut(), 67u16, 8 as u16);
13412 self.as_rec_mut().extend(value.to_ne_bytes());
13413 self
13414 }
13415 pub fn push_resource_size_new(mut self, value: u64) -> Self {
13416 push_header(self.as_rec_mut(), 68u16, 8 as u16);
13417 self.as_rec_mut().extend(value.to_ne_bytes());
13418 self
13419 }
13420 pub fn push_resource_size_valid(mut self, value: u8) -> Self {
13421 push_header(self.as_rec_mut(), 69u16, 1 as u16);
13422 self.as_rec_mut().extend(value.to_ne_bytes());
13423 self
13424 }
13425 pub fn push_resource_size_min(mut self, value: u64) -> Self {
13426 push_header(self.as_rec_mut(), 70u16, 8 as u16);
13427 self.as_rec_mut().extend(value.to_ne_bytes());
13428 self
13429 }
13430 pub fn push_resource_size_max(mut self, value: u64) -> Self {
13431 push_header(self.as_rec_mut(), 71u16, 8 as u16);
13432 self.as_rec_mut().extend(value.to_ne_bytes());
13433 self
13434 }
13435 pub fn push_resource_size_gran(mut self, value: u64) -> Self {
13436 push_header(self.as_rec_mut(), 72u16, 8 as u16);
13437 self.as_rec_mut().extend(value.to_ne_bytes());
13438 self
13439 }
13440 #[doc = "Associated type: [`ResourceUnit`] (enum)"]
13441 pub fn push_resource_unit(mut self, value: u8) -> Self {
13442 push_header(self.as_rec_mut(), 73u16, 1 as u16);
13443 self.as_rec_mut().extend(value.to_ne_bytes());
13444 self
13445 }
13446 pub fn push_resource_occ(mut self, value: u64) -> Self {
13447 push_header(self.as_rec_mut(), 74u16, 8 as u16);
13448 self.as_rec_mut().extend(value.to_ne_bytes());
13449 self
13450 }
13451 pub fn push_dpipe_table_resource_id(mut self, value: u64) -> Self {
13452 push_header(self.as_rec_mut(), 75u16, 8 as u16);
13453 self.as_rec_mut().extend(value.to_ne_bytes());
13454 self
13455 }
13456 pub fn push_dpipe_table_resource_units(mut self, value: u64) -> Self {
13457 push_header(self.as_rec_mut(), 76u16, 8 as u16);
13458 self.as_rec_mut().extend(value.to_ne_bytes());
13459 self
13460 }
13461 #[doc = "Associated type: [`PortFlavour`] (enum)"]
13462 pub fn push_port_flavour(mut self, value: u16) -> Self {
13463 push_header(self.as_rec_mut(), 77u16, 2 as u16);
13464 self.as_rec_mut().extend(value.to_ne_bytes());
13465 self
13466 }
13467 pub fn push_port_number(mut self, value: u32) -> Self {
13468 push_header(self.as_rec_mut(), 78u16, 4 as u16);
13469 self.as_rec_mut().extend(value.to_ne_bytes());
13470 self
13471 }
13472 pub fn push_port_split_subport_number(mut self, value: u32) -> Self {
13473 push_header(self.as_rec_mut(), 79u16, 4 as u16);
13474 self.as_rec_mut().extend(value.to_ne_bytes());
13475 self
13476 }
13477 pub fn nested_param(mut self) -> PushDlParam<Self> {
13478 let header_offset = push_nested_header(self.as_rec_mut(), 80u16);
13479 PushDlParam {
13480 prev: Some(self),
13481 header_offset: Some(header_offset),
13482 }
13483 }
13484 pub fn push_param_name(mut self, value: &CStr) -> Self {
13485 push_header(
13486 self.as_rec_mut(),
13487 81u16,
13488 value.to_bytes_with_nul().len() as u16,
13489 );
13490 self.as_rec_mut().extend(value.to_bytes_with_nul());
13491 self
13492 }
13493 pub fn push_param_name_bytes(mut self, value: &[u8]) -> Self {
13494 push_header(self.as_rec_mut(), 81u16, (value.len() + 1) as u16);
13495 self.as_rec_mut().extend(value);
13496 self.as_rec_mut().push(0);
13497 self
13498 }
13499 pub fn push_param_generic(mut self, value: ()) -> Self {
13500 push_header(self.as_rec_mut(), 82u16, 0 as u16);
13501 self
13502 }
13503 #[doc = "Associated type: [`VarAttrType`] (enum)"]
13504 pub fn push_param_type(mut self, value: u8) -> Self {
13505 push_header(self.as_rec_mut(), 83u16, 1 as u16);
13506 self.as_rec_mut().extend(value.to_ne_bytes());
13507 self
13508 }
13509 #[doc = "Associated type: [`ParamCmode`] (enum)"]
13510 pub fn push_param_value_cmode(mut self, value: u8) -> Self {
13511 push_header(self.as_rec_mut(), 87u16, 1 as u16);
13512 self.as_rec_mut().extend(value.to_ne_bytes());
13513 self
13514 }
13515 pub fn push_region_name(mut self, value: &CStr) -> Self {
13516 push_header(
13517 self.as_rec_mut(),
13518 88u16,
13519 value.to_bytes_with_nul().len() as u16,
13520 );
13521 self.as_rec_mut().extend(value.to_bytes_with_nul());
13522 self
13523 }
13524 pub fn push_region_name_bytes(mut self, value: &[u8]) -> Self {
13525 push_header(self.as_rec_mut(), 88u16, (value.len() + 1) as u16);
13526 self.as_rec_mut().extend(value);
13527 self.as_rec_mut().push(0);
13528 self
13529 }
13530 pub fn push_region_size(mut self, value: u64) -> Self {
13531 push_header(self.as_rec_mut(), 89u16, 8 as u16);
13532 self.as_rec_mut().extend(value.to_ne_bytes());
13533 self
13534 }
13535 pub fn nested_region_snapshots(mut self) -> PushDlRegionSnapshots<Self> {
13536 let header_offset = push_nested_header(self.as_rec_mut(), 90u16);
13537 PushDlRegionSnapshots {
13538 prev: Some(self),
13539 header_offset: Some(header_offset),
13540 }
13541 }
13542 pub fn nested_region_snapshot(mut self) -> PushDlRegionSnapshot<Self> {
13543 let header_offset = push_nested_header(self.as_rec_mut(), 91u16);
13544 PushDlRegionSnapshot {
13545 prev: Some(self),
13546 header_offset: Some(header_offset),
13547 }
13548 }
13549 pub fn push_region_snapshot_id(mut self, value: u32) -> Self {
13550 push_header(self.as_rec_mut(), 92u16, 4 as u16);
13551 self.as_rec_mut().extend(value.to_ne_bytes());
13552 self
13553 }
13554 pub fn nested_region_chunks(mut self) -> PushDlRegionChunks<Self> {
13555 let header_offset = push_nested_header(self.as_rec_mut(), 93u16);
13556 PushDlRegionChunks {
13557 prev: Some(self),
13558 header_offset: Some(header_offset),
13559 }
13560 }
13561 pub fn nested_region_chunk(mut self) -> PushDlRegionChunk<Self> {
13562 let header_offset = push_nested_header(self.as_rec_mut(), 94u16);
13563 PushDlRegionChunk {
13564 prev: Some(self),
13565 header_offset: Some(header_offset),
13566 }
13567 }
13568 pub fn push_region_chunk_data(mut self, value: &[u8]) -> Self {
13569 push_header(self.as_rec_mut(), 95u16, value.len() as u16);
13570 self.as_rec_mut().extend(value);
13571 self
13572 }
13573 pub fn push_region_chunk_addr(mut self, value: u64) -> Self {
13574 push_header(self.as_rec_mut(), 96u16, 8 as u16);
13575 self.as_rec_mut().extend(value.to_ne_bytes());
13576 self
13577 }
13578 pub fn push_region_chunk_len(mut self, value: u64) -> Self {
13579 push_header(self.as_rec_mut(), 97u16, 8 as u16);
13580 self.as_rec_mut().extend(value.to_ne_bytes());
13581 self
13582 }
13583 pub fn push_info_driver_name(mut self, value: &CStr) -> Self {
13584 push_header(
13585 self.as_rec_mut(),
13586 98u16,
13587 value.to_bytes_with_nul().len() as u16,
13588 );
13589 self.as_rec_mut().extend(value.to_bytes_with_nul());
13590 self
13591 }
13592 pub fn push_info_driver_name_bytes(mut self, value: &[u8]) -> Self {
13593 push_header(self.as_rec_mut(), 98u16, (value.len() + 1) as u16);
13594 self.as_rec_mut().extend(value);
13595 self.as_rec_mut().push(0);
13596 self
13597 }
13598 pub fn push_info_serial_number(mut self, value: &CStr) -> Self {
13599 push_header(
13600 self.as_rec_mut(),
13601 99u16,
13602 value.to_bytes_with_nul().len() as u16,
13603 );
13604 self.as_rec_mut().extend(value.to_bytes_with_nul());
13605 self
13606 }
13607 pub fn push_info_serial_number_bytes(mut self, value: &[u8]) -> Self {
13608 push_header(self.as_rec_mut(), 99u16, (value.len() + 1) as u16);
13609 self.as_rec_mut().extend(value);
13610 self.as_rec_mut().push(0);
13611 self
13612 }
13613 #[doc = "Attribute may repeat multiple times (treat it as array)"]
13614 pub fn nested_info_version_fixed(mut self) -> PushDlInfoVersion<Self> {
13615 let header_offset = push_nested_header(self.as_rec_mut(), 100u16);
13616 PushDlInfoVersion {
13617 prev: Some(self),
13618 header_offset: Some(header_offset),
13619 }
13620 }
13621 #[doc = "Attribute may repeat multiple times (treat it as array)"]
13622 pub fn nested_info_version_running(mut self) -> PushDlInfoVersion<Self> {
13623 let header_offset = push_nested_header(self.as_rec_mut(), 101u16);
13624 PushDlInfoVersion {
13625 prev: Some(self),
13626 header_offset: Some(header_offset),
13627 }
13628 }
13629 #[doc = "Attribute may repeat multiple times (treat it as array)"]
13630 pub fn nested_info_version_stored(mut self) -> PushDlInfoVersion<Self> {
13631 let header_offset = push_nested_header(self.as_rec_mut(), 102u16);
13632 PushDlInfoVersion {
13633 prev: Some(self),
13634 header_offset: Some(header_offset),
13635 }
13636 }
13637 pub fn push_info_version_name(mut self, value: &CStr) -> Self {
13638 push_header(
13639 self.as_rec_mut(),
13640 103u16,
13641 value.to_bytes_with_nul().len() as u16,
13642 );
13643 self.as_rec_mut().extend(value.to_bytes_with_nul());
13644 self
13645 }
13646 pub fn push_info_version_name_bytes(mut self, value: &[u8]) -> Self {
13647 push_header(self.as_rec_mut(), 103u16, (value.len() + 1) as u16);
13648 self.as_rec_mut().extend(value);
13649 self.as_rec_mut().push(0);
13650 self
13651 }
13652 pub fn push_info_version_value(mut self, value: &CStr) -> Self {
13653 push_header(
13654 self.as_rec_mut(),
13655 104u16,
13656 value.to_bytes_with_nul().len() as u16,
13657 );
13658 self.as_rec_mut().extend(value.to_bytes_with_nul());
13659 self
13660 }
13661 pub fn push_info_version_value_bytes(mut self, value: &[u8]) -> Self {
13662 push_header(self.as_rec_mut(), 104u16, (value.len() + 1) as u16);
13663 self.as_rec_mut().extend(value);
13664 self.as_rec_mut().push(0);
13665 self
13666 }
13667 pub fn push_sb_pool_cell_size(mut self, value: u32) -> Self {
13668 push_header(self.as_rec_mut(), 105u16, 4 as u16);
13669 self.as_rec_mut().extend(value.to_ne_bytes());
13670 self
13671 }
13672 pub fn nested_fmsg(mut self) -> PushDlFmsg<Self> {
13673 let header_offset = push_nested_header(self.as_rec_mut(), 106u16);
13674 PushDlFmsg {
13675 prev: Some(self),
13676 header_offset: Some(header_offset),
13677 }
13678 }
13679 pub fn push_fmsg_obj_nest_start(mut self, value: ()) -> Self {
13680 push_header(self.as_rec_mut(), 107u16, 0 as u16);
13681 self
13682 }
13683 pub fn push_fmsg_pair_nest_start(mut self, value: ()) -> Self {
13684 push_header(self.as_rec_mut(), 108u16, 0 as u16);
13685 self
13686 }
13687 pub fn push_fmsg_arr_nest_start(mut self, value: ()) -> Self {
13688 push_header(self.as_rec_mut(), 109u16, 0 as u16);
13689 self
13690 }
13691 pub fn push_fmsg_nest_end(mut self, value: ()) -> Self {
13692 push_header(self.as_rec_mut(), 110u16, 0 as u16);
13693 self
13694 }
13695 pub fn push_fmsg_obj_name(mut self, value: &CStr) -> Self {
13696 push_header(
13697 self.as_rec_mut(),
13698 111u16,
13699 value.to_bytes_with_nul().len() as u16,
13700 );
13701 self.as_rec_mut().extend(value.to_bytes_with_nul());
13702 self
13703 }
13704 pub fn push_fmsg_obj_name_bytes(mut self, value: &[u8]) -> Self {
13705 push_header(self.as_rec_mut(), 111u16, (value.len() + 1) as u16);
13706 self.as_rec_mut().extend(value);
13707 self.as_rec_mut().push(0);
13708 self
13709 }
13710 #[doc = "Associated type: [`VarAttrType`] (enum)"]
13711 pub fn push_fmsg_obj_value_type(mut self, value: u8) -> Self {
13712 push_header(self.as_rec_mut(), 112u16, 1 as u16);
13713 self.as_rec_mut().extend(value.to_ne_bytes());
13714 self
13715 }
13716 pub fn nested_health_reporter(mut self) -> PushDlHealthReporter<Self> {
13717 let header_offset = push_nested_header(self.as_rec_mut(), 114u16);
13718 PushDlHealthReporter {
13719 prev: Some(self),
13720 header_offset: Some(header_offset),
13721 }
13722 }
13723 pub fn push_health_reporter_name(mut self, value: &CStr) -> Self {
13724 push_header(
13725 self.as_rec_mut(),
13726 115u16,
13727 value.to_bytes_with_nul().len() as u16,
13728 );
13729 self.as_rec_mut().extend(value.to_bytes_with_nul());
13730 self
13731 }
13732 pub fn push_health_reporter_name_bytes(mut self, value: &[u8]) -> Self {
13733 push_header(self.as_rec_mut(), 115u16, (value.len() + 1) as u16);
13734 self.as_rec_mut().extend(value);
13735 self.as_rec_mut().push(0);
13736 self
13737 }
13738 pub fn push_health_reporter_state(mut self, value: u8) -> Self {
13739 push_header(self.as_rec_mut(), 116u16, 1 as u16);
13740 self.as_rec_mut().extend(value.to_ne_bytes());
13741 self
13742 }
13743 pub fn push_health_reporter_err_count(mut self, value: u64) -> Self {
13744 push_header(self.as_rec_mut(), 117u16, 8 as u16);
13745 self.as_rec_mut().extend(value.to_ne_bytes());
13746 self
13747 }
13748 pub fn push_health_reporter_recover_count(mut self, value: u64) -> Self {
13749 push_header(self.as_rec_mut(), 118u16, 8 as u16);
13750 self.as_rec_mut().extend(value.to_ne_bytes());
13751 self
13752 }
13753 pub fn push_health_reporter_dump_ts(mut self, value: u64) -> Self {
13754 push_header(self.as_rec_mut(), 119u16, 8 as u16);
13755 self.as_rec_mut().extend(value.to_ne_bytes());
13756 self
13757 }
13758 pub fn push_health_reporter_graceful_period(mut self, value: u64) -> Self {
13759 push_header(self.as_rec_mut(), 120u16, 8 as u16);
13760 self.as_rec_mut().extend(value.to_ne_bytes());
13761 self
13762 }
13763 pub fn push_health_reporter_auto_recover(mut self, value: u8) -> Self {
13764 push_header(self.as_rec_mut(), 121u16, 1 as u16);
13765 self.as_rec_mut().extend(value.to_ne_bytes());
13766 self
13767 }
13768 pub fn push_flash_update_file_name(mut self, value: &CStr) -> Self {
13769 push_header(
13770 self.as_rec_mut(),
13771 122u16,
13772 value.to_bytes_with_nul().len() as u16,
13773 );
13774 self.as_rec_mut().extend(value.to_bytes_with_nul());
13775 self
13776 }
13777 pub fn push_flash_update_file_name_bytes(mut self, value: &[u8]) -> Self {
13778 push_header(self.as_rec_mut(), 122u16, (value.len() + 1) as u16);
13779 self.as_rec_mut().extend(value);
13780 self.as_rec_mut().push(0);
13781 self
13782 }
13783 pub fn push_flash_update_component(mut self, value: &CStr) -> Self {
13784 push_header(
13785 self.as_rec_mut(),
13786 123u16,
13787 value.to_bytes_with_nul().len() as u16,
13788 );
13789 self.as_rec_mut().extend(value.to_bytes_with_nul());
13790 self
13791 }
13792 pub fn push_flash_update_component_bytes(mut self, value: &[u8]) -> Self {
13793 push_header(self.as_rec_mut(), 123u16, (value.len() + 1) as u16);
13794 self.as_rec_mut().extend(value);
13795 self.as_rec_mut().push(0);
13796 self
13797 }
13798 pub fn push_flash_update_status_msg(mut self, value: &CStr) -> Self {
13799 push_header(
13800 self.as_rec_mut(),
13801 124u16,
13802 value.to_bytes_with_nul().len() as u16,
13803 );
13804 self.as_rec_mut().extend(value.to_bytes_with_nul());
13805 self
13806 }
13807 pub fn push_flash_update_status_msg_bytes(mut self, value: &[u8]) -> Self {
13808 push_header(self.as_rec_mut(), 124u16, (value.len() + 1) as u16);
13809 self.as_rec_mut().extend(value);
13810 self.as_rec_mut().push(0);
13811 self
13812 }
13813 pub fn push_flash_update_status_done(mut self, value: u64) -> Self {
13814 push_header(self.as_rec_mut(), 125u16, 8 as u16);
13815 self.as_rec_mut().extend(value.to_ne_bytes());
13816 self
13817 }
13818 pub fn push_flash_update_status_total(mut self, value: u64) -> Self {
13819 push_header(self.as_rec_mut(), 126u16, 8 as u16);
13820 self.as_rec_mut().extend(value.to_ne_bytes());
13821 self
13822 }
13823 pub fn push_port_pci_pf_number(mut self, value: u16) -> Self {
13824 push_header(self.as_rec_mut(), 127u16, 2 as u16);
13825 self.as_rec_mut().extend(value.to_ne_bytes());
13826 self
13827 }
13828 pub fn push_port_pci_vf_number(mut self, value: u16) -> Self {
13829 push_header(self.as_rec_mut(), 128u16, 2 as u16);
13830 self.as_rec_mut().extend(value.to_ne_bytes());
13831 self
13832 }
13833 pub fn nested_stats(mut self) -> PushDlAttrStats<Self> {
13834 let header_offset = push_nested_header(self.as_rec_mut(), 129u16);
13835 PushDlAttrStats {
13836 prev: Some(self),
13837 header_offset: Some(header_offset),
13838 }
13839 }
13840 pub fn push_trap_name(mut self, value: &CStr) -> Self {
13841 push_header(
13842 self.as_rec_mut(),
13843 130u16,
13844 value.to_bytes_with_nul().len() as u16,
13845 );
13846 self.as_rec_mut().extend(value.to_bytes_with_nul());
13847 self
13848 }
13849 pub fn push_trap_name_bytes(mut self, value: &[u8]) -> Self {
13850 push_header(self.as_rec_mut(), 130u16, (value.len() + 1) as u16);
13851 self.as_rec_mut().extend(value);
13852 self.as_rec_mut().push(0);
13853 self
13854 }
13855 #[doc = "Associated type: [`TrapAction`] (enum)"]
13856 pub fn push_trap_action(mut self, value: u8) -> Self {
13857 push_header(self.as_rec_mut(), 131u16, 1 as u16);
13858 self.as_rec_mut().extend(value.to_ne_bytes());
13859 self
13860 }
13861 #[doc = "Associated type: [`TrapType`] (enum)"]
13862 pub fn push_trap_type(mut self, value: u8) -> Self {
13863 push_header(self.as_rec_mut(), 132u16, 1 as u16);
13864 self.as_rec_mut().extend(value.to_ne_bytes());
13865 self
13866 }
13867 pub fn push_trap_generic(mut self, value: ()) -> Self {
13868 push_header(self.as_rec_mut(), 133u16, 0 as u16);
13869 self
13870 }
13871 pub fn nested_trap_metadata(mut self) -> PushDlTrapMetadata<Self> {
13872 let header_offset = push_nested_header(self.as_rec_mut(), 134u16);
13873 PushDlTrapMetadata {
13874 prev: Some(self),
13875 header_offset: Some(header_offset),
13876 }
13877 }
13878 pub fn push_trap_group_name(mut self, value: &CStr) -> Self {
13879 push_header(
13880 self.as_rec_mut(),
13881 135u16,
13882 value.to_bytes_with_nul().len() as u16,
13883 );
13884 self.as_rec_mut().extend(value.to_bytes_with_nul());
13885 self
13886 }
13887 pub fn push_trap_group_name_bytes(mut self, value: &[u8]) -> Self {
13888 push_header(self.as_rec_mut(), 135u16, (value.len() + 1) as u16);
13889 self.as_rec_mut().extend(value);
13890 self.as_rec_mut().push(0);
13891 self
13892 }
13893 pub fn push_reload_failed(mut self, value: u8) -> Self {
13894 push_header(self.as_rec_mut(), 136u16, 1 as u16);
13895 self.as_rec_mut().extend(value.to_ne_bytes());
13896 self
13897 }
13898 pub fn push_health_reporter_dump_ts_ns(mut self, value: u64) -> Self {
13899 push_header(self.as_rec_mut(), 137u16, 8 as u16);
13900 self.as_rec_mut().extend(value.to_ne_bytes());
13901 self
13902 }
13903 pub fn push_netns_fd(mut self, value: u32) -> Self {
13904 push_header(self.as_rec_mut(), 138u16, 4 as u16);
13905 self.as_rec_mut().extend(value.to_ne_bytes());
13906 self
13907 }
13908 pub fn push_netns_pid(mut self, value: u32) -> Self {
13909 push_header(self.as_rec_mut(), 139u16, 4 as u16);
13910 self.as_rec_mut().extend(value.to_ne_bytes());
13911 self
13912 }
13913 pub fn push_netns_id(mut self, value: u32) -> Self {
13914 push_header(self.as_rec_mut(), 140u16, 4 as u16);
13915 self.as_rec_mut().extend(value.to_ne_bytes());
13916 self
13917 }
13918 pub fn push_health_reporter_auto_dump(mut self, value: u8) -> Self {
13919 push_header(self.as_rec_mut(), 141u16, 1 as u16);
13920 self.as_rec_mut().extend(value.to_ne_bytes());
13921 self
13922 }
13923 pub fn push_trap_policer_id(mut self, value: u32) -> Self {
13924 push_header(self.as_rec_mut(), 142u16, 4 as u16);
13925 self.as_rec_mut().extend(value.to_ne_bytes());
13926 self
13927 }
13928 pub fn push_trap_policer_rate(mut self, value: u64) -> Self {
13929 push_header(self.as_rec_mut(), 143u16, 8 as u16);
13930 self.as_rec_mut().extend(value.to_ne_bytes());
13931 self
13932 }
13933 pub fn push_trap_policer_burst(mut self, value: u64) -> Self {
13934 push_header(self.as_rec_mut(), 144u16, 8 as u16);
13935 self.as_rec_mut().extend(value.to_ne_bytes());
13936 self
13937 }
13938 pub fn nested_port_function(mut self) -> PushDlPortFunction<Self> {
13939 let header_offset = push_nested_header(self.as_rec_mut(), 145u16);
13940 PushDlPortFunction {
13941 prev: Some(self),
13942 header_offset: Some(header_offset),
13943 }
13944 }
13945 pub fn push_info_board_serial_number(mut self, value: &CStr) -> Self {
13946 push_header(
13947 self.as_rec_mut(),
13948 146u16,
13949 value.to_bytes_with_nul().len() as u16,
13950 );
13951 self.as_rec_mut().extend(value.to_bytes_with_nul());
13952 self
13953 }
13954 pub fn push_info_board_serial_number_bytes(mut self, value: &[u8]) -> Self {
13955 push_header(self.as_rec_mut(), 146u16, (value.len() + 1) as u16);
13956 self.as_rec_mut().extend(value);
13957 self.as_rec_mut().push(0);
13958 self
13959 }
13960 pub fn push_port_lanes(mut self, value: u32) -> Self {
13961 push_header(self.as_rec_mut(), 147u16, 4 as u16);
13962 self.as_rec_mut().extend(value.to_ne_bytes());
13963 self
13964 }
13965 pub fn push_port_splittable(mut self, value: u8) -> Self {
13966 push_header(self.as_rec_mut(), 148u16, 1 as u16);
13967 self.as_rec_mut().extend(value.to_ne_bytes());
13968 self
13969 }
13970 pub fn push_port_external(mut self, value: u8) -> Self {
13971 push_header(self.as_rec_mut(), 149u16, 1 as u16);
13972 self.as_rec_mut().extend(value.to_ne_bytes());
13973 self
13974 }
13975 pub fn push_port_controller_number(mut self, value: u32) -> Self {
13976 push_header(self.as_rec_mut(), 150u16, 4 as u16);
13977 self.as_rec_mut().extend(value.to_ne_bytes());
13978 self
13979 }
13980 pub fn push_flash_update_status_timeout(mut self, value: u64) -> Self {
13981 push_header(self.as_rec_mut(), 151u16, 8 as u16);
13982 self.as_rec_mut().extend(value.to_ne_bytes());
13983 self
13984 }
13985 #[doc = "Associated type: [`FlashOverwrite`] (1 bit per enumeration)"]
13986 pub fn push_flash_update_overwrite_mask(mut self, value: BuiltinBitfield32) -> Self {
13987 push_header(self.as_rec_mut(), 152u16, value.as_slice().len() as u16);
13988 self.as_rec_mut().extend(value.as_slice());
13989 self
13990 }
13991 #[doc = "Associated type: [`ReloadAction`] (enum)"]
13992 pub fn push_reload_action(mut self, value: u8) -> Self {
13993 push_header(self.as_rec_mut(), 153u16, 1 as u16);
13994 self.as_rec_mut().extend(value.to_ne_bytes());
13995 self
13996 }
13997 #[doc = "Associated type: [`ReloadAction`] (1 bit per enumeration)"]
13998 pub fn push_reload_actions_performed(mut self, value: BuiltinBitfield32) -> Self {
13999 push_header(self.as_rec_mut(), 154u16, value.as_slice().len() as u16);
14000 self.as_rec_mut().extend(value.as_slice());
14001 self
14002 }
14003 #[doc = "Associated type: [`ReloadAction`] (1 bit per enumeration)"]
14004 pub fn push_reload_limits(mut self, value: BuiltinBitfield32) -> Self {
14005 push_header(self.as_rec_mut(), 155u16, value.as_slice().len() as u16);
14006 self.as_rec_mut().extend(value.as_slice());
14007 self
14008 }
14009 pub fn nested_dev_stats(mut self) -> PushDlDevStats<Self> {
14010 let header_offset = push_nested_header(self.as_rec_mut(), 156u16);
14011 PushDlDevStats {
14012 prev: Some(self),
14013 header_offset: Some(header_offset),
14014 }
14015 }
14016 pub fn nested_reload_stats(mut self) -> PushDlReloadStats<Self> {
14017 let header_offset = push_nested_header(self.as_rec_mut(), 157u16);
14018 PushDlReloadStats {
14019 prev: Some(self),
14020 header_offset: Some(header_offset),
14021 }
14022 }
14023 #[doc = "Attribute may repeat multiple times (treat it as array)"]
14024 pub fn nested_reload_stats_entry(mut self) -> PushDlReloadStatsEntry<Self> {
14025 let header_offset = push_nested_header(self.as_rec_mut(), 158u16);
14026 PushDlReloadStatsEntry {
14027 prev: Some(self),
14028 header_offset: Some(header_offset),
14029 }
14030 }
14031 pub fn push_reload_stats_limit(mut self, value: u8) -> Self {
14032 push_header(self.as_rec_mut(), 159u16, 1 as u16);
14033 self.as_rec_mut().extend(value.to_ne_bytes());
14034 self
14035 }
14036 pub fn push_reload_stats_value(mut self, value: u32) -> Self {
14037 push_header(self.as_rec_mut(), 160u16, 4 as u16);
14038 self.as_rec_mut().extend(value.to_ne_bytes());
14039 self
14040 }
14041 pub fn nested_remote_reload_stats(mut self) -> PushDlReloadStats<Self> {
14042 let header_offset = push_nested_header(self.as_rec_mut(), 161u16);
14043 PushDlReloadStats {
14044 prev: Some(self),
14045 header_offset: Some(header_offset),
14046 }
14047 }
14048 #[doc = "Attribute may repeat multiple times (treat it as array)"]
14049 pub fn nested_reload_action_info(mut self) -> PushDlReloadActInfo<Self> {
14050 let header_offset = push_nested_header(self.as_rec_mut(), 162u16);
14051 PushDlReloadActInfo {
14052 prev: Some(self),
14053 header_offset: Some(header_offset),
14054 }
14055 }
14056 #[doc = "Attribute may repeat multiple times (treat it as array)"]
14057 pub fn nested_reload_action_stats(mut self) -> PushDlReloadActStats<Self> {
14058 let header_offset = push_nested_header(self.as_rec_mut(), 163u16);
14059 PushDlReloadActStats {
14060 prev: Some(self),
14061 header_offset: Some(header_offset),
14062 }
14063 }
14064 pub fn push_port_pci_sf_number(mut self, value: u32) -> Self {
14065 push_header(self.as_rec_mut(), 164u16, 4 as u16);
14066 self.as_rec_mut().extend(value.to_ne_bytes());
14067 self
14068 }
14069 #[doc = "Associated type: [`RateType`] (enum)"]
14070 pub fn push_rate_type(mut self, value: u16) -> Self {
14071 push_header(self.as_rec_mut(), 165u16, 2 as u16);
14072 self.as_rec_mut().extend(value.to_ne_bytes());
14073 self
14074 }
14075 pub fn push_rate_tx_share(mut self, value: u64) -> Self {
14076 push_header(self.as_rec_mut(), 166u16, 8 as u16);
14077 self.as_rec_mut().extend(value.to_ne_bytes());
14078 self
14079 }
14080 pub fn push_rate_tx_max(mut self, value: u64) -> Self {
14081 push_header(self.as_rec_mut(), 167u16, 8 as u16);
14082 self.as_rec_mut().extend(value.to_ne_bytes());
14083 self
14084 }
14085 pub fn push_rate_node_name(mut self, value: &CStr) -> Self {
14086 push_header(
14087 self.as_rec_mut(),
14088 168u16,
14089 value.to_bytes_with_nul().len() as u16,
14090 );
14091 self.as_rec_mut().extend(value.to_bytes_with_nul());
14092 self
14093 }
14094 pub fn push_rate_node_name_bytes(mut self, value: &[u8]) -> Self {
14095 push_header(self.as_rec_mut(), 168u16, (value.len() + 1) as u16);
14096 self.as_rec_mut().extend(value);
14097 self.as_rec_mut().push(0);
14098 self
14099 }
14100 pub fn push_rate_parent_node_name(mut self, value: &CStr) -> Self {
14101 push_header(
14102 self.as_rec_mut(),
14103 169u16,
14104 value.to_bytes_with_nul().len() as u16,
14105 );
14106 self.as_rec_mut().extend(value.to_bytes_with_nul());
14107 self
14108 }
14109 pub fn push_rate_parent_node_name_bytes(mut self, value: &[u8]) -> Self {
14110 push_header(self.as_rec_mut(), 169u16, (value.len() + 1) as u16);
14111 self.as_rec_mut().extend(value);
14112 self.as_rec_mut().push(0);
14113 self
14114 }
14115 pub fn push_region_max_snapshots(mut self, value: u32) -> Self {
14116 push_header(self.as_rec_mut(), 170u16, 4 as u16);
14117 self.as_rec_mut().extend(value.to_ne_bytes());
14118 self
14119 }
14120 pub fn push_linecard_index(mut self, value: u32) -> Self {
14121 push_header(self.as_rec_mut(), 171u16, 4 as u16);
14122 self.as_rec_mut().extend(value.to_ne_bytes());
14123 self
14124 }
14125 pub fn push_linecard_state(mut self, value: u8) -> Self {
14126 push_header(self.as_rec_mut(), 172u16, 1 as u16);
14127 self.as_rec_mut().extend(value.to_ne_bytes());
14128 self
14129 }
14130 pub fn push_linecard_type(mut self, value: &CStr) -> Self {
14131 push_header(
14132 self.as_rec_mut(),
14133 173u16,
14134 value.to_bytes_with_nul().len() as u16,
14135 );
14136 self.as_rec_mut().extend(value.to_bytes_with_nul());
14137 self
14138 }
14139 pub fn push_linecard_type_bytes(mut self, value: &[u8]) -> Self {
14140 push_header(self.as_rec_mut(), 173u16, (value.len() + 1) as u16);
14141 self.as_rec_mut().extend(value);
14142 self.as_rec_mut().push(0);
14143 self
14144 }
14145 pub fn nested_linecard_supported_types(mut self) -> PushDlLinecardSupportedTypes<Self> {
14146 let header_offset = push_nested_header(self.as_rec_mut(), 174u16);
14147 PushDlLinecardSupportedTypes {
14148 prev: Some(self),
14149 header_offset: Some(header_offset),
14150 }
14151 }
14152 pub fn nested_selftests(mut self) -> PushDlSelftestId<Self> {
14153 let header_offset = push_nested_header(self.as_rec_mut(), 176u16);
14154 PushDlSelftestId {
14155 prev: Some(self),
14156 header_offset: Some(header_offset),
14157 }
14158 }
14159 pub fn push_rate_tx_priority(mut self, value: u32) -> Self {
14160 push_header(self.as_rec_mut(), 177u16, 4 as u16);
14161 self.as_rec_mut().extend(value.to_ne_bytes());
14162 self
14163 }
14164 pub fn push_rate_tx_weight(mut self, value: u32) -> Self {
14165 push_header(self.as_rec_mut(), 178u16, 4 as u16);
14166 self.as_rec_mut().extend(value.to_ne_bytes());
14167 self
14168 }
14169 pub fn push_region_direct(mut self, value: ()) -> Self {
14170 push_header(self.as_rec_mut(), 179u16, 0 as u16);
14171 self
14172 }
14173 #[doc = "Attribute may repeat multiple times (treat it as array)"]
14174 pub fn nested_rate_tc_bws(mut self) -> PushDlRateTcBws<Self> {
14175 let header_offset = push_nested_header(self.as_rec_mut(), 180u16);
14176 PushDlRateTcBws {
14177 prev: Some(self),
14178 header_offset: Some(header_offset),
14179 }
14180 }
14181 #[doc = "Time (in msec) for recoveries before starting the grace period.\n"]
14182 pub fn push_health_reporter_burst_period(mut self, value: u64) -> Self {
14183 push_header(self.as_rec_mut(), 181u16, 8 as u16);
14184 self.as_rec_mut().extend(value.to_ne_bytes());
14185 self
14186 }
14187 #[doc = "Request restoring parameter to its default value.\n"]
14188 pub fn push_param_reset_default(mut self, value: ()) -> Self {
14189 push_header(self.as_rec_mut(), 183u16, 0 as u16);
14190 self
14191 }
14192 #[doc = "Unique devlink instance index.\n"]
14193 pub fn push_index(mut self, value: u32) -> Self {
14194 push_header(self.as_rec_mut(), 184u16, 4 as u16);
14195 self.as_rec_mut().extend(value.to_ne_bytes());
14196 self
14197 }
14198 #[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)"]
14199 pub fn push_resource_scope_mask(mut self, value: u32) -> Self {
14200 push_header(self.as_rec_mut(), 185u16, 4 as u16);
14201 self.as_rec_mut().extend(value.to_ne_bytes());
14202 self
14203 }
14204}
14205impl<Prev: Rec> Drop for PushDevlink<Prev> {
14206 fn drop(&mut self) {
14207 if let Some(prev) = &mut self.prev {
14208 if let Some(header_offset) = &self.header_offset {
14209 finalize_nested_header(prev.as_rec_mut(), *header_offset);
14210 }
14211 }
14212 }
14213}
14214pub struct PushDlDevStats<Prev: Rec> {
14215 pub(crate) prev: Option<Prev>,
14216 pub(crate) header_offset: Option<usize>,
14217}
14218impl<Prev: Rec> Rec for PushDlDevStats<Prev> {
14219 fn as_rec_mut(&mut self) -> &mut Vec<u8> {
14220 self.prev.as_mut().unwrap().as_rec_mut()
14221 }
14222 fn as_rec(&self) -> &Vec<u8> {
14223 self.prev.as_ref().unwrap().as_rec()
14224 }
14225}
14226impl<Prev: Rec> PushDlDevStats<Prev> {
14227 pub fn new(prev: Prev) -> Self {
14228 Self {
14229 prev: Some(prev),
14230 header_offset: None,
14231 }
14232 }
14233 pub fn end_nested(mut self) -> Prev {
14234 let mut prev = self.prev.take().unwrap();
14235 if let Some(header_offset) = &self.header_offset {
14236 finalize_nested_header(prev.as_rec_mut(), *header_offset);
14237 }
14238 prev
14239 }
14240 pub fn nested_reload_stats(mut self) -> PushDlReloadStats<Self> {
14241 let header_offset = push_nested_header(self.as_rec_mut(), 157u16);
14242 PushDlReloadStats {
14243 prev: Some(self),
14244 header_offset: Some(header_offset),
14245 }
14246 }
14247 pub fn nested_remote_reload_stats(mut self) -> PushDlReloadStats<Self> {
14248 let header_offset = push_nested_header(self.as_rec_mut(), 161u16);
14249 PushDlReloadStats {
14250 prev: Some(self),
14251 header_offset: Some(header_offset),
14252 }
14253 }
14254}
14255impl<Prev: Rec> Drop for PushDlDevStats<Prev> {
14256 fn drop(&mut self) {
14257 if let Some(prev) = &mut self.prev {
14258 if let Some(header_offset) = &self.header_offset {
14259 finalize_nested_header(prev.as_rec_mut(), *header_offset);
14260 }
14261 }
14262 }
14263}
14264pub struct PushDlReloadStats<Prev: Rec> {
14265 pub(crate) prev: Option<Prev>,
14266 pub(crate) header_offset: Option<usize>,
14267}
14268impl<Prev: Rec> Rec for PushDlReloadStats<Prev> {
14269 fn as_rec_mut(&mut self) -> &mut Vec<u8> {
14270 self.prev.as_mut().unwrap().as_rec_mut()
14271 }
14272 fn as_rec(&self) -> &Vec<u8> {
14273 self.prev.as_ref().unwrap().as_rec()
14274 }
14275}
14276impl<Prev: Rec> PushDlReloadStats<Prev> {
14277 pub fn new(prev: Prev) -> Self {
14278 Self {
14279 prev: Some(prev),
14280 header_offset: None,
14281 }
14282 }
14283 pub fn end_nested(mut self) -> Prev {
14284 let mut prev = self.prev.take().unwrap();
14285 if let Some(header_offset) = &self.header_offset {
14286 finalize_nested_header(prev.as_rec_mut(), *header_offset);
14287 }
14288 prev
14289 }
14290 #[doc = "Attribute may repeat multiple times (treat it as array)"]
14291 pub fn nested_reload_action_info(mut self) -> PushDlReloadActInfo<Self> {
14292 let header_offset = push_nested_header(self.as_rec_mut(), 162u16);
14293 PushDlReloadActInfo {
14294 prev: Some(self),
14295 header_offset: Some(header_offset),
14296 }
14297 }
14298}
14299impl<Prev: Rec> Drop for PushDlReloadStats<Prev> {
14300 fn drop(&mut self) {
14301 if let Some(prev) = &mut self.prev {
14302 if let Some(header_offset) = &self.header_offset {
14303 finalize_nested_header(prev.as_rec_mut(), *header_offset);
14304 }
14305 }
14306 }
14307}
14308pub struct PushDlReloadActInfo<Prev: Rec> {
14309 pub(crate) prev: Option<Prev>,
14310 pub(crate) header_offset: Option<usize>,
14311}
14312impl<Prev: Rec> Rec for PushDlReloadActInfo<Prev> {
14313 fn as_rec_mut(&mut self) -> &mut Vec<u8> {
14314 self.prev.as_mut().unwrap().as_rec_mut()
14315 }
14316 fn as_rec(&self) -> &Vec<u8> {
14317 self.prev.as_ref().unwrap().as_rec()
14318 }
14319}
14320impl<Prev: Rec> PushDlReloadActInfo<Prev> {
14321 pub fn new(prev: Prev) -> Self {
14322 Self {
14323 prev: Some(prev),
14324 header_offset: None,
14325 }
14326 }
14327 pub fn end_nested(mut self) -> Prev {
14328 let mut prev = self.prev.take().unwrap();
14329 if let Some(header_offset) = &self.header_offset {
14330 finalize_nested_header(prev.as_rec_mut(), *header_offset);
14331 }
14332 prev
14333 }
14334 #[doc = "Associated type: [`ReloadAction`] (enum)"]
14335 pub fn push_reload_action(mut self, value: u8) -> Self {
14336 push_header(self.as_rec_mut(), 153u16, 1 as u16);
14337 self.as_rec_mut().extend(value.to_ne_bytes());
14338 self
14339 }
14340 #[doc = "Attribute may repeat multiple times (treat it as array)"]
14341 pub fn nested_reload_action_stats(mut self) -> PushDlReloadActStats<Self> {
14342 let header_offset = push_nested_header(self.as_rec_mut(), 163u16);
14343 PushDlReloadActStats {
14344 prev: Some(self),
14345 header_offset: Some(header_offset),
14346 }
14347 }
14348}
14349impl<Prev: Rec> Drop for PushDlReloadActInfo<Prev> {
14350 fn drop(&mut self) {
14351 if let Some(prev) = &mut self.prev {
14352 if let Some(header_offset) = &self.header_offset {
14353 finalize_nested_header(prev.as_rec_mut(), *header_offset);
14354 }
14355 }
14356 }
14357}
14358pub struct PushDlReloadActStats<Prev: Rec> {
14359 pub(crate) prev: Option<Prev>,
14360 pub(crate) header_offset: Option<usize>,
14361}
14362impl<Prev: Rec> Rec for PushDlReloadActStats<Prev> {
14363 fn as_rec_mut(&mut self) -> &mut Vec<u8> {
14364 self.prev.as_mut().unwrap().as_rec_mut()
14365 }
14366 fn as_rec(&self) -> &Vec<u8> {
14367 self.prev.as_ref().unwrap().as_rec()
14368 }
14369}
14370impl<Prev: Rec> PushDlReloadActStats<Prev> {
14371 pub fn new(prev: Prev) -> Self {
14372 Self {
14373 prev: Some(prev),
14374 header_offset: None,
14375 }
14376 }
14377 pub fn end_nested(mut self) -> Prev {
14378 let mut prev = self.prev.take().unwrap();
14379 if let Some(header_offset) = &self.header_offset {
14380 finalize_nested_header(prev.as_rec_mut(), *header_offset);
14381 }
14382 prev
14383 }
14384 #[doc = "Attribute may repeat multiple times (treat it as array)"]
14385 pub fn nested_reload_stats_entry(mut self) -> PushDlReloadStatsEntry<Self> {
14386 let header_offset = push_nested_header(self.as_rec_mut(), 158u16);
14387 PushDlReloadStatsEntry {
14388 prev: Some(self),
14389 header_offset: Some(header_offset),
14390 }
14391 }
14392}
14393impl<Prev: Rec> Drop for PushDlReloadActStats<Prev> {
14394 fn drop(&mut self) {
14395 if let Some(prev) = &mut self.prev {
14396 if let Some(header_offset) = &self.header_offset {
14397 finalize_nested_header(prev.as_rec_mut(), *header_offset);
14398 }
14399 }
14400 }
14401}
14402pub struct PushDlReloadStatsEntry<Prev: Rec> {
14403 pub(crate) prev: Option<Prev>,
14404 pub(crate) header_offset: Option<usize>,
14405}
14406impl<Prev: Rec> Rec for PushDlReloadStatsEntry<Prev> {
14407 fn as_rec_mut(&mut self) -> &mut Vec<u8> {
14408 self.prev.as_mut().unwrap().as_rec_mut()
14409 }
14410 fn as_rec(&self) -> &Vec<u8> {
14411 self.prev.as_ref().unwrap().as_rec()
14412 }
14413}
14414impl<Prev: Rec> PushDlReloadStatsEntry<Prev> {
14415 pub fn new(prev: Prev) -> Self {
14416 Self {
14417 prev: Some(prev),
14418 header_offset: None,
14419 }
14420 }
14421 pub fn end_nested(mut self) -> Prev {
14422 let mut prev = self.prev.take().unwrap();
14423 if let Some(header_offset) = &self.header_offset {
14424 finalize_nested_header(prev.as_rec_mut(), *header_offset);
14425 }
14426 prev
14427 }
14428 pub fn push_reload_stats_limit(mut self, value: u8) -> Self {
14429 push_header(self.as_rec_mut(), 159u16, 1 as u16);
14430 self.as_rec_mut().extend(value.to_ne_bytes());
14431 self
14432 }
14433 pub fn push_reload_stats_value(mut self, value: u32) -> Self {
14434 push_header(self.as_rec_mut(), 160u16, 4 as u16);
14435 self.as_rec_mut().extend(value.to_ne_bytes());
14436 self
14437 }
14438}
14439impl<Prev: Rec> Drop for PushDlReloadStatsEntry<Prev> {
14440 fn drop(&mut self) {
14441 if let Some(prev) = &mut self.prev {
14442 if let Some(header_offset) = &self.header_offset {
14443 finalize_nested_header(prev.as_rec_mut(), *header_offset);
14444 }
14445 }
14446 }
14447}
14448pub struct PushDlInfoVersion<Prev: Rec> {
14449 pub(crate) prev: Option<Prev>,
14450 pub(crate) header_offset: Option<usize>,
14451}
14452impl<Prev: Rec> Rec for PushDlInfoVersion<Prev> {
14453 fn as_rec_mut(&mut self) -> &mut Vec<u8> {
14454 self.prev.as_mut().unwrap().as_rec_mut()
14455 }
14456 fn as_rec(&self) -> &Vec<u8> {
14457 self.prev.as_ref().unwrap().as_rec()
14458 }
14459}
14460impl<Prev: Rec> PushDlInfoVersion<Prev> {
14461 pub fn new(prev: Prev) -> Self {
14462 Self {
14463 prev: Some(prev),
14464 header_offset: None,
14465 }
14466 }
14467 pub fn end_nested(mut self) -> Prev {
14468 let mut prev = self.prev.take().unwrap();
14469 if let Some(header_offset) = &self.header_offset {
14470 finalize_nested_header(prev.as_rec_mut(), *header_offset);
14471 }
14472 prev
14473 }
14474 pub fn push_info_version_name(mut self, value: &CStr) -> Self {
14475 push_header(
14476 self.as_rec_mut(),
14477 103u16,
14478 value.to_bytes_with_nul().len() as u16,
14479 );
14480 self.as_rec_mut().extend(value.to_bytes_with_nul());
14481 self
14482 }
14483 pub fn push_info_version_name_bytes(mut self, value: &[u8]) -> Self {
14484 push_header(self.as_rec_mut(), 103u16, (value.len() + 1) as u16);
14485 self.as_rec_mut().extend(value);
14486 self.as_rec_mut().push(0);
14487 self
14488 }
14489 pub fn push_info_version_value(mut self, value: &CStr) -> Self {
14490 push_header(
14491 self.as_rec_mut(),
14492 104u16,
14493 value.to_bytes_with_nul().len() as u16,
14494 );
14495 self.as_rec_mut().extend(value.to_bytes_with_nul());
14496 self
14497 }
14498 pub fn push_info_version_value_bytes(mut self, value: &[u8]) -> Self {
14499 push_header(self.as_rec_mut(), 104u16, (value.len() + 1) as u16);
14500 self.as_rec_mut().extend(value);
14501 self.as_rec_mut().push(0);
14502 self
14503 }
14504}
14505impl<Prev: Rec> Drop for PushDlInfoVersion<Prev> {
14506 fn drop(&mut self) {
14507 if let Some(prev) = &mut self.prev {
14508 if let Some(header_offset) = &self.header_offset {
14509 finalize_nested_header(prev.as_rec_mut(), *header_offset);
14510 }
14511 }
14512 }
14513}
14514pub struct PushDlPortFunction<Prev: Rec> {
14515 pub(crate) prev: Option<Prev>,
14516 pub(crate) header_offset: Option<usize>,
14517}
14518impl<Prev: Rec> Rec for PushDlPortFunction<Prev> {
14519 fn as_rec_mut(&mut self) -> &mut Vec<u8> {
14520 self.prev.as_mut().unwrap().as_rec_mut()
14521 }
14522 fn as_rec(&self) -> &Vec<u8> {
14523 self.prev.as_ref().unwrap().as_rec()
14524 }
14525}
14526impl<Prev: Rec> PushDlPortFunction<Prev> {
14527 pub fn new(prev: Prev) -> Self {
14528 Self {
14529 prev: Some(prev),
14530 header_offset: None,
14531 }
14532 }
14533 pub fn end_nested(mut self) -> Prev {
14534 let mut prev = self.prev.take().unwrap();
14535 if let Some(header_offset) = &self.header_offset {
14536 finalize_nested_header(prev.as_rec_mut(), *header_offset);
14537 }
14538 prev
14539 }
14540 pub fn push_hw_addr(mut self, value: &[u8]) -> Self {
14541 push_header(self.as_rec_mut(), 1u16, value.len() as u16);
14542 self.as_rec_mut().extend(value);
14543 self
14544 }
14545 #[doc = "Associated type: [`PortFnState`] (enum)"]
14546 pub fn push_state(mut self, value: u8) -> Self {
14547 push_header(self.as_rec_mut(), 2u16, 1 as u16);
14548 self.as_rec_mut().extend(value.to_ne_bytes());
14549 self
14550 }
14551 #[doc = "Associated type: [`PortFnOpstate`] (enum)"]
14552 pub fn push_opstate(mut self, value: u8) -> Self {
14553 push_header(self.as_rec_mut(), 3u16, 1 as u16);
14554 self.as_rec_mut().extend(value.to_ne_bytes());
14555 self
14556 }
14557 #[doc = "Associated type: [`PortFnAttrCap`] (1 bit per enumeration)"]
14558 pub fn push_caps(mut self, value: BuiltinBitfield32) -> Self {
14559 push_header(self.as_rec_mut(), 4u16, value.as_slice().len() as u16);
14560 self.as_rec_mut().extend(value.as_slice());
14561 self
14562 }
14563}
14564impl<Prev: Rec> Drop for PushDlPortFunction<Prev> {
14565 fn drop(&mut self) {
14566 if let Some(prev) = &mut self.prev {
14567 if let Some(header_offset) = &self.header_offset {
14568 finalize_nested_header(prev.as_rec_mut(), *header_offset);
14569 }
14570 }
14571 }
14572}
14573pub struct PushDlDpipeTables<Prev: Rec> {
14574 pub(crate) prev: Option<Prev>,
14575 pub(crate) header_offset: Option<usize>,
14576}
14577impl<Prev: Rec> Rec for PushDlDpipeTables<Prev> {
14578 fn as_rec_mut(&mut self) -> &mut Vec<u8> {
14579 self.prev.as_mut().unwrap().as_rec_mut()
14580 }
14581 fn as_rec(&self) -> &Vec<u8> {
14582 self.prev.as_ref().unwrap().as_rec()
14583 }
14584}
14585impl<Prev: Rec> PushDlDpipeTables<Prev> {
14586 pub fn new(prev: Prev) -> Self {
14587 Self {
14588 prev: Some(prev),
14589 header_offset: None,
14590 }
14591 }
14592 pub fn end_nested(mut self) -> Prev {
14593 let mut prev = self.prev.take().unwrap();
14594 if let Some(header_offset) = &self.header_offset {
14595 finalize_nested_header(prev.as_rec_mut(), *header_offset);
14596 }
14597 prev
14598 }
14599 #[doc = "Attribute may repeat multiple times (treat it as array)"]
14600 pub fn nested_dpipe_table(mut self) -> PushDlDpipeTable<Self> {
14601 let header_offset = push_nested_header(self.as_rec_mut(), 28u16);
14602 PushDlDpipeTable {
14603 prev: Some(self),
14604 header_offset: Some(header_offset),
14605 }
14606 }
14607}
14608impl<Prev: Rec> Drop for PushDlDpipeTables<Prev> {
14609 fn drop(&mut self) {
14610 if let Some(prev) = &mut self.prev {
14611 if let Some(header_offset) = &self.header_offset {
14612 finalize_nested_header(prev.as_rec_mut(), *header_offset);
14613 }
14614 }
14615 }
14616}
14617pub struct PushDlDpipeTable<Prev: Rec> {
14618 pub(crate) prev: Option<Prev>,
14619 pub(crate) header_offset: Option<usize>,
14620}
14621impl<Prev: Rec> Rec for PushDlDpipeTable<Prev> {
14622 fn as_rec_mut(&mut self) -> &mut Vec<u8> {
14623 self.prev.as_mut().unwrap().as_rec_mut()
14624 }
14625 fn as_rec(&self) -> &Vec<u8> {
14626 self.prev.as_ref().unwrap().as_rec()
14627 }
14628}
14629impl<Prev: Rec> PushDlDpipeTable<Prev> {
14630 pub fn new(prev: Prev) -> Self {
14631 Self {
14632 prev: Some(prev),
14633 header_offset: None,
14634 }
14635 }
14636 pub fn end_nested(mut self) -> Prev {
14637 let mut prev = self.prev.take().unwrap();
14638 if let Some(header_offset) = &self.header_offset {
14639 finalize_nested_header(prev.as_rec_mut(), *header_offset);
14640 }
14641 prev
14642 }
14643 pub fn push_dpipe_table_name(mut self, value: &CStr) -> Self {
14644 push_header(
14645 self.as_rec_mut(),
14646 29u16,
14647 value.to_bytes_with_nul().len() as u16,
14648 );
14649 self.as_rec_mut().extend(value.to_bytes_with_nul());
14650 self
14651 }
14652 pub fn push_dpipe_table_name_bytes(mut self, value: &[u8]) -> Self {
14653 push_header(self.as_rec_mut(), 29u16, (value.len() + 1) as u16);
14654 self.as_rec_mut().extend(value);
14655 self.as_rec_mut().push(0);
14656 self
14657 }
14658 pub fn push_dpipe_table_size(mut self, value: u64) -> Self {
14659 push_header(self.as_rec_mut(), 30u16, 8 as u16);
14660 self.as_rec_mut().extend(value.to_ne_bytes());
14661 self
14662 }
14663 pub fn nested_dpipe_table_matches(mut self) -> PushDlDpipeTableMatches<Self> {
14664 let header_offset = push_nested_header(self.as_rec_mut(), 31u16);
14665 PushDlDpipeTableMatches {
14666 prev: Some(self),
14667 header_offset: Some(header_offset),
14668 }
14669 }
14670 pub fn nested_dpipe_table_actions(mut self) -> PushDlDpipeTableActions<Self> {
14671 let header_offset = push_nested_header(self.as_rec_mut(), 32u16);
14672 PushDlDpipeTableActions {
14673 prev: Some(self),
14674 header_offset: Some(header_offset),
14675 }
14676 }
14677 pub fn push_dpipe_table_counters_enabled(mut self, value: u8) -> Self {
14678 push_header(self.as_rec_mut(), 33u16, 1 as u16);
14679 self.as_rec_mut().extend(value.to_ne_bytes());
14680 self
14681 }
14682 pub fn push_dpipe_table_resource_id(mut self, value: u64) -> Self {
14683 push_header(self.as_rec_mut(), 75u16, 8 as u16);
14684 self.as_rec_mut().extend(value.to_ne_bytes());
14685 self
14686 }
14687 pub fn push_dpipe_table_resource_units(mut self, value: u64) -> Self {
14688 push_header(self.as_rec_mut(), 76u16, 8 as u16);
14689 self.as_rec_mut().extend(value.to_ne_bytes());
14690 self
14691 }
14692}
14693impl<Prev: Rec> Drop for PushDlDpipeTable<Prev> {
14694 fn drop(&mut self) {
14695 if let Some(prev) = &mut self.prev {
14696 if let Some(header_offset) = &self.header_offset {
14697 finalize_nested_header(prev.as_rec_mut(), *header_offset);
14698 }
14699 }
14700 }
14701}
14702pub struct PushDlDpipeTableMatches<Prev: Rec> {
14703 pub(crate) prev: Option<Prev>,
14704 pub(crate) header_offset: Option<usize>,
14705}
14706impl<Prev: Rec> Rec for PushDlDpipeTableMatches<Prev> {
14707 fn as_rec_mut(&mut self) -> &mut Vec<u8> {
14708 self.prev.as_mut().unwrap().as_rec_mut()
14709 }
14710 fn as_rec(&self) -> &Vec<u8> {
14711 self.prev.as_ref().unwrap().as_rec()
14712 }
14713}
14714impl<Prev: Rec> PushDlDpipeTableMatches<Prev> {
14715 pub fn new(prev: Prev) -> Self {
14716 Self {
14717 prev: Some(prev),
14718 header_offset: None,
14719 }
14720 }
14721 pub fn end_nested(mut self) -> Prev {
14722 let mut prev = self.prev.take().unwrap();
14723 if let Some(header_offset) = &self.header_offset {
14724 finalize_nested_header(prev.as_rec_mut(), *header_offset);
14725 }
14726 prev
14727 }
14728 #[doc = "Attribute may repeat multiple times (treat it as array)"]
14729 pub fn nested_dpipe_match(mut self) -> PushDlDpipeMatch<Self> {
14730 let header_offset = push_nested_header(self.as_rec_mut(), 40u16);
14731 PushDlDpipeMatch {
14732 prev: Some(self),
14733 header_offset: Some(header_offset),
14734 }
14735 }
14736}
14737impl<Prev: Rec> Drop for PushDlDpipeTableMatches<Prev> {
14738 fn drop(&mut self) {
14739 if let Some(prev) = &mut self.prev {
14740 if let Some(header_offset) = &self.header_offset {
14741 finalize_nested_header(prev.as_rec_mut(), *header_offset);
14742 }
14743 }
14744 }
14745}
14746pub struct PushDlDpipeTableActions<Prev: Rec> {
14747 pub(crate) prev: Option<Prev>,
14748 pub(crate) header_offset: Option<usize>,
14749}
14750impl<Prev: Rec> Rec for PushDlDpipeTableActions<Prev> {
14751 fn as_rec_mut(&mut self) -> &mut Vec<u8> {
14752 self.prev.as_mut().unwrap().as_rec_mut()
14753 }
14754 fn as_rec(&self) -> &Vec<u8> {
14755 self.prev.as_ref().unwrap().as_rec()
14756 }
14757}
14758impl<Prev: Rec> PushDlDpipeTableActions<Prev> {
14759 pub fn new(prev: Prev) -> Self {
14760 Self {
14761 prev: Some(prev),
14762 header_offset: None,
14763 }
14764 }
14765 pub fn end_nested(mut self) -> Prev {
14766 let mut prev = self.prev.take().unwrap();
14767 if let Some(header_offset) = &self.header_offset {
14768 finalize_nested_header(prev.as_rec_mut(), *header_offset);
14769 }
14770 prev
14771 }
14772 #[doc = "Attribute may repeat multiple times (treat it as array)"]
14773 pub fn nested_dpipe_action(mut self) -> PushDlDpipeAction<Self> {
14774 let header_offset = push_nested_header(self.as_rec_mut(), 43u16);
14775 PushDlDpipeAction {
14776 prev: Some(self),
14777 header_offset: Some(header_offset),
14778 }
14779 }
14780}
14781impl<Prev: Rec> Drop for PushDlDpipeTableActions<Prev> {
14782 fn drop(&mut self) {
14783 if let Some(prev) = &mut self.prev {
14784 if let Some(header_offset) = &self.header_offset {
14785 finalize_nested_header(prev.as_rec_mut(), *header_offset);
14786 }
14787 }
14788 }
14789}
14790pub struct PushDlDpipeEntries<Prev: Rec> {
14791 pub(crate) prev: Option<Prev>,
14792 pub(crate) header_offset: Option<usize>,
14793}
14794impl<Prev: Rec> Rec for PushDlDpipeEntries<Prev> {
14795 fn as_rec_mut(&mut self) -> &mut Vec<u8> {
14796 self.prev.as_mut().unwrap().as_rec_mut()
14797 }
14798 fn as_rec(&self) -> &Vec<u8> {
14799 self.prev.as_ref().unwrap().as_rec()
14800 }
14801}
14802impl<Prev: Rec> PushDlDpipeEntries<Prev> {
14803 pub fn new(prev: Prev) -> Self {
14804 Self {
14805 prev: Some(prev),
14806 header_offset: None,
14807 }
14808 }
14809 pub fn end_nested(mut self) -> Prev {
14810 let mut prev = self.prev.take().unwrap();
14811 if let Some(header_offset) = &self.header_offset {
14812 finalize_nested_header(prev.as_rec_mut(), *header_offset);
14813 }
14814 prev
14815 }
14816 #[doc = "Attribute may repeat multiple times (treat it as array)"]
14817 pub fn nested_dpipe_entry(mut self) -> PushDlDpipeEntry<Self> {
14818 let header_offset = push_nested_header(self.as_rec_mut(), 35u16);
14819 PushDlDpipeEntry {
14820 prev: Some(self),
14821 header_offset: Some(header_offset),
14822 }
14823 }
14824}
14825impl<Prev: Rec> Drop for PushDlDpipeEntries<Prev> {
14826 fn drop(&mut self) {
14827 if let Some(prev) = &mut self.prev {
14828 if let Some(header_offset) = &self.header_offset {
14829 finalize_nested_header(prev.as_rec_mut(), *header_offset);
14830 }
14831 }
14832 }
14833}
14834pub struct PushDlDpipeEntry<Prev: Rec> {
14835 pub(crate) prev: Option<Prev>,
14836 pub(crate) header_offset: Option<usize>,
14837}
14838impl<Prev: Rec> Rec for PushDlDpipeEntry<Prev> {
14839 fn as_rec_mut(&mut self) -> &mut Vec<u8> {
14840 self.prev.as_mut().unwrap().as_rec_mut()
14841 }
14842 fn as_rec(&self) -> &Vec<u8> {
14843 self.prev.as_ref().unwrap().as_rec()
14844 }
14845}
14846impl<Prev: Rec> PushDlDpipeEntry<Prev> {
14847 pub fn new(prev: Prev) -> Self {
14848 Self {
14849 prev: Some(prev),
14850 header_offset: None,
14851 }
14852 }
14853 pub fn end_nested(mut self) -> Prev {
14854 let mut prev = self.prev.take().unwrap();
14855 if let Some(header_offset) = &self.header_offset {
14856 finalize_nested_header(prev.as_rec_mut(), *header_offset);
14857 }
14858 prev
14859 }
14860 pub fn push_dpipe_entry_index(mut self, value: u64) -> Self {
14861 push_header(self.as_rec_mut(), 36u16, 8 as u16);
14862 self.as_rec_mut().extend(value.to_ne_bytes());
14863 self
14864 }
14865 pub fn nested_dpipe_entry_match_values(mut self) -> PushDlDpipeEntryMatchValues<Self> {
14866 let header_offset = push_nested_header(self.as_rec_mut(), 37u16);
14867 PushDlDpipeEntryMatchValues {
14868 prev: Some(self),
14869 header_offset: Some(header_offset),
14870 }
14871 }
14872 pub fn nested_dpipe_entry_action_values(mut self) -> PushDlDpipeEntryActionValues<Self> {
14873 let header_offset = push_nested_header(self.as_rec_mut(), 38u16);
14874 PushDlDpipeEntryActionValues {
14875 prev: Some(self),
14876 header_offset: Some(header_offset),
14877 }
14878 }
14879 pub fn push_dpipe_entry_counter(mut self, value: u64) -> Self {
14880 push_header(self.as_rec_mut(), 39u16, 8 as u16);
14881 self.as_rec_mut().extend(value.to_ne_bytes());
14882 self
14883 }
14884}
14885impl<Prev: Rec> Drop for PushDlDpipeEntry<Prev> {
14886 fn drop(&mut self) {
14887 if let Some(prev) = &mut self.prev {
14888 if let Some(header_offset) = &self.header_offset {
14889 finalize_nested_header(prev.as_rec_mut(), *header_offset);
14890 }
14891 }
14892 }
14893}
14894pub struct PushDlDpipeEntryMatchValues<Prev: Rec> {
14895 pub(crate) prev: Option<Prev>,
14896 pub(crate) header_offset: Option<usize>,
14897}
14898impl<Prev: Rec> Rec for PushDlDpipeEntryMatchValues<Prev> {
14899 fn as_rec_mut(&mut self) -> &mut Vec<u8> {
14900 self.prev.as_mut().unwrap().as_rec_mut()
14901 }
14902 fn as_rec(&self) -> &Vec<u8> {
14903 self.prev.as_ref().unwrap().as_rec()
14904 }
14905}
14906impl<Prev: Rec> PushDlDpipeEntryMatchValues<Prev> {
14907 pub fn new(prev: Prev) -> Self {
14908 Self {
14909 prev: Some(prev),
14910 header_offset: None,
14911 }
14912 }
14913 pub fn end_nested(mut self) -> Prev {
14914 let mut prev = self.prev.take().unwrap();
14915 if let Some(header_offset) = &self.header_offset {
14916 finalize_nested_header(prev.as_rec_mut(), *header_offset);
14917 }
14918 prev
14919 }
14920 #[doc = "Attribute may repeat multiple times (treat it as array)"]
14921 pub fn nested_dpipe_match_value(mut self) -> PushDlDpipeMatchValue<Self> {
14922 let header_offset = push_nested_header(self.as_rec_mut(), 41u16);
14923 PushDlDpipeMatchValue {
14924 prev: Some(self),
14925 header_offset: Some(header_offset),
14926 }
14927 }
14928}
14929impl<Prev: Rec> Drop for PushDlDpipeEntryMatchValues<Prev> {
14930 fn drop(&mut self) {
14931 if let Some(prev) = &mut self.prev {
14932 if let Some(header_offset) = &self.header_offset {
14933 finalize_nested_header(prev.as_rec_mut(), *header_offset);
14934 }
14935 }
14936 }
14937}
14938pub struct PushDlDpipeEntryActionValues<Prev: Rec> {
14939 pub(crate) prev: Option<Prev>,
14940 pub(crate) header_offset: Option<usize>,
14941}
14942impl<Prev: Rec> Rec for PushDlDpipeEntryActionValues<Prev> {
14943 fn as_rec_mut(&mut self) -> &mut Vec<u8> {
14944 self.prev.as_mut().unwrap().as_rec_mut()
14945 }
14946 fn as_rec(&self) -> &Vec<u8> {
14947 self.prev.as_ref().unwrap().as_rec()
14948 }
14949}
14950impl<Prev: Rec> PushDlDpipeEntryActionValues<Prev> {
14951 pub fn new(prev: Prev) -> Self {
14952 Self {
14953 prev: Some(prev),
14954 header_offset: None,
14955 }
14956 }
14957 pub fn end_nested(mut self) -> Prev {
14958 let mut prev = self.prev.take().unwrap();
14959 if let Some(header_offset) = &self.header_offset {
14960 finalize_nested_header(prev.as_rec_mut(), *header_offset);
14961 }
14962 prev
14963 }
14964 #[doc = "Attribute may repeat multiple times (treat it as array)"]
14965 pub fn nested_dpipe_action_value(mut self) -> PushDlDpipeActionValue<Self> {
14966 let header_offset = push_nested_header(self.as_rec_mut(), 44u16);
14967 PushDlDpipeActionValue {
14968 prev: Some(self),
14969 header_offset: Some(header_offset),
14970 }
14971 }
14972}
14973impl<Prev: Rec> Drop for PushDlDpipeEntryActionValues<Prev> {
14974 fn drop(&mut self) {
14975 if let Some(prev) = &mut self.prev {
14976 if let Some(header_offset) = &self.header_offset {
14977 finalize_nested_header(prev.as_rec_mut(), *header_offset);
14978 }
14979 }
14980 }
14981}
14982pub struct PushDlDpipeMatch<Prev: Rec> {
14983 pub(crate) prev: Option<Prev>,
14984 pub(crate) header_offset: Option<usize>,
14985}
14986impl<Prev: Rec> Rec for PushDlDpipeMatch<Prev> {
14987 fn as_rec_mut(&mut self) -> &mut Vec<u8> {
14988 self.prev.as_mut().unwrap().as_rec_mut()
14989 }
14990 fn as_rec(&self) -> &Vec<u8> {
14991 self.prev.as_ref().unwrap().as_rec()
14992 }
14993}
14994impl<Prev: Rec> PushDlDpipeMatch<Prev> {
14995 pub fn new(prev: Prev) -> Self {
14996 Self {
14997 prev: Some(prev),
14998 header_offset: None,
14999 }
15000 }
15001 pub fn end_nested(mut self) -> Prev {
15002 let mut prev = self.prev.take().unwrap();
15003 if let Some(header_offset) = &self.header_offset {
15004 finalize_nested_header(prev.as_rec_mut(), *header_offset);
15005 }
15006 prev
15007 }
15008 #[doc = "Associated type: [`DpipeMatchType`] (enum)"]
15009 pub fn push_dpipe_match_type(mut self, value: u32) -> Self {
15010 push_header(self.as_rec_mut(), 42u16, 4 as u16);
15011 self.as_rec_mut().extend(value.to_ne_bytes());
15012 self
15013 }
15014 #[doc = "Associated type: [`DpipeHeaderId`] (enum)"]
15015 pub fn push_dpipe_header_id(mut self, value: u32) -> Self {
15016 push_header(self.as_rec_mut(), 52u16, 4 as u16);
15017 self.as_rec_mut().extend(value.to_ne_bytes());
15018 self
15019 }
15020 pub fn push_dpipe_header_global(mut self, value: u8) -> Self {
15021 push_header(self.as_rec_mut(), 54u16, 1 as u16);
15022 self.as_rec_mut().extend(value.to_ne_bytes());
15023 self
15024 }
15025 pub fn push_dpipe_header_index(mut self, value: u32) -> Self {
15026 push_header(self.as_rec_mut(), 55u16, 4 as u16);
15027 self.as_rec_mut().extend(value.to_ne_bytes());
15028 self
15029 }
15030 pub fn push_dpipe_field_id(mut self, value: u32) -> Self {
15031 push_header(self.as_rec_mut(), 58u16, 4 as u16);
15032 self.as_rec_mut().extend(value.to_ne_bytes());
15033 self
15034 }
15035}
15036impl<Prev: Rec> Drop for PushDlDpipeMatch<Prev> {
15037 fn drop(&mut self) {
15038 if let Some(prev) = &mut self.prev {
15039 if let Some(header_offset) = &self.header_offset {
15040 finalize_nested_header(prev.as_rec_mut(), *header_offset);
15041 }
15042 }
15043 }
15044}
15045pub struct PushDlDpipeMatchValue<Prev: Rec> {
15046 pub(crate) prev: Option<Prev>,
15047 pub(crate) header_offset: Option<usize>,
15048}
15049impl<Prev: Rec> Rec for PushDlDpipeMatchValue<Prev> {
15050 fn as_rec_mut(&mut self) -> &mut Vec<u8> {
15051 self.prev.as_mut().unwrap().as_rec_mut()
15052 }
15053 fn as_rec(&self) -> &Vec<u8> {
15054 self.prev.as_ref().unwrap().as_rec()
15055 }
15056}
15057impl<Prev: Rec> PushDlDpipeMatchValue<Prev> {
15058 pub fn new(prev: Prev) -> Self {
15059 Self {
15060 prev: Some(prev),
15061 header_offset: None,
15062 }
15063 }
15064 pub fn end_nested(mut self) -> Prev {
15065 let mut prev = self.prev.take().unwrap();
15066 if let Some(header_offset) = &self.header_offset {
15067 finalize_nested_header(prev.as_rec_mut(), *header_offset);
15068 }
15069 prev
15070 }
15071 #[doc = "Attribute may repeat multiple times (treat it as array)"]
15072 pub fn nested_dpipe_match(mut self) -> PushDlDpipeMatch<Self> {
15073 let header_offset = push_nested_header(self.as_rec_mut(), 40u16);
15074 PushDlDpipeMatch {
15075 prev: Some(self),
15076 header_offset: Some(header_offset),
15077 }
15078 }
15079 pub fn push_dpipe_value(mut self, value: &[u8]) -> Self {
15080 push_header(self.as_rec_mut(), 46u16, value.len() as u16);
15081 self.as_rec_mut().extend(value);
15082 self
15083 }
15084 pub fn push_dpipe_value_mask(mut self, value: &[u8]) -> Self {
15085 push_header(self.as_rec_mut(), 47u16, value.len() as u16);
15086 self.as_rec_mut().extend(value);
15087 self
15088 }
15089 pub fn push_dpipe_value_mapping(mut self, value: u32) -> Self {
15090 push_header(self.as_rec_mut(), 48u16, 4 as u16);
15091 self.as_rec_mut().extend(value.to_ne_bytes());
15092 self
15093 }
15094}
15095impl<Prev: Rec> Drop for PushDlDpipeMatchValue<Prev> {
15096 fn drop(&mut self) {
15097 if let Some(prev) = &mut self.prev {
15098 if let Some(header_offset) = &self.header_offset {
15099 finalize_nested_header(prev.as_rec_mut(), *header_offset);
15100 }
15101 }
15102 }
15103}
15104pub struct PushDlDpipeAction<Prev: Rec> {
15105 pub(crate) prev: Option<Prev>,
15106 pub(crate) header_offset: Option<usize>,
15107}
15108impl<Prev: Rec> Rec for PushDlDpipeAction<Prev> {
15109 fn as_rec_mut(&mut self) -> &mut Vec<u8> {
15110 self.prev.as_mut().unwrap().as_rec_mut()
15111 }
15112 fn as_rec(&self) -> &Vec<u8> {
15113 self.prev.as_ref().unwrap().as_rec()
15114 }
15115}
15116impl<Prev: Rec> PushDlDpipeAction<Prev> {
15117 pub fn new(prev: Prev) -> Self {
15118 Self {
15119 prev: Some(prev),
15120 header_offset: None,
15121 }
15122 }
15123 pub fn end_nested(mut self) -> Prev {
15124 let mut prev = self.prev.take().unwrap();
15125 if let Some(header_offset) = &self.header_offset {
15126 finalize_nested_header(prev.as_rec_mut(), *header_offset);
15127 }
15128 prev
15129 }
15130 #[doc = "Associated type: [`DpipeActionType`] (enum)"]
15131 pub fn push_dpipe_action_type(mut self, value: u32) -> Self {
15132 push_header(self.as_rec_mut(), 45u16, 4 as u16);
15133 self.as_rec_mut().extend(value.to_ne_bytes());
15134 self
15135 }
15136 #[doc = "Associated type: [`DpipeHeaderId`] (enum)"]
15137 pub fn push_dpipe_header_id(mut self, value: u32) -> Self {
15138 push_header(self.as_rec_mut(), 52u16, 4 as u16);
15139 self.as_rec_mut().extend(value.to_ne_bytes());
15140 self
15141 }
15142 pub fn push_dpipe_header_global(mut self, value: u8) -> Self {
15143 push_header(self.as_rec_mut(), 54u16, 1 as u16);
15144 self.as_rec_mut().extend(value.to_ne_bytes());
15145 self
15146 }
15147 pub fn push_dpipe_header_index(mut self, value: u32) -> Self {
15148 push_header(self.as_rec_mut(), 55u16, 4 as u16);
15149 self.as_rec_mut().extend(value.to_ne_bytes());
15150 self
15151 }
15152 pub fn push_dpipe_field_id(mut self, value: u32) -> Self {
15153 push_header(self.as_rec_mut(), 58u16, 4 as u16);
15154 self.as_rec_mut().extend(value.to_ne_bytes());
15155 self
15156 }
15157}
15158impl<Prev: Rec> Drop for PushDlDpipeAction<Prev> {
15159 fn drop(&mut self) {
15160 if let Some(prev) = &mut self.prev {
15161 if let Some(header_offset) = &self.header_offset {
15162 finalize_nested_header(prev.as_rec_mut(), *header_offset);
15163 }
15164 }
15165 }
15166}
15167pub struct PushDlDpipeActionValue<Prev: Rec> {
15168 pub(crate) prev: Option<Prev>,
15169 pub(crate) header_offset: Option<usize>,
15170}
15171impl<Prev: Rec> Rec for PushDlDpipeActionValue<Prev> {
15172 fn as_rec_mut(&mut self) -> &mut Vec<u8> {
15173 self.prev.as_mut().unwrap().as_rec_mut()
15174 }
15175 fn as_rec(&self) -> &Vec<u8> {
15176 self.prev.as_ref().unwrap().as_rec()
15177 }
15178}
15179impl<Prev: Rec> PushDlDpipeActionValue<Prev> {
15180 pub fn new(prev: Prev) -> Self {
15181 Self {
15182 prev: Some(prev),
15183 header_offset: None,
15184 }
15185 }
15186 pub fn end_nested(mut self) -> Prev {
15187 let mut prev = self.prev.take().unwrap();
15188 if let Some(header_offset) = &self.header_offset {
15189 finalize_nested_header(prev.as_rec_mut(), *header_offset);
15190 }
15191 prev
15192 }
15193 #[doc = "Attribute may repeat multiple times (treat it as array)"]
15194 pub fn nested_dpipe_action(mut self) -> PushDlDpipeAction<Self> {
15195 let header_offset = push_nested_header(self.as_rec_mut(), 43u16);
15196 PushDlDpipeAction {
15197 prev: Some(self),
15198 header_offset: Some(header_offset),
15199 }
15200 }
15201 pub fn push_dpipe_value(mut self, value: &[u8]) -> Self {
15202 push_header(self.as_rec_mut(), 46u16, value.len() as u16);
15203 self.as_rec_mut().extend(value);
15204 self
15205 }
15206 pub fn push_dpipe_value_mask(mut self, value: &[u8]) -> Self {
15207 push_header(self.as_rec_mut(), 47u16, value.len() as u16);
15208 self.as_rec_mut().extend(value);
15209 self
15210 }
15211 pub fn push_dpipe_value_mapping(mut self, value: u32) -> Self {
15212 push_header(self.as_rec_mut(), 48u16, 4 as u16);
15213 self.as_rec_mut().extend(value.to_ne_bytes());
15214 self
15215 }
15216}
15217impl<Prev: Rec> Drop for PushDlDpipeActionValue<Prev> {
15218 fn drop(&mut self) {
15219 if let Some(prev) = &mut self.prev {
15220 if let Some(header_offset) = &self.header_offset {
15221 finalize_nested_header(prev.as_rec_mut(), *header_offset);
15222 }
15223 }
15224 }
15225}
15226pub struct PushDlDpipeHeaders<Prev: Rec> {
15227 pub(crate) prev: Option<Prev>,
15228 pub(crate) header_offset: Option<usize>,
15229}
15230impl<Prev: Rec> Rec for PushDlDpipeHeaders<Prev> {
15231 fn as_rec_mut(&mut self) -> &mut Vec<u8> {
15232 self.prev.as_mut().unwrap().as_rec_mut()
15233 }
15234 fn as_rec(&self) -> &Vec<u8> {
15235 self.prev.as_ref().unwrap().as_rec()
15236 }
15237}
15238impl<Prev: Rec> PushDlDpipeHeaders<Prev> {
15239 pub fn new(prev: Prev) -> Self {
15240 Self {
15241 prev: Some(prev),
15242 header_offset: None,
15243 }
15244 }
15245 pub fn end_nested(mut self) -> Prev {
15246 let mut prev = self.prev.take().unwrap();
15247 if let Some(header_offset) = &self.header_offset {
15248 finalize_nested_header(prev.as_rec_mut(), *header_offset);
15249 }
15250 prev
15251 }
15252 #[doc = "Attribute may repeat multiple times (treat it as array)"]
15253 pub fn nested_dpipe_header(mut self) -> PushDlDpipeHeader<Self> {
15254 let header_offset = push_nested_header(self.as_rec_mut(), 50u16);
15255 PushDlDpipeHeader {
15256 prev: Some(self),
15257 header_offset: Some(header_offset),
15258 }
15259 }
15260}
15261impl<Prev: Rec> Drop for PushDlDpipeHeaders<Prev> {
15262 fn drop(&mut self) {
15263 if let Some(prev) = &mut self.prev {
15264 if let Some(header_offset) = &self.header_offset {
15265 finalize_nested_header(prev.as_rec_mut(), *header_offset);
15266 }
15267 }
15268 }
15269}
15270pub struct PushDlDpipeHeader<Prev: Rec> {
15271 pub(crate) prev: Option<Prev>,
15272 pub(crate) header_offset: Option<usize>,
15273}
15274impl<Prev: Rec> Rec for PushDlDpipeHeader<Prev> {
15275 fn as_rec_mut(&mut self) -> &mut Vec<u8> {
15276 self.prev.as_mut().unwrap().as_rec_mut()
15277 }
15278 fn as_rec(&self) -> &Vec<u8> {
15279 self.prev.as_ref().unwrap().as_rec()
15280 }
15281}
15282impl<Prev: Rec> PushDlDpipeHeader<Prev> {
15283 pub fn new(prev: Prev) -> Self {
15284 Self {
15285 prev: Some(prev),
15286 header_offset: None,
15287 }
15288 }
15289 pub fn end_nested(mut self) -> Prev {
15290 let mut prev = self.prev.take().unwrap();
15291 if let Some(header_offset) = &self.header_offset {
15292 finalize_nested_header(prev.as_rec_mut(), *header_offset);
15293 }
15294 prev
15295 }
15296 pub fn push_dpipe_header_name(mut self, value: &CStr) -> Self {
15297 push_header(
15298 self.as_rec_mut(),
15299 51u16,
15300 value.to_bytes_with_nul().len() as u16,
15301 );
15302 self.as_rec_mut().extend(value.to_bytes_with_nul());
15303 self
15304 }
15305 pub fn push_dpipe_header_name_bytes(mut self, value: &[u8]) -> Self {
15306 push_header(self.as_rec_mut(), 51u16, (value.len() + 1) as u16);
15307 self.as_rec_mut().extend(value);
15308 self.as_rec_mut().push(0);
15309 self
15310 }
15311 #[doc = "Associated type: [`DpipeHeaderId`] (enum)"]
15312 pub fn push_dpipe_header_id(mut self, value: u32) -> Self {
15313 push_header(self.as_rec_mut(), 52u16, 4 as u16);
15314 self.as_rec_mut().extend(value.to_ne_bytes());
15315 self
15316 }
15317 pub fn nested_dpipe_header_fields(mut self) -> PushDlDpipeHeaderFields<Self> {
15318 let header_offset = push_nested_header(self.as_rec_mut(), 53u16);
15319 PushDlDpipeHeaderFields {
15320 prev: Some(self),
15321 header_offset: Some(header_offset),
15322 }
15323 }
15324 pub fn push_dpipe_header_global(mut self, value: u8) -> Self {
15325 push_header(self.as_rec_mut(), 54u16, 1 as u16);
15326 self.as_rec_mut().extend(value.to_ne_bytes());
15327 self
15328 }
15329}
15330impl<Prev: Rec> Drop for PushDlDpipeHeader<Prev> {
15331 fn drop(&mut self) {
15332 if let Some(prev) = &mut self.prev {
15333 if let Some(header_offset) = &self.header_offset {
15334 finalize_nested_header(prev.as_rec_mut(), *header_offset);
15335 }
15336 }
15337 }
15338}
15339pub struct PushDlDpipeHeaderFields<Prev: Rec> {
15340 pub(crate) prev: Option<Prev>,
15341 pub(crate) header_offset: Option<usize>,
15342}
15343impl<Prev: Rec> Rec for PushDlDpipeHeaderFields<Prev> {
15344 fn as_rec_mut(&mut self) -> &mut Vec<u8> {
15345 self.prev.as_mut().unwrap().as_rec_mut()
15346 }
15347 fn as_rec(&self) -> &Vec<u8> {
15348 self.prev.as_ref().unwrap().as_rec()
15349 }
15350}
15351impl<Prev: Rec> PushDlDpipeHeaderFields<Prev> {
15352 pub fn new(prev: Prev) -> Self {
15353 Self {
15354 prev: Some(prev),
15355 header_offset: None,
15356 }
15357 }
15358 pub fn end_nested(mut self) -> Prev {
15359 let mut prev = self.prev.take().unwrap();
15360 if let Some(header_offset) = &self.header_offset {
15361 finalize_nested_header(prev.as_rec_mut(), *header_offset);
15362 }
15363 prev
15364 }
15365 #[doc = "Attribute may repeat multiple times (treat it as array)"]
15366 pub fn nested_dpipe_field(mut self) -> PushDlDpipeField<Self> {
15367 let header_offset = push_nested_header(self.as_rec_mut(), 56u16);
15368 PushDlDpipeField {
15369 prev: Some(self),
15370 header_offset: Some(header_offset),
15371 }
15372 }
15373}
15374impl<Prev: Rec> Drop for PushDlDpipeHeaderFields<Prev> {
15375 fn drop(&mut self) {
15376 if let Some(prev) = &mut self.prev {
15377 if let Some(header_offset) = &self.header_offset {
15378 finalize_nested_header(prev.as_rec_mut(), *header_offset);
15379 }
15380 }
15381 }
15382}
15383pub struct PushDlDpipeField<Prev: Rec> {
15384 pub(crate) prev: Option<Prev>,
15385 pub(crate) header_offset: Option<usize>,
15386}
15387impl<Prev: Rec> Rec for PushDlDpipeField<Prev> {
15388 fn as_rec_mut(&mut self) -> &mut Vec<u8> {
15389 self.prev.as_mut().unwrap().as_rec_mut()
15390 }
15391 fn as_rec(&self) -> &Vec<u8> {
15392 self.prev.as_ref().unwrap().as_rec()
15393 }
15394}
15395impl<Prev: Rec> PushDlDpipeField<Prev> {
15396 pub fn new(prev: Prev) -> Self {
15397 Self {
15398 prev: Some(prev),
15399 header_offset: None,
15400 }
15401 }
15402 pub fn end_nested(mut self) -> Prev {
15403 let mut prev = self.prev.take().unwrap();
15404 if let Some(header_offset) = &self.header_offset {
15405 finalize_nested_header(prev.as_rec_mut(), *header_offset);
15406 }
15407 prev
15408 }
15409 pub fn push_dpipe_field_name(mut self, value: &CStr) -> Self {
15410 push_header(
15411 self.as_rec_mut(),
15412 57u16,
15413 value.to_bytes_with_nul().len() as u16,
15414 );
15415 self.as_rec_mut().extend(value.to_bytes_with_nul());
15416 self
15417 }
15418 pub fn push_dpipe_field_name_bytes(mut self, value: &[u8]) -> Self {
15419 push_header(self.as_rec_mut(), 57u16, (value.len() + 1) as u16);
15420 self.as_rec_mut().extend(value);
15421 self.as_rec_mut().push(0);
15422 self
15423 }
15424 pub fn push_dpipe_field_id(mut self, value: u32) -> Self {
15425 push_header(self.as_rec_mut(), 58u16, 4 as u16);
15426 self.as_rec_mut().extend(value.to_ne_bytes());
15427 self
15428 }
15429 pub fn push_dpipe_field_bitwidth(mut self, value: u32) -> Self {
15430 push_header(self.as_rec_mut(), 59u16, 4 as u16);
15431 self.as_rec_mut().extend(value.to_ne_bytes());
15432 self
15433 }
15434 #[doc = "Associated type: [`DpipeFieldMappingType`] (enum)"]
15435 pub fn push_dpipe_field_mapping_type(mut self, value: u32) -> Self {
15436 push_header(self.as_rec_mut(), 60u16, 4 as u16);
15437 self.as_rec_mut().extend(value.to_ne_bytes());
15438 self
15439 }
15440}
15441impl<Prev: Rec> Drop for PushDlDpipeField<Prev> {
15442 fn drop(&mut self) {
15443 if let Some(prev) = &mut self.prev {
15444 if let Some(header_offset) = &self.header_offset {
15445 finalize_nested_header(prev.as_rec_mut(), *header_offset);
15446 }
15447 }
15448 }
15449}
15450pub struct PushDlResource<Prev: Rec> {
15451 pub(crate) prev: Option<Prev>,
15452 pub(crate) header_offset: Option<usize>,
15453}
15454impl<Prev: Rec> Rec for PushDlResource<Prev> {
15455 fn as_rec_mut(&mut self) -> &mut Vec<u8> {
15456 self.prev.as_mut().unwrap().as_rec_mut()
15457 }
15458 fn as_rec(&self) -> &Vec<u8> {
15459 self.prev.as_ref().unwrap().as_rec()
15460 }
15461}
15462impl<Prev: Rec> PushDlResource<Prev> {
15463 pub fn new(prev: Prev) -> Self {
15464 Self {
15465 prev: Some(prev),
15466 header_offset: None,
15467 }
15468 }
15469 pub fn end_nested(mut self) -> Prev {
15470 let mut prev = self.prev.take().unwrap();
15471 if let Some(header_offset) = &self.header_offset {
15472 finalize_nested_header(prev.as_rec_mut(), *header_offset);
15473 }
15474 prev
15475 }
15476 pub fn push_resource_name(mut self, value: &CStr) -> Self {
15477 push_header(
15478 self.as_rec_mut(),
15479 65u16,
15480 value.to_bytes_with_nul().len() as u16,
15481 );
15482 self.as_rec_mut().extend(value.to_bytes_with_nul());
15483 self
15484 }
15485 pub fn push_resource_name_bytes(mut self, value: &[u8]) -> Self {
15486 push_header(self.as_rec_mut(), 65u16, (value.len() + 1) as u16);
15487 self.as_rec_mut().extend(value);
15488 self.as_rec_mut().push(0);
15489 self
15490 }
15491 pub fn push_resource_id(mut self, value: u64) -> Self {
15492 push_header(self.as_rec_mut(), 66u16, 8 as u16);
15493 self.as_rec_mut().extend(value.to_ne_bytes());
15494 self
15495 }
15496 pub fn push_resource_size(mut self, value: u64) -> Self {
15497 push_header(self.as_rec_mut(), 67u16, 8 as u16);
15498 self.as_rec_mut().extend(value.to_ne_bytes());
15499 self
15500 }
15501 pub fn push_resource_size_new(mut self, value: u64) -> Self {
15502 push_header(self.as_rec_mut(), 68u16, 8 as u16);
15503 self.as_rec_mut().extend(value.to_ne_bytes());
15504 self
15505 }
15506 pub fn push_resource_size_valid(mut self, value: u8) -> Self {
15507 push_header(self.as_rec_mut(), 69u16, 1 as u16);
15508 self.as_rec_mut().extend(value.to_ne_bytes());
15509 self
15510 }
15511 pub fn push_resource_size_min(mut self, value: u64) -> Self {
15512 push_header(self.as_rec_mut(), 70u16, 8 as u16);
15513 self.as_rec_mut().extend(value.to_ne_bytes());
15514 self
15515 }
15516 pub fn push_resource_size_max(mut self, value: u64) -> Self {
15517 push_header(self.as_rec_mut(), 71u16, 8 as u16);
15518 self.as_rec_mut().extend(value.to_ne_bytes());
15519 self
15520 }
15521 pub fn push_resource_size_gran(mut self, value: u64) -> Self {
15522 push_header(self.as_rec_mut(), 72u16, 8 as u16);
15523 self.as_rec_mut().extend(value.to_ne_bytes());
15524 self
15525 }
15526 #[doc = "Associated type: [`ResourceUnit`] (enum)"]
15527 pub fn push_resource_unit(mut self, value: u8) -> Self {
15528 push_header(self.as_rec_mut(), 73u16, 1 as u16);
15529 self.as_rec_mut().extend(value.to_ne_bytes());
15530 self
15531 }
15532 pub fn push_resource_occ(mut self, value: u64) -> Self {
15533 push_header(self.as_rec_mut(), 74u16, 8 as u16);
15534 self.as_rec_mut().extend(value.to_ne_bytes());
15535 self
15536 }
15537}
15538impl<Prev: Rec> Drop for PushDlResource<Prev> {
15539 fn drop(&mut self) {
15540 if let Some(prev) = &mut self.prev {
15541 if let Some(header_offset) = &self.header_offset {
15542 finalize_nested_header(prev.as_rec_mut(), *header_offset);
15543 }
15544 }
15545 }
15546}
15547pub struct PushDlResourceList<Prev: Rec> {
15548 pub(crate) prev: Option<Prev>,
15549 pub(crate) header_offset: Option<usize>,
15550}
15551impl<Prev: Rec> Rec for PushDlResourceList<Prev> {
15552 fn as_rec_mut(&mut self) -> &mut Vec<u8> {
15553 self.prev.as_mut().unwrap().as_rec_mut()
15554 }
15555 fn as_rec(&self) -> &Vec<u8> {
15556 self.prev.as_ref().unwrap().as_rec()
15557 }
15558}
15559impl<Prev: Rec> PushDlResourceList<Prev> {
15560 pub fn new(prev: Prev) -> Self {
15561 Self {
15562 prev: Some(prev),
15563 header_offset: None,
15564 }
15565 }
15566 pub fn end_nested(mut self) -> Prev {
15567 let mut prev = self.prev.take().unwrap();
15568 if let Some(header_offset) = &self.header_offset {
15569 finalize_nested_header(prev.as_rec_mut(), *header_offset);
15570 }
15571 prev
15572 }
15573 #[doc = "Attribute may repeat multiple times (treat it as array)"]
15574 pub fn nested_resource(mut self) -> PushDlResource<Self> {
15575 let header_offset = push_nested_header(self.as_rec_mut(), 64u16);
15576 PushDlResource {
15577 prev: Some(self),
15578 header_offset: Some(header_offset),
15579 }
15580 }
15581}
15582impl<Prev: Rec> Drop for PushDlResourceList<Prev> {
15583 fn drop(&mut self) {
15584 if let Some(prev) = &mut self.prev {
15585 if let Some(header_offset) = &self.header_offset {
15586 finalize_nested_header(prev.as_rec_mut(), *header_offset);
15587 }
15588 }
15589 }
15590}
15591pub struct PushDlParam<Prev: Rec> {
15592 pub(crate) prev: Option<Prev>,
15593 pub(crate) header_offset: Option<usize>,
15594}
15595impl<Prev: Rec> Rec for PushDlParam<Prev> {
15596 fn as_rec_mut(&mut self) -> &mut Vec<u8> {
15597 self.prev.as_mut().unwrap().as_rec_mut()
15598 }
15599 fn as_rec(&self) -> &Vec<u8> {
15600 self.prev.as_ref().unwrap().as_rec()
15601 }
15602}
15603impl<Prev: Rec> PushDlParam<Prev> {
15604 pub fn new(prev: Prev) -> Self {
15605 Self {
15606 prev: Some(prev),
15607 header_offset: None,
15608 }
15609 }
15610 pub fn end_nested(mut self) -> Prev {
15611 let mut prev = self.prev.take().unwrap();
15612 if let Some(header_offset) = &self.header_offset {
15613 finalize_nested_header(prev.as_rec_mut(), *header_offset);
15614 }
15615 prev
15616 }
15617 pub fn push_param_name(mut self, value: &CStr) -> Self {
15618 push_header(
15619 self.as_rec_mut(),
15620 81u16,
15621 value.to_bytes_with_nul().len() as u16,
15622 );
15623 self.as_rec_mut().extend(value.to_bytes_with_nul());
15624 self
15625 }
15626 pub fn push_param_name_bytes(mut self, value: &[u8]) -> Self {
15627 push_header(self.as_rec_mut(), 81u16, (value.len() + 1) as u16);
15628 self.as_rec_mut().extend(value);
15629 self.as_rec_mut().push(0);
15630 self
15631 }
15632 pub fn push_param_generic(mut self, value: ()) -> Self {
15633 push_header(self.as_rec_mut(), 82u16, 0 as u16);
15634 self
15635 }
15636 #[doc = "Associated type: [`VarAttrType`] (enum)"]
15637 pub fn push_param_type(mut self, value: u8) -> Self {
15638 push_header(self.as_rec_mut(), 83u16, 1 as u16);
15639 self.as_rec_mut().extend(value.to_ne_bytes());
15640 self
15641 }
15642}
15643impl<Prev: Rec> Drop for PushDlParam<Prev> {
15644 fn drop(&mut self) {
15645 if let Some(prev) = &mut self.prev {
15646 if let Some(header_offset) = &self.header_offset {
15647 finalize_nested_header(prev.as_rec_mut(), *header_offset);
15648 }
15649 }
15650 }
15651}
15652pub struct PushDlRegionSnapshots<Prev: Rec> {
15653 pub(crate) prev: Option<Prev>,
15654 pub(crate) header_offset: Option<usize>,
15655}
15656impl<Prev: Rec> Rec for PushDlRegionSnapshots<Prev> {
15657 fn as_rec_mut(&mut self) -> &mut Vec<u8> {
15658 self.prev.as_mut().unwrap().as_rec_mut()
15659 }
15660 fn as_rec(&self) -> &Vec<u8> {
15661 self.prev.as_ref().unwrap().as_rec()
15662 }
15663}
15664impl<Prev: Rec> PushDlRegionSnapshots<Prev> {
15665 pub fn new(prev: Prev) -> Self {
15666 Self {
15667 prev: Some(prev),
15668 header_offset: None,
15669 }
15670 }
15671 pub fn end_nested(mut self) -> Prev {
15672 let mut prev = self.prev.take().unwrap();
15673 if let Some(header_offset) = &self.header_offset {
15674 finalize_nested_header(prev.as_rec_mut(), *header_offset);
15675 }
15676 prev
15677 }
15678 pub fn nested_region_snapshot(mut self) -> PushDlRegionSnapshot<Self> {
15679 let header_offset = push_nested_header(self.as_rec_mut(), 91u16);
15680 PushDlRegionSnapshot {
15681 prev: Some(self),
15682 header_offset: Some(header_offset),
15683 }
15684 }
15685}
15686impl<Prev: Rec> Drop for PushDlRegionSnapshots<Prev> {
15687 fn drop(&mut self) {
15688 if let Some(prev) = &mut self.prev {
15689 if let Some(header_offset) = &self.header_offset {
15690 finalize_nested_header(prev.as_rec_mut(), *header_offset);
15691 }
15692 }
15693 }
15694}
15695pub struct PushDlRegionSnapshot<Prev: Rec> {
15696 pub(crate) prev: Option<Prev>,
15697 pub(crate) header_offset: Option<usize>,
15698}
15699impl<Prev: Rec> Rec for PushDlRegionSnapshot<Prev> {
15700 fn as_rec_mut(&mut self) -> &mut Vec<u8> {
15701 self.prev.as_mut().unwrap().as_rec_mut()
15702 }
15703 fn as_rec(&self) -> &Vec<u8> {
15704 self.prev.as_ref().unwrap().as_rec()
15705 }
15706}
15707impl<Prev: Rec> PushDlRegionSnapshot<Prev> {
15708 pub fn new(prev: Prev) -> Self {
15709 Self {
15710 prev: Some(prev),
15711 header_offset: None,
15712 }
15713 }
15714 pub fn end_nested(mut self) -> Prev {
15715 let mut prev = self.prev.take().unwrap();
15716 if let Some(header_offset) = &self.header_offset {
15717 finalize_nested_header(prev.as_rec_mut(), *header_offset);
15718 }
15719 prev
15720 }
15721 pub fn push_region_snapshot_id(mut self, value: u32) -> Self {
15722 push_header(self.as_rec_mut(), 92u16, 4 as u16);
15723 self.as_rec_mut().extend(value.to_ne_bytes());
15724 self
15725 }
15726}
15727impl<Prev: Rec> Drop for PushDlRegionSnapshot<Prev> {
15728 fn drop(&mut self) {
15729 if let Some(prev) = &mut self.prev {
15730 if let Some(header_offset) = &self.header_offset {
15731 finalize_nested_header(prev.as_rec_mut(), *header_offset);
15732 }
15733 }
15734 }
15735}
15736pub struct PushDlRegionChunks<Prev: Rec> {
15737 pub(crate) prev: Option<Prev>,
15738 pub(crate) header_offset: Option<usize>,
15739}
15740impl<Prev: Rec> Rec for PushDlRegionChunks<Prev> {
15741 fn as_rec_mut(&mut self) -> &mut Vec<u8> {
15742 self.prev.as_mut().unwrap().as_rec_mut()
15743 }
15744 fn as_rec(&self) -> &Vec<u8> {
15745 self.prev.as_ref().unwrap().as_rec()
15746 }
15747}
15748impl<Prev: Rec> PushDlRegionChunks<Prev> {
15749 pub fn new(prev: Prev) -> Self {
15750 Self {
15751 prev: Some(prev),
15752 header_offset: None,
15753 }
15754 }
15755 pub fn end_nested(mut self) -> Prev {
15756 let mut prev = self.prev.take().unwrap();
15757 if let Some(header_offset) = &self.header_offset {
15758 finalize_nested_header(prev.as_rec_mut(), *header_offset);
15759 }
15760 prev
15761 }
15762 pub fn nested_region_chunk(mut self) -> PushDlRegionChunk<Self> {
15763 let header_offset = push_nested_header(self.as_rec_mut(), 94u16);
15764 PushDlRegionChunk {
15765 prev: Some(self),
15766 header_offset: Some(header_offset),
15767 }
15768 }
15769}
15770impl<Prev: Rec> Drop for PushDlRegionChunks<Prev> {
15771 fn drop(&mut self) {
15772 if let Some(prev) = &mut self.prev {
15773 if let Some(header_offset) = &self.header_offset {
15774 finalize_nested_header(prev.as_rec_mut(), *header_offset);
15775 }
15776 }
15777 }
15778}
15779pub struct PushDlRegionChunk<Prev: Rec> {
15780 pub(crate) prev: Option<Prev>,
15781 pub(crate) header_offset: Option<usize>,
15782}
15783impl<Prev: Rec> Rec for PushDlRegionChunk<Prev> {
15784 fn as_rec_mut(&mut self) -> &mut Vec<u8> {
15785 self.prev.as_mut().unwrap().as_rec_mut()
15786 }
15787 fn as_rec(&self) -> &Vec<u8> {
15788 self.prev.as_ref().unwrap().as_rec()
15789 }
15790}
15791impl<Prev: Rec> PushDlRegionChunk<Prev> {
15792 pub fn new(prev: Prev) -> Self {
15793 Self {
15794 prev: Some(prev),
15795 header_offset: None,
15796 }
15797 }
15798 pub fn end_nested(mut self) -> Prev {
15799 let mut prev = self.prev.take().unwrap();
15800 if let Some(header_offset) = &self.header_offset {
15801 finalize_nested_header(prev.as_rec_mut(), *header_offset);
15802 }
15803 prev
15804 }
15805 pub fn push_region_chunk_data(mut self, value: &[u8]) -> Self {
15806 push_header(self.as_rec_mut(), 95u16, value.len() as u16);
15807 self.as_rec_mut().extend(value);
15808 self
15809 }
15810 pub fn push_region_chunk_addr(mut self, value: u64) -> Self {
15811 push_header(self.as_rec_mut(), 96u16, 8 as u16);
15812 self.as_rec_mut().extend(value.to_ne_bytes());
15813 self
15814 }
15815}
15816impl<Prev: Rec> Drop for PushDlRegionChunk<Prev> {
15817 fn drop(&mut self) {
15818 if let Some(prev) = &mut self.prev {
15819 if let Some(header_offset) = &self.header_offset {
15820 finalize_nested_header(prev.as_rec_mut(), *header_offset);
15821 }
15822 }
15823 }
15824}
15825pub struct PushDlFmsg<Prev: Rec> {
15826 pub(crate) prev: Option<Prev>,
15827 pub(crate) header_offset: Option<usize>,
15828}
15829impl<Prev: Rec> Rec for PushDlFmsg<Prev> {
15830 fn as_rec_mut(&mut self) -> &mut Vec<u8> {
15831 self.prev.as_mut().unwrap().as_rec_mut()
15832 }
15833 fn as_rec(&self) -> &Vec<u8> {
15834 self.prev.as_ref().unwrap().as_rec()
15835 }
15836}
15837impl<Prev: Rec> PushDlFmsg<Prev> {
15838 pub fn new(prev: Prev) -> Self {
15839 Self {
15840 prev: Some(prev),
15841 header_offset: None,
15842 }
15843 }
15844 pub fn end_nested(mut self) -> Prev {
15845 let mut prev = self.prev.take().unwrap();
15846 if let Some(header_offset) = &self.header_offset {
15847 finalize_nested_header(prev.as_rec_mut(), *header_offset);
15848 }
15849 prev
15850 }
15851 pub fn push_fmsg_obj_nest_start(mut self, value: ()) -> Self {
15852 push_header(self.as_rec_mut(), 107u16, 0 as u16);
15853 self
15854 }
15855 pub fn push_fmsg_pair_nest_start(mut self, value: ()) -> Self {
15856 push_header(self.as_rec_mut(), 108u16, 0 as u16);
15857 self
15858 }
15859 pub fn push_fmsg_arr_nest_start(mut self, value: ()) -> Self {
15860 push_header(self.as_rec_mut(), 109u16, 0 as u16);
15861 self
15862 }
15863 pub fn push_fmsg_nest_end(mut self, value: ()) -> Self {
15864 push_header(self.as_rec_mut(), 110u16, 0 as u16);
15865 self
15866 }
15867 pub fn push_fmsg_obj_name(mut self, value: &CStr) -> Self {
15868 push_header(
15869 self.as_rec_mut(),
15870 111u16,
15871 value.to_bytes_with_nul().len() as u16,
15872 );
15873 self.as_rec_mut().extend(value.to_bytes_with_nul());
15874 self
15875 }
15876 pub fn push_fmsg_obj_name_bytes(mut self, value: &[u8]) -> Self {
15877 push_header(self.as_rec_mut(), 111u16, (value.len() + 1) as u16);
15878 self.as_rec_mut().extend(value);
15879 self.as_rec_mut().push(0);
15880 self
15881 }
15882}
15883impl<Prev: Rec> Drop for PushDlFmsg<Prev> {
15884 fn drop(&mut self) {
15885 if let Some(prev) = &mut self.prev {
15886 if let Some(header_offset) = &self.header_offset {
15887 finalize_nested_header(prev.as_rec_mut(), *header_offset);
15888 }
15889 }
15890 }
15891}
15892pub struct PushDlHealthReporter<Prev: Rec> {
15893 pub(crate) prev: Option<Prev>,
15894 pub(crate) header_offset: Option<usize>,
15895}
15896impl<Prev: Rec> Rec for PushDlHealthReporter<Prev> {
15897 fn as_rec_mut(&mut self) -> &mut Vec<u8> {
15898 self.prev.as_mut().unwrap().as_rec_mut()
15899 }
15900 fn as_rec(&self) -> &Vec<u8> {
15901 self.prev.as_ref().unwrap().as_rec()
15902 }
15903}
15904impl<Prev: Rec> PushDlHealthReporter<Prev> {
15905 pub fn new(prev: Prev) -> Self {
15906 Self {
15907 prev: Some(prev),
15908 header_offset: None,
15909 }
15910 }
15911 pub fn end_nested(mut self) -> Prev {
15912 let mut prev = self.prev.take().unwrap();
15913 if let Some(header_offset) = &self.header_offset {
15914 finalize_nested_header(prev.as_rec_mut(), *header_offset);
15915 }
15916 prev
15917 }
15918 pub fn push_health_reporter_name(mut self, value: &CStr) -> Self {
15919 push_header(
15920 self.as_rec_mut(),
15921 115u16,
15922 value.to_bytes_with_nul().len() as u16,
15923 );
15924 self.as_rec_mut().extend(value.to_bytes_with_nul());
15925 self
15926 }
15927 pub fn push_health_reporter_name_bytes(mut self, value: &[u8]) -> Self {
15928 push_header(self.as_rec_mut(), 115u16, (value.len() + 1) as u16);
15929 self.as_rec_mut().extend(value);
15930 self.as_rec_mut().push(0);
15931 self
15932 }
15933 pub fn push_health_reporter_state(mut self, value: u8) -> Self {
15934 push_header(self.as_rec_mut(), 116u16, 1 as u16);
15935 self.as_rec_mut().extend(value.to_ne_bytes());
15936 self
15937 }
15938 pub fn push_health_reporter_err_count(mut self, value: u64) -> Self {
15939 push_header(self.as_rec_mut(), 117u16, 8 as u16);
15940 self.as_rec_mut().extend(value.to_ne_bytes());
15941 self
15942 }
15943 pub fn push_health_reporter_recover_count(mut self, value: u64) -> Self {
15944 push_header(self.as_rec_mut(), 118u16, 8 as u16);
15945 self.as_rec_mut().extend(value.to_ne_bytes());
15946 self
15947 }
15948 pub fn push_health_reporter_dump_ts(mut self, value: u64) -> Self {
15949 push_header(self.as_rec_mut(), 119u16, 8 as u16);
15950 self.as_rec_mut().extend(value.to_ne_bytes());
15951 self
15952 }
15953 pub fn push_health_reporter_graceful_period(mut self, value: u64) -> Self {
15954 push_header(self.as_rec_mut(), 120u16, 8 as u16);
15955 self.as_rec_mut().extend(value.to_ne_bytes());
15956 self
15957 }
15958 pub fn push_health_reporter_auto_recover(mut self, value: u8) -> Self {
15959 push_header(self.as_rec_mut(), 121u16, 1 as u16);
15960 self.as_rec_mut().extend(value.to_ne_bytes());
15961 self
15962 }
15963 pub fn push_health_reporter_dump_ts_ns(mut self, value: u64) -> Self {
15964 push_header(self.as_rec_mut(), 137u16, 8 as u16);
15965 self.as_rec_mut().extend(value.to_ne_bytes());
15966 self
15967 }
15968 pub fn push_health_reporter_auto_dump(mut self, value: u8) -> Self {
15969 push_header(self.as_rec_mut(), 141u16, 1 as u16);
15970 self.as_rec_mut().extend(value.to_ne_bytes());
15971 self
15972 }
15973 #[doc = "Time (in msec) for recoveries before starting the grace period.\n"]
15974 pub fn push_health_reporter_burst_period(mut self, value: u64) -> Self {
15975 push_header(self.as_rec_mut(), 181u16, 8 as u16);
15976 self.as_rec_mut().extend(value.to_ne_bytes());
15977 self
15978 }
15979}
15980impl<Prev: Rec> Drop for PushDlHealthReporter<Prev> {
15981 fn drop(&mut self) {
15982 if let Some(prev) = &mut self.prev {
15983 if let Some(header_offset) = &self.header_offset {
15984 finalize_nested_header(prev.as_rec_mut(), *header_offset);
15985 }
15986 }
15987 }
15988}
15989pub struct PushDlAttrStats<Prev: Rec> {
15990 pub(crate) prev: Option<Prev>,
15991 pub(crate) header_offset: Option<usize>,
15992}
15993impl<Prev: Rec> Rec for PushDlAttrStats<Prev> {
15994 fn as_rec_mut(&mut self) -> &mut Vec<u8> {
15995 self.prev.as_mut().unwrap().as_rec_mut()
15996 }
15997 fn as_rec(&self) -> &Vec<u8> {
15998 self.prev.as_ref().unwrap().as_rec()
15999 }
16000}
16001impl<Prev: Rec> PushDlAttrStats<Prev> {
16002 pub fn new(prev: Prev) -> Self {
16003 Self {
16004 prev: Some(prev),
16005 header_offset: None,
16006 }
16007 }
16008 pub fn end_nested(mut self) -> Prev {
16009 let mut prev = self.prev.take().unwrap();
16010 if let Some(header_offset) = &self.header_offset {
16011 finalize_nested_header(prev.as_rec_mut(), *header_offset);
16012 }
16013 prev
16014 }
16015 pub fn push_stats_rx_packets(mut self, value: u64) -> Self {
16016 push_header(self.as_rec_mut(), 0u16, 8 as u16);
16017 self.as_rec_mut().extend(value.to_ne_bytes());
16018 self
16019 }
16020 pub fn push_stats_rx_bytes(mut self, value: u64) -> Self {
16021 push_header(self.as_rec_mut(), 1u16, 8 as u16);
16022 self.as_rec_mut().extend(value.to_ne_bytes());
16023 self
16024 }
16025 pub fn push_stats_rx_dropped(mut self, value: u64) -> Self {
16026 push_header(self.as_rec_mut(), 2u16, 8 as u16);
16027 self.as_rec_mut().extend(value.to_ne_bytes());
16028 self
16029 }
16030}
16031impl<Prev: Rec> Drop for PushDlAttrStats<Prev> {
16032 fn drop(&mut self) {
16033 if let Some(prev) = &mut self.prev {
16034 if let Some(header_offset) = &self.header_offset {
16035 finalize_nested_header(prev.as_rec_mut(), *header_offset);
16036 }
16037 }
16038 }
16039}
16040pub struct PushDlTrapMetadata<Prev: Rec> {
16041 pub(crate) prev: Option<Prev>,
16042 pub(crate) header_offset: Option<usize>,
16043}
16044impl<Prev: Rec> Rec for PushDlTrapMetadata<Prev> {
16045 fn as_rec_mut(&mut self) -> &mut Vec<u8> {
16046 self.prev.as_mut().unwrap().as_rec_mut()
16047 }
16048 fn as_rec(&self) -> &Vec<u8> {
16049 self.prev.as_ref().unwrap().as_rec()
16050 }
16051}
16052impl<Prev: Rec> PushDlTrapMetadata<Prev> {
16053 pub fn new(prev: Prev) -> Self {
16054 Self {
16055 prev: Some(prev),
16056 header_offset: None,
16057 }
16058 }
16059 pub fn end_nested(mut self) -> Prev {
16060 let mut prev = self.prev.take().unwrap();
16061 if let Some(header_offset) = &self.header_offset {
16062 finalize_nested_header(prev.as_rec_mut(), *header_offset);
16063 }
16064 prev
16065 }
16066 pub fn push_trap_metadata_type_in_port(mut self, value: ()) -> Self {
16067 push_header(self.as_rec_mut(), 0u16, 0 as u16);
16068 self
16069 }
16070 pub fn push_trap_metadata_type_fa_cookie(mut self, value: ()) -> Self {
16071 push_header(self.as_rec_mut(), 1u16, 0 as u16);
16072 self
16073 }
16074}
16075impl<Prev: Rec> Drop for PushDlTrapMetadata<Prev> {
16076 fn drop(&mut self) {
16077 if let Some(prev) = &mut self.prev {
16078 if let Some(header_offset) = &self.header_offset {
16079 finalize_nested_header(prev.as_rec_mut(), *header_offset);
16080 }
16081 }
16082 }
16083}
16084pub struct PushDlLinecardSupportedTypes<Prev: Rec> {
16085 pub(crate) prev: Option<Prev>,
16086 pub(crate) header_offset: Option<usize>,
16087}
16088impl<Prev: Rec> Rec for PushDlLinecardSupportedTypes<Prev> {
16089 fn as_rec_mut(&mut self) -> &mut Vec<u8> {
16090 self.prev.as_mut().unwrap().as_rec_mut()
16091 }
16092 fn as_rec(&self) -> &Vec<u8> {
16093 self.prev.as_ref().unwrap().as_rec()
16094 }
16095}
16096impl<Prev: Rec> PushDlLinecardSupportedTypes<Prev> {
16097 pub fn new(prev: Prev) -> Self {
16098 Self {
16099 prev: Some(prev),
16100 header_offset: None,
16101 }
16102 }
16103 pub fn end_nested(mut self) -> Prev {
16104 let mut prev = self.prev.take().unwrap();
16105 if let Some(header_offset) = &self.header_offset {
16106 finalize_nested_header(prev.as_rec_mut(), *header_offset);
16107 }
16108 prev
16109 }
16110 pub fn push_linecard_type(mut self, value: &CStr) -> Self {
16111 push_header(
16112 self.as_rec_mut(),
16113 173u16,
16114 value.to_bytes_with_nul().len() as u16,
16115 );
16116 self.as_rec_mut().extend(value.to_bytes_with_nul());
16117 self
16118 }
16119 pub fn push_linecard_type_bytes(mut self, value: &[u8]) -> Self {
16120 push_header(self.as_rec_mut(), 173u16, (value.len() + 1) as u16);
16121 self.as_rec_mut().extend(value);
16122 self.as_rec_mut().push(0);
16123 self
16124 }
16125}
16126impl<Prev: Rec> Drop for PushDlLinecardSupportedTypes<Prev> {
16127 fn drop(&mut self) {
16128 if let Some(prev) = &mut self.prev {
16129 if let Some(header_offset) = &self.header_offset {
16130 finalize_nested_header(prev.as_rec_mut(), *header_offset);
16131 }
16132 }
16133 }
16134}
16135pub struct PushDlSelftestId<Prev: Rec> {
16136 pub(crate) prev: Option<Prev>,
16137 pub(crate) header_offset: Option<usize>,
16138}
16139impl<Prev: Rec> Rec for PushDlSelftestId<Prev> {
16140 fn as_rec_mut(&mut self) -> &mut Vec<u8> {
16141 self.prev.as_mut().unwrap().as_rec_mut()
16142 }
16143 fn as_rec(&self) -> &Vec<u8> {
16144 self.prev.as_ref().unwrap().as_rec()
16145 }
16146}
16147impl<Prev: Rec> PushDlSelftestId<Prev> {
16148 pub fn new(prev: Prev) -> Self {
16149 Self {
16150 prev: Some(prev),
16151 header_offset: None,
16152 }
16153 }
16154 pub fn end_nested(mut self) -> Prev {
16155 let mut prev = self.prev.take().unwrap();
16156 if let Some(header_offset) = &self.header_offset {
16157 finalize_nested_header(prev.as_rec_mut(), *header_offset);
16158 }
16159 prev
16160 }
16161 pub fn push_flash(mut self, value: ()) -> Self {
16162 push_header(self.as_rec_mut(), 1u16, 0 as u16);
16163 self
16164 }
16165}
16166impl<Prev: Rec> Drop for PushDlSelftestId<Prev> {
16167 fn drop(&mut self) {
16168 if let Some(prev) = &mut self.prev {
16169 if let Some(header_offset) = &self.header_offset {
16170 finalize_nested_header(prev.as_rec_mut(), *header_offset);
16171 }
16172 }
16173 }
16174}
16175pub struct PushDlRateTcBws<Prev: Rec> {
16176 pub(crate) prev: Option<Prev>,
16177 pub(crate) header_offset: Option<usize>,
16178}
16179impl<Prev: Rec> Rec for PushDlRateTcBws<Prev> {
16180 fn as_rec_mut(&mut self) -> &mut Vec<u8> {
16181 self.prev.as_mut().unwrap().as_rec_mut()
16182 }
16183 fn as_rec(&self) -> &Vec<u8> {
16184 self.prev.as_ref().unwrap().as_rec()
16185 }
16186}
16187impl<Prev: Rec> PushDlRateTcBws<Prev> {
16188 pub fn new(prev: Prev) -> Self {
16189 Self {
16190 prev: Some(prev),
16191 header_offset: None,
16192 }
16193 }
16194 pub fn end_nested(mut self) -> Prev {
16195 let mut prev = self.prev.take().unwrap();
16196 if let Some(header_offset) = &self.header_offset {
16197 finalize_nested_header(prev.as_rec_mut(), *header_offset);
16198 }
16199 prev
16200 }
16201 pub fn push_index(mut self, value: u8) -> Self {
16202 push_header(self.as_rec_mut(), 1u16, 1 as u16);
16203 self.as_rec_mut().extend(value.to_ne_bytes());
16204 self
16205 }
16206 #[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"]
16207 pub fn push_bw(mut self, value: u32) -> Self {
16208 push_header(self.as_rec_mut(), 2u16, 4 as u16);
16209 self.as_rec_mut().extend(value.to_ne_bytes());
16210 self
16211 }
16212}
16213impl<Prev: Rec> Drop for PushDlRateTcBws<Prev> {
16214 fn drop(&mut self) {
16215 if let Some(prev) = &mut self.prev {
16216 if let Some(header_offset) = &self.header_offset {
16217 finalize_nested_header(prev.as_rec_mut(), *header_offset);
16218 }
16219 }
16220 }
16221}
16222#[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"]
16223#[derive(Debug)]
16224pub struct OpGetDump<'r> {
16225 request: Request<'r>,
16226}
16227impl<'r> OpGetDump<'r> {
16228 pub fn new(mut request: Request<'r>) -> Self {
16229 Self::write_header(request.buf_mut());
16230 Self {
16231 request: request.set_dump(),
16232 }
16233 }
16234 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
16235 Self::write_header(buf);
16236 PushDevlink::new(buf)
16237 }
16238 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
16239 PushDevlink::new(self.request.buf_mut())
16240 }
16241 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
16242 PushDevlink::new(self.request.buf)
16243 }
16244 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
16245 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
16246 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
16247 }
16248 fn write_header<Prev: Rec>(prev: &mut Prev) {
16249 let mut header = BuiltinNfgenmsg::new();
16250 header.cmd = 1u8;
16251 header.version = 1u8;
16252 prev.as_rec_mut().extend(header.as_slice());
16253 }
16254}
16255impl NetlinkRequest for OpGetDump<'_> {
16256 fn protocol(&self) -> Protocol {
16257 Protocol::Generic("devlink".as_bytes())
16258 }
16259 fn flags(&self) -> u16 {
16260 self.request.flags
16261 }
16262 fn payload(&self) -> &[u8] {
16263 self.request.buf()
16264 }
16265 type ReplyType<'buf> = IterableDevlink<'buf>;
16266 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
16267 Self::decode_request(buf)
16268 }
16269 fn lookup(
16270 buf: &[u8],
16271 offset: usize,
16272 missing_type: Option<u16>,
16273 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
16274 Self::decode_request(buf).lookup_attr(offset, missing_type)
16275 }
16276}
16277#[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"]
16278#[derive(Debug)]
16279pub struct OpGetDo<'r> {
16280 request: Request<'r>,
16281}
16282impl<'r> OpGetDo<'r> {
16283 pub fn new(mut request: Request<'r>) -> Self {
16284 Self::write_header(request.buf_mut());
16285 Self { request: request }
16286 }
16287 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
16288 Self::write_header(buf);
16289 PushDevlink::new(buf)
16290 }
16291 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
16292 PushDevlink::new(self.request.buf_mut())
16293 }
16294 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
16295 PushDevlink::new(self.request.buf)
16296 }
16297 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
16298 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
16299 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
16300 }
16301 fn write_header<Prev: Rec>(prev: &mut Prev) {
16302 let mut header = BuiltinNfgenmsg::new();
16303 header.cmd = 1u8;
16304 header.version = 1u8;
16305 prev.as_rec_mut().extend(header.as_slice());
16306 }
16307}
16308impl NetlinkRequest for OpGetDo<'_> {
16309 fn protocol(&self) -> Protocol {
16310 Protocol::Generic("devlink".as_bytes())
16311 }
16312 fn flags(&self) -> u16 {
16313 self.request.flags
16314 }
16315 fn payload(&self) -> &[u8] {
16316 self.request.buf()
16317 }
16318 type ReplyType<'buf> = IterableDevlink<'buf>;
16319 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
16320 Self::decode_request(buf)
16321 }
16322 fn lookup(
16323 buf: &[u8],
16324 offset: usize,
16325 missing_type: Option<u16>,
16326 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
16327 Self::decode_request(buf).lookup_attr(offset, missing_type)
16328 }
16329}
16330#[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"]
16331#[derive(Debug)]
16332pub struct OpPortGetDump<'r> {
16333 request: Request<'r>,
16334}
16335impl<'r> OpPortGetDump<'r> {
16336 pub fn new(mut request: Request<'r>) -> Self {
16337 Self::write_header(request.buf_mut());
16338 Self {
16339 request: request.set_dump(),
16340 }
16341 }
16342 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
16343 Self::write_header(buf);
16344 PushDevlink::new(buf)
16345 }
16346 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
16347 PushDevlink::new(self.request.buf_mut())
16348 }
16349 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
16350 PushDevlink::new(self.request.buf)
16351 }
16352 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
16353 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
16354 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
16355 }
16356 fn write_header<Prev: Rec>(prev: &mut Prev) {
16357 let mut header = BuiltinNfgenmsg::new();
16358 header.cmd = 5u8;
16359 header.version = 1u8;
16360 prev.as_rec_mut().extend(header.as_slice());
16361 }
16362}
16363impl NetlinkRequest for OpPortGetDump<'_> {
16364 fn protocol(&self) -> Protocol {
16365 Protocol::Generic("devlink".as_bytes())
16366 }
16367 fn flags(&self) -> u16 {
16368 self.request.flags
16369 }
16370 fn payload(&self) -> &[u8] {
16371 self.request.buf()
16372 }
16373 type ReplyType<'buf> = IterableDevlink<'buf>;
16374 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
16375 Self::decode_request(buf)
16376 }
16377 fn lookup(
16378 buf: &[u8],
16379 offset: usize,
16380 missing_type: Option<u16>,
16381 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
16382 Self::decode_request(buf).lookup_attr(offset, missing_type)
16383 }
16384}
16385#[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"]
16386#[derive(Debug)]
16387pub struct OpPortGetDo<'r> {
16388 request: Request<'r>,
16389}
16390impl<'r> OpPortGetDo<'r> {
16391 pub fn new(mut request: Request<'r>) -> Self {
16392 Self::write_header(request.buf_mut());
16393 Self { request: request }
16394 }
16395 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
16396 Self::write_header(buf);
16397 PushDevlink::new(buf)
16398 }
16399 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
16400 PushDevlink::new(self.request.buf_mut())
16401 }
16402 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
16403 PushDevlink::new(self.request.buf)
16404 }
16405 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
16406 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
16407 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
16408 }
16409 fn write_header<Prev: Rec>(prev: &mut Prev) {
16410 let mut header = BuiltinNfgenmsg::new();
16411 header.cmd = 5u8;
16412 header.version = 1u8;
16413 prev.as_rec_mut().extend(header.as_slice());
16414 }
16415}
16416impl NetlinkRequest for OpPortGetDo<'_> {
16417 fn protocol(&self) -> Protocol {
16418 Protocol::Generic("devlink".as_bytes())
16419 }
16420 fn flags(&self) -> u16 {
16421 self.request.flags
16422 }
16423 fn payload(&self) -> &[u8] {
16424 self.request.buf()
16425 }
16426 type ReplyType<'buf> = IterableDevlink<'buf>;
16427 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
16428 Self::decode_request(buf)
16429 }
16430 fn lookup(
16431 buf: &[u8],
16432 offset: usize,
16433 missing_type: Option<u16>,
16434 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
16435 Self::decode_request(buf).lookup_attr(offset, missing_type)
16436 }
16437}
16438#[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"]
16439#[derive(Debug)]
16440pub struct OpPortSetDo<'r> {
16441 request: Request<'r>,
16442}
16443impl<'r> OpPortSetDo<'r> {
16444 pub fn new(mut request: Request<'r>) -> Self {
16445 Self::write_header(request.buf_mut());
16446 Self { request: request }
16447 }
16448 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
16449 Self::write_header(buf);
16450 PushDevlink::new(buf)
16451 }
16452 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
16453 PushDevlink::new(self.request.buf_mut())
16454 }
16455 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
16456 PushDevlink::new(self.request.buf)
16457 }
16458 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
16459 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
16460 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
16461 }
16462 fn write_header<Prev: Rec>(prev: &mut Prev) {
16463 let mut header = BuiltinNfgenmsg::new();
16464 header.cmd = 6u8;
16465 header.version = 1u8;
16466 prev.as_rec_mut().extend(header.as_slice());
16467 }
16468}
16469impl NetlinkRequest for OpPortSetDo<'_> {
16470 fn protocol(&self) -> Protocol {
16471 Protocol::Generic("devlink".as_bytes())
16472 }
16473 fn flags(&self) -> u16 {
16474 self.request.flags
16475 }
16476 fn payload(&self) -> &[u8] {
16477 self.request.buf()
16478 }
16479 type ReplyType<'buf> = IterableDevlink<'buf>;
16480 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
16481 Self::decode_request(buf)
16482 }
16483 fn lookup(
16484 buf: &[u8],
16485 offset: usize,
16486 missing_type: Option<u16>,
16487 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
16488 Self::decode_request(buf).lookup_attr(offset, missing_type)
16489 }
16490}
16491#[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"]
16492#[derive(Debug)]
16493pub struct OpPortNewDo<'r> {
16494 request: Request<'r>,
16495}
16496impl<'r> OpPortNewDo<'r> {
16497 pub fn new(mut request: Request<'r>) -> Self {
16498 Self::write_header(request.buf_mut());
16499 Self { request: request }
16500 }
16501 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
16502 Self::write_header(buf);
16503 PushDevlink::new(buf)
16504 }
16505 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
16506 PushDevlink::new(self.request.buf_mut())
16507 }
16508 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
16509 PushDevlink::new(self.request.buf)
16510 }
16511 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
16512 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
16513 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
16514 }
16515 fn write_header<Prev: Rec>(prev: &mut Prev) {
16516 let mut header = BuiltinNfgenmsg::new();
16517 header.cmd = 7u8;
16518 header.version = 1u8;
16519 prev.as_rec_mut().extend(header.as_slice());
16520 }
16521}
16522impl NetlinkRequest for OpPortNewDo<'_> {
16523 fn protocol(&self) -> Protocol {
16524 Protocol::Generic("devlink".as_bytes())
16525 }
16526 fn flags(&self) -> u16 {
16527 self.request.flags
16528 }
16529 fn payload(&self) -> &[u8] {
16530 self.request.buf()
16531 }
16532 type ReplyType<'buf> = IterableDevlink<'buf>;
16533 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
16534 Self::decode_request(buf)
16535 }
16536 fn lookup(
16537 buf: &[u8],
16538 offset: usize,
16539 missing_type: Option<u16>,
16540 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
16541 Self::decode_request(buf).lookup_attr(offset, missing_type)
16542 }
16543}
16544#[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"]
16545#[derive(Debug)]
16546pub struct OpPortDelDo<'r> {
16547 request: Request<'r>,
16548}
16549impl<'r> OpPortDelDo<'r> {
16550 pub fn new(mut request: Request<'r>) -> Self {
16551 Self::write_header(request.buf_mut());
16552 Self { request: request }
16553 }
16554 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
16555 Self::write_header(buf);
16556 PushDevlink::new(buf)
16557 }
16558 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
16559 PushDevlink::new(self.request.buf_mut())
16560 }
16561 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
16562 PushDevlink::new(self.request.buf)
16563 }
16564 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
16565 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
16566 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
16567 }
16568 fn write_header<Prev: Rec>(prev: &mut Prev) {
16569 let mut header = BuiltinNfgenmsg::new();
16570 header.cmd = 8u8;
16571 header.version = 1u8;
16572 prev.as_rec_mut().extend(header.as_slice());
16573 }
16574}
16575impl NetlinkRequest for OpPortDelDo<'_> {
16576 fn protocol(&self) -> Protocol {
16577 Protocol::Generic("devlink".as_bytes())
16578 }
16579 fn flags(&self) -> u16 {
16580 self.request.flags
16581 }
16582 fn payload(&self) -> &[u8] {
16583 self.request.buf()
16584 }
16585 type ReplyType<'buf> = IterableDevlink<'buf>;
16586 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
16587 Self::decode_request(buf)
16588 }
16589 fn lookup(
16590 buf: &[u8],
16591 offset: usize,
16592 missing_type: Option<u16>,
16593 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
16594 Self::decode_request(buf).lookup_attr(offset, missing_type)
16595 }
16596}
16597#[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"]
16598#[derive(Debug)]
16599pub struct OpPortSplitDo<'r> {
16600 request: Request<'r>,
16601}
16602impl<'r> OpPortSplitDo<'r> {
16603 pub fn new(mut request: Request<'r>) -> Self {
16604 Self::write_header(request.buf_mut());
16605 Self { request: request }
16606 }
16607 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
16608 Self::write_header(buf);
16609 PushDevlink::new(buf)
16610 }
16611 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
16612 PushDevlink::new(self.request.buf_mut())
16613 }
16614 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
16615 PushDevlink::new(self.request.buf)
16616 }
16617 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
16618 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
16619 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
16620 }
16621 fn write_header<Prev: Rec>(prev: &mut Prev) {
16622 let mut header = BuiltinNfgenmsg::new();
16623 header.cmd = 9u8;
16624 header.version = 1u8;
16625 prev.as_rec_mut().extend(header.as_slice());
16626 }
16627}
16628impl NetlinkRequest for OpPortSplitDo<'_> {
16629 fn protocol(&self) -> Protocol {
16630 Protocol::Generic("devlink".as_bytes())
16631 }
16632 fn flags(&self) -> u16 {
16633 self.request.flags
16634 }
16635 fn payload(&self) -> &[u8] {
16636 self.request.buf()
16637 }
16638 type ReplyType<'buf> = IterableDevlink<'buf>;
16639 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
16640 Self::decode_request(buf)
16641 }
16642 fn lookup(
16643 buf: &[u8],
16644 offset: usize,
16645 missing_type: Option<u16>,
16646 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
16647 Self::decode_request(buf).lookup_attr(offset, missing_type)
16648 }
16649}
16650#[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"]
16651#[derive(Debug)]
16652pub struct OpPortUnsplitDo<'r> {
16653 request: Request<'r>,
16654}
16655impl<'r> OpPortUnsplitDo<'r> {
16656 pub fn new(mut request: Request<'r>) -> Self {
16657 Self::write_header(request.buf_mut());
16658 Self { request: request }
16659 }
16660 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
16661 Self::write_header(buf);
16662 PushDevlink::new(buf)
16663 }
16664 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
16665 PushDevlink::new(self.request.buf_mut())
16666 }
16667 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
16668 PushDevlink::new(self.request.buf)
16669 }
16670 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
16671 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
16672 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
16673 }
16674 fn write_header<Prev: Rec>(prev: &mut Prev) {
16675 let mut header = BuiltinNfgenmsg::new();
16676 header.cmd = 10u8;
16677 header.version = 1u8;
16678 prev.as_rec_mut().extend(header.as_slice());
16679 }
16680}
16681impl NetlinkRequest for OpPortUnsplitDo<'_> {
16682 fn protocol(&self) -> Protocol {
16683 Protocol::Generic("devlink".as_bytes())
16684 }
16685 fn flags(&self) -> u16 {
16686 self.request.flags
16687 }
16688 fn payload(&self) -> &[u8] {
16689 self.request.buf()
16690 }
16691 type ReplyType<'buf> = IterableDevlink<'buf>;
16692 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
16693 Self::decode_request(buf)
16694 }
16695 fn lookup(
16696 buf: &[u8],
16697 offset: usize,
16698 missing_type: Option<u16>,
16699 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
16700 Self::decode_request(buf).lookup_attr(offset, missing_type)
16701 }
16702}
16703#[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"]
16704#[derive(Debug)]
16705pub struct OpSbGetDump<'r> {
16706 request: Request<'r>,
16707}
16708impl<'r> OpSbGetDump<'r> {
16709 pub fn new(mut request: Request<'r>) -> Self {
16710 Self::write_header(request.buf_mut());
16711 Self {
16712 request: request.set_dump(),
16713 }
16714 }
16715 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
16716 Self::write_header(buf);
16717 PushDevlink::new(buf)
16718 }
16719 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
16720 PushDevlink::new(self.request.buf_mut())
16721 }
16722 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
16723 PushDevlink::new(self.request.buf)
16724 }
16725 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
16726 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
16727 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
16728 }
16729 fn write_header<Prev: Rec>(prev: &mut Prev) {
16730 let mut header = BuiltinNfgenmsg::new();
16731 header.cmd = 11u8;
16732 header.version = 1u8;
16733 prev.as_rec_mut().extend(header.as_slice());
16734 }
16735}
16736impl NetlinkRequest for OpSbGetDump<'_> {
16737 fn protocol(&self) -> Protocol {
16738 Protocol::Generic("devlink".as_bytes())
16739 }
16740 fn flags(&self) -> u16 {
16741 self.request.flags
16742 }
16743 fn payload(&self) -> &[u8] {
16744 self.request.buf()
16745 }
16746 type ReplyType<'buf> = IterableDevlink<'buf>;
16747 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
16748 Self::decode_request(buf)
16749 }
16750 fn lookup(
16751 buf: &[u8],
16752 offset: usize,
16753 missing_type: Option<u16>,
16754 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
16755 Self::decode_request(buf).lookup_attr(offset, missing_type)
16756 }
16757}
16758#[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"]
16759#[derive(Debug)]
16760pub struct OpSbGetDo<'r> {
16761 request: Request<'r>,
16762}
16763impl<'r> OpSbGetDo<'r> {
16764 pub fn new(mut request: Request<'r>) -> Self {
16765 Self::write_header(request.buf_mut());
16766 Self { request: request }
16767 }
16768 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
16769 Self::write_header(buf);
16770 PushDevlink::new(buf)
16771 }
16772 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
16773 PushDevlink::new(self.request.buf_mut())
16774 }
16775 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
16776 PushDevlink::new(self.request.buf)
16777 }
16778 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
16779 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
16780 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
16781 }
16782 fn write_header<Prev: Rec>(prev: &mut Prev) {
16783 let mut header = BuiltinNfgenmsg::new();
16784 header.cmd = 11u8;
16785 header.version = 1u8;
16786 prev.as_rec_mut().extend(header.as_slice());
16787 }
16788}
16789impl NetlinkRequest for OpSbGetDo<'_> {
16790 fn protocol(&self) -> Protocol {
16791 Protocol::Generic("devlink".as_bytes())
16792 }
16793 fn flags(&self) -> u16 {
16794 self.request.flags
16795 }
16796 fn payload(&self) -> &[u8] {
16797 self.request.buf()
16798 }
16799 type ReplyType<'buf> = IterableDevlink<'buf>;
16800 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
16801 Self::decode_request(buf)
16802 }
16803 fn lookup(
16804 buf: &[u8],
16805 offset: usize,
16806 missing_type: Option<u16>,
16807 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
16808 Self::decode_request(buf).lookup_attr(offset, missing_type)
16809 }
16810}
16811#[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"]
16812#[derive(Debug)]
16813pub struct OpSbPoolGetDump<'r> {
16814 request: Request<'r>,
16815}
16816impl<'r> OpSbPoolGetDump<'r> {
16817 pub fn new(mut request: Request<'r>) -> Self {
16818 Self::write_header(request.buf_mut());
16819 Self {
16820 request: request.set_dump(),
16821 }
16822 }
16823 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
16824 Self::write_header(buf);
16825 PushDevlink::new(buf)
16826 }
16827 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
16828 PushDevlink::new(self.request.buf_mut())
16829 }
16830 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
16831 PushDevlink::new(self.request.buf)
16832 }
16833 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
16834 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
16835 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
16836 }
16837 fn write_header<Prev: Rec>(prev: &mut Prev) {
16838 let mut header = BuiltinNfgenmsg::new();
16839 header.cmd = 15u8;
16840 header.version = 1u8;
16841 prev.as_rec_mut().extend(header.as_slice());
16842 }
16843}
16844impl NetlinkRequest for OpSbPoolGetDump<'_> {
16845 fn protocol(&self) -> Protocol {
16846 Protocol::Generic("devlink".as_bytes())
16847 }
16848 fn flags(&self) -> u16 {
16849 self.request.flags
16850 }
16851 fn payload(&self) -> &[u8] {
16852 self.request.buf()
16853 }
16854 type ReplyType<'buf> = IterableDevlink<'buf>;
16855 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
16856 Self::decode_request(buf)
16857 }
16858 fn lookup(
16859 buf: &[u8],
16860 offset: usize,
16861 missing_type: Option<u16>,
16862 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
16863 Self::decode_request(buf).lookup_attr(offset, missing_type)
16864 }
16865}
16866#[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"]
16867#[derive(Debug)]
16868pub struct OpSbPoolGetDo<'r> {
16869 request: Request<'r>,
16870}
16871impl<'r> OpSbPoolGetDo<'r> {
16872 pub fn new(mut request: Request<'r>) -> Self {
16873 Self::write_header(request.buf_mut());
16874 Self { request: request }
16875 }
16876 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
16877 Self::write_header(buf);
16878 PushDevlink::new(buf)
16879 }
16880 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
16881 PushDevlink::new(self.request.buf_mut())
16882 }
16883 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
16884 PushDevlink::new(self.request.buf)
16885 }
16886 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
16887 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
16888 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
16889 }
16890 fn write_header<Prev: Rec>(prev: &mut Prev) {
16891 let mut header = BuiltinNfgenmsg::new();
16892 header.cmd = 15u8;
16893 header.version = 1u8;
16894 prev.as_rec_mut().extend(header.as_slice());
16895 }
16896}
16897impl NetlinkRequest for OpSbPoolGetDo<'_> {
16898 fn protocol(&self) -> Protocol {
16899 Protocol::Generic("devlink".as_bytes())
16900 }
16901 fn flags(&self) -> u16 {
16902 self.request.flags
16903 }
16904 fn payload(&self) -> &[u8] {
16905 self.request.buf()
16906 }
16907 type ReplyType<'buf> = IterableDevlink<'buf>;
16908 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
16909 Self::decode_request(buf)
16910 }
16911 fn lookup(
16912 buf: &[u8],
16913 offset: usize,
16914 missing_type: Option<u16>,
16915 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
16916 Self::decode_request(buf).lookup_attr(offset, missing_type)
16917 }
16918}
16919#[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"]
16920#[derive(Debug)]
16921pub struct OpSbPoolSetDo<'r> {
16922 request: Request<'r>,
16923}
16924impl<'r> OpSbPoolSetDo<'r> {
16925 pub fn new(mut request: Request<'r>) -> Self {
16926 Self::write_header(request.buf_mut());
16927 Self { request: request }
16928 }
16929 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
16930 Self::write_header(buf);
16931 PushDevlink::new(buf)
16932 }
16933 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
16934 PushDevlink::new(self.request.buf_mut())
16935 }
16936 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
16937 PushDevlink::new(self.request.buf)
16938 }
16939 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
16940 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
16941 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
16942 }
16943 fn write_header<Prev: Rec>(prev: &mut Prev) {
16944 let mut header = BuiltinNfgenmsg::new();
16945 header.cmd = 16u8;
16946 header.version = 1u8;
16947 prev.as_rec_mut().extend(header.as_slice());
16948 }
16949}
16950impl NetlinkRequest for OpSbPoolSetDo<'_> {
16951 fn protocol(&self) -> Protocol {
16952 Protocol::Generic("devlink".as_bytes())
16953 }
16954 fn flags(&self) -> u16 {
16955 self.request.flags
16956 }
16957 fn payload(&self) -> &[u8] {
16958 self.request.buf()
16959 }
16960 type ReplyType<'buf> = IterableDevlink<'buf>;
16961 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
16962 Self::decode_request(buf)
16963 }
16964 fn lookup(
16965 buf: &[u8],
16966 offset: usize,
16967 missing_type: Option<u16>,
16968 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
16969 Self::decode_request(buf).lookup_attr(offset, missing_type)
16970 }
16971}
16972#[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"]
16973#[derive(Debug)]
16974pub struct OpSbPortPoolGetDump<'r> {
16975 request: Request<'r>,
16976}
16977impl<'r> OpSbPortPoolGetDump<'r> {
16978 pub fn new(mut request: Request<'r>) -> Self {
16979 Self::write_header(request.buf_mut());
16980 Self {
16981 request: request.set_dump(),
16982 }
16983 }
16984 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
16985 Self::write_header(buf);
16986 PushDevlink::new(buf)
16987 }
16988 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
16989 PushDevlink::new(self.request.buf_mut())
16990 }
16991 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
16992 PushDevlink::new(self.request.buf)
16993 }
16994 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
16995 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
16996 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
16997 }
16998 fn write_header<Prev: Rec>(prev: &mut Prev) {
16999 let mut header = BuiltinNfgenmsg::new();
17000 header.cmd = 19u8;
17001 header.version = 1u8;
17002 prev.as_rec_mut().extend(header.as_slice());
17003 }
17004}
17005impl NetlinkRequest for OpSbPortPoolGetDump<'_> {
17006 fn protocol(&self) -> Protocol {
17007 Protocol::Generic("devlink".as_bytes())
17008 }
17009 fn flags(&self) -> u16 {
17010 self.request.flags
17011 }
17012 fn payload(&self) -> &[u8] {
17013 self.request.buf()
17014 }
17015 type ReplyType<'buf> = IterableDevlink<'buf>;
17016 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
17017 Self::decode_request(buf)
17018 }
17019 fn lookup(
17020 buf: &[u8],
17021 offset: usize,
17022 missing_type: Option<u16>,
17023 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
17024 Self::decode_request(buf).lookup_attr(offset, missing_type)
17025 }
17026}
17027#[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"]
17028#[derive(Debug)]
17029pub struct OpSbPortPoolGetDo<'r> {
17030 request: Request<'r>,
17031}
17032impl<'r> OpSbPortPoolGetDo<'r> {
17033 pub fn new(mut request: Request<'r>) -> Self {
17034 Self::write_header(request.buf_mut());
17035 Self { request: request }
17036 }
17037 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
17038 Self::write_header(buf);
17039 PushDevlink::new(buf)
17040 }
17041 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
17042 PushDevlink::new(self.request.buf_mut())
17043 }
17044 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
17045 PushDevlink::new(self.request.buf)
17046 }
17047 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
17048 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
17049 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
17050 }
17051 fn write_header<Prev: Rec>(prev: &mut Prev) {
17052 let mut header = BuiltinNfgenmsg::new();
17053 header.cmd = 19u8;
17054 header.version = 1u8;
17055 prev.as_rec_mut().extend(header.as_slice());
17056 }
17057}
17058impl NetlinkRequest for OpSbPortPoolGetDo<'_> {
17059 fn protocol(&self) -> Protocol {
17060 Protocol::Generic("devlink".as_bytes())
17061 }
17062 fn flags(&self) -> u16 {
17063 self.request.flags
17064 }
17065 fn payload(&self) -> &[u8] {
17066 self.request.buf()
17067 }
17068 type ReplyType<'buf> = IterableDevlink<'buf>;
17069 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
17070 Self::decode_request(buf)
17071 }
17072 fn lookup(
17073 buf: &[u8],
17074 offset: usize,
17075 missing_type: Option<u16>,
17076 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
17077 Self::decode_request(buf).lookup_attr(offset, missing_type)
17078 }
17079}
17080#[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"]
17081#[derive(Debug)]
17082pub struct OpSbPortPoolSetDo<'r> {
17083 request: Request<'r>,
17084}
17085impl<'r> OpSbPortPoolSetDo<'r> {
17086 pub fn new(mut request: Request<'r>) -> Self {
17087 Self::write_header(request.buf_mut());
17088 Self { request: request }
17089 }
17090 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
17091 Self::write_header(buf);
17092 PushDevlink::new(buf)
17093 }
17094 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
17095 PushDevlink::new(self.request.buf_mut())
17096 }
17097 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
17098 PushDevlink::new(self.request.buf)
17099 }
17100 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
17101 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
17102 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
17103 }
17104 fn write_header<Prev: Rec>(prev: &mut Prev) {
17105 let mut header = BuiltinNfgenmsg::new();
17106 header.cmd = 20u8;
17107 header.version = 1u8;
17108 prev.as_rec_mut().extend(header.as_slice());
17109 }
17110}
17111impl NetlinkRequest for OpSbPortPoolSetDo<'_> {
17112 fn protocol(&self) -> Protocol {
17113 Protocol::Generic("devlink".as_bytes())
17114 }
17115 fn flags(&self) -> u16 {
17116 self.request.flags
17117 }
17118 fn payload(&self) -> &[u8] {
17119 self.request.buf()
17120 }
17121 type ReplyType<'buf> = IterableDevlink<'buf>;
17122 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
17123 Self::decode_request(buf)
17124 }
17125 fn lookup(
17126 buf: &[u8],
17127 offset: usize,
17128 missing_type: Option<u16>,
17129 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
17130 Self::decode_request(buf).lookup_attr(offset, missing_type)
17131 }
17132}
17133#[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"]
17134#[derive(Debug)]
17135pub struct OpSbTcPoolBindGetDump<'r> {
17136 request: Request<'r>,
17137}
17138impl<'r> OpSbTcPoolBindGetDump<'r> {
17139 pub fn new(mut request: Request<'r>) -> Self {
17140 Self::write_header(request.buf_mut());
17141 Self {
17142 request: request.set_dump(),
17143 }
17144 }
17145 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
17146 Self::write_header(buf);
17147 PushDevlink::new(buf)
17148 }
17149 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
17150 PushDevlink::new(self.request.buf_mut())
17151 }
17152 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
17153 PushDevlink::new(self.request.buf)
17154 }
17155 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
17156 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
17157 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
17158 }
17159 fn write_header<Prev: Rec>(prev: &mut Prev) {
17160 let mut header = BuiltinNfgenmsg::new();
17161 header.cmd = 23u8;
17162 header.version = 1u8;
17163 prev.as_rec_mut().extend(header.as_slice());
17164 }
17165}
17166impl NetlinkRequest for OpSbTcPoolBindGetDump<'_> {
17167 fn protocol(&self) -> Protocol {
17168 Protocol::Generic("devlink".as_bytes())
17169 }
17170 fn flags(&self) -> u16 {
17171 self.request.flags
17172 }
17173 fn payload(&self) -> &[u8] {
17174 self.request.buf()
17175 }
17176 type ReplyType<'buf> = IterableDevlink<'buf>;
17177 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
17178 Self::decode_request(buf)
17179 }
17180 fn lookup(
17181 buf: &[u8],
17182 offset: usize,
17183 missing_type: Option<u16>,
17184 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
17185 Self::decode_request(buf).lookup_attr(offset, missing_type)
17186 }
17187}
17188#[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"]
17189#[derive(Debug)]
17190pub struct OpSbTcPoolBindGetDo<'r> {
17191 request: Request<'r>,
17192}
17193impl<'r> OpSbTcPoolBindGetDo<'r> {
17194 pub fn new(mut request: Request<'r>) -> Self {
17195 Self::write_header(request.buf_mut());
17196 Self { request: request }
17197 }
17198 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
17199 Self::write_header(buf);
17200 PushDevlink::new(buf)
17201 }
17202 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
17203 PushDevlink::new(self.request.buf_mut())
17204 }
17205 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
17206 PushDevlink::new(self.request.buf)
17207 }
17208 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
17209 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
17210 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
17211 }
17212 fn write_header<Prev: Rec>(prev: &mut Prev) {
17213 let mut header = BuiltinNfgenmsg::new();
17214 header.cmd = 23u8;
17215 header.version = 1u8;
17216 prev.as_rec_mut().extend(header.as_slice());
17217 }
17218}
17219impl NetlinkRequest for OpSbTcPoolBindGetDo<'_> {
17220 fn protocol(&self) -> Protocol {
17221 Protocol::Generic("devlink".as_bytes())
17222 }
17223 fn flags(&self) -> u16 {
17224 self.request.flags
17225 }
17226 fn payload(&self) -> &[u8] {
17227 self.request.buf()
17228 }
17229 type ReplyType<'buf> = IterableDevlink<'buf>;
17230 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
17231 Self::decode_request(buf)
17232 }
17233 fn lookup(
17234 buf: &[u8],
17235 offset: usize,
17236 missing_type: Option<u16>,
17237 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
17238 Self::decode_request(buf).lookup_attr(offset, missing_type)
17239 }
17240}
17241#[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"]
17242#[derive(Debug)]
17243pub struct OpSbTcPoolBindSetDo<'r> {
17244 request: Request<'r>,
17245}
17246impl<'r> OpSbTcPoolBindSetDo<'r> {
17247 pub fn new(mut request: Request<'r>) -> Self {
17248 Self::write_header(request.buf_mut());
17249 Self { request: request }
17250 }
17251 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
17252 Self::write_header(buf);
17253 PushDevlink::new(buf)
17254 }
17255 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
17256 PushDevlink::new(self.request.buf_mut())
17257 }
17258 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
17259 PushDevlink::new(self.request.buf)
17260 }
17261 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
17262 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
17263 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
17264 }
17265 fn write_header<Prev: Rec>(prev: &mut Prev) {
17266 let mut header = BuiltinNfgenmsg::new();
17267 header.cmd = 24u8;
17268 header.version = 1u8;
17269 prev.as_rec_mut().extend(header.as_slice());
17270 }
17271}
17272impl NetlinkRequest for OpSbTcPoolBindSetDo<'_> {
17273 fn protocol(&self) -> Protocol {
17274 Protocol::Generic("devlink".as_bytes())
17275 }
17276 fn flags(&self) -> u16 {
17277 self.request.flags
17278 }
17279 fn payload(&self) -> &[u8] {
17280 self.request.buf()
17281 }
17282 type ReplyType<'buf> = IterableDevlink<'buf>;
17283 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
17284 Self::decode_request(buf)
17285 }
17286 fn lookup(
17287 buf: &[u8],
17288 offset: usize,
17289 missing_type: Option<u16>,
17290 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
17291 Self::decode_request(buf).lookup_attr(offset, missing_type)
17292 }
17293}
17294#[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"]
17295#[derive(Debug)]
17296pub struct OpSbOccSnapshotDo<'r> {
17297 request: Request<'r>,
17298}
17299impl<'r> OpSbOccSnapshotDo<'r> {
17300 pub fn new(mut request: Request<'r>) -> Self {
17301 Self::write_header(request.buf_mut());
17302 Self { request: request }
17303 }
17304 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
17305 Self::write_header(buf);
17306 PushDevlink::new(buf)
17307 }
17308 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
17309 PushDevlink::new(self.request.buf_mut())
17310 }
17311 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
17312 PushDevlink::new(self.request.buf)
17313 }
17314 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
17315 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
17316 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
17317 }
17318 fn write_header<Prev: Rec>(prev: &mut Prev) {
17319 let mut header = BuiltinNfgenmsg::new();
17320 header.cmd = 27u8;
17321 header.version = 1u8;
17322 prev.as_rec_mut().extend(header.as_slice());
17323 }
17324}
17325impl NetlinkRequest for OpSbOccSnapshotDo<'_> {
17326 fn protocol(&self) -> Protocol {
17327 Protocol::Generic("devlink".as_bytes())
17328 }
17329 fn flags(&self) -> u16 {
17330 self.request.flags
17331 }
17332 fn payload(&self) -> &[u8] {
17333 self.request.buf()
17334 }
17335 type ReplyType<'buf> = IterableDevlink<'buf>;
17336 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
17337 Self::decode_request(buf)
17338 }
17339 fn lookup(
17340 buf: &[u8],
17341 offset: usize,
17342 missing_type: Option<u16>,
17343 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
17344 Self::decode_request(buf).lookup_attr(offset, missing_type)
17345 }
17346}
17347#[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"]
17348#[derive(Debug)]
17349pub struct OpSbOccMaxClearDo<'r> {
17350 request: Request<'r>,
17351}
17352impl<'r> OpSbOccMaxClearDo<'r> {
17353 pub fn new(mut request: Request<'r>) -> Self {
17354 Self::write_header(request.buf_mut());
17355 Self { request: request }
17356 }
17357 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
17358 Self::write_header(buf);
17359 PushDevlink::new(buf)
17360 }
17361 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
17362 PushDevlink::new(self.request.buf_mut())
17363 }
17364 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
17365 PushDevlink::new(self.request.buf)
17366 }
17367 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
17368 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
17369 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
17370 }
17371 fn write_header<Prev: Rec>(prev: &mut Prev) {
17372 let mut header = BuiltinNfgenmsg::new();
17373 header.cmd = 28u8;
17374 header.version = 1u8;
17375 prev.as_rec_mut().extend(header.as_slice());
17376 }
17377}
17378impl NetlinkRequest for OpSbOccMaxClearDo<'_> {
17379 fn protocol(&self) -> Protocol {
17380 Protocol::Generic("devlink".as_bytes())
17381 }
17382 fn flags(&self) -> u16 {
17383 self.request.flags
17384 }
17385 fn payload(&self) -> &[u8] {
17386 self.request.buf()
17387 }
17388 type ReplyType<'buf> = IterableDevlink<'buf>;
17389 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
17390 Self::decode_request(buf)
17391 }
17392 fn lookup(
17393 buf: &[u8],
17394 offset: usize,
17395 missing_type: Option<u16>,
17396 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
17397 Self::decode_request(buf).lookup_attr(offset, missing_type)
17398 }
17399}
17400#[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"]
17401#[derive(Debug)]
17402pub struct OpEswitchGetDo<'r> {
17403 request: Request<'r>,
17404}
17405impl<'r> OpEswitchGetDo<'r> {
17406 pub fn new(mut request: Request<'r>) -> Self {
17407 Self::write_header(request.buf_mut());
17408 Self { request: request }
17409 }
17410 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
17411 Self::write_header(buf);
17412 PushDevlink::new(buf)
17413 }
17414 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
17415 PushDevlink::new(self.request.buf_mut())
17416 }
17417 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
17418 PushDevlink::new(self.request.buf)
17419 }
17420 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
17421 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
17422 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
17423 }
17424 fn write_header<Prev: Rec>(prev: &mut Prev) {
17425 let mut header = BuiltinNfgenmsg::new();
17426 header.cmd = 29u8;
17427 header.version = 1u8;
17428 prev.as_rec_mut().extend(header.as_slice());
17429 }
17430}
17431impl NetlinkRequest for OpEswitchGetDo<'_> {
17432 fn protocol(&self) -> Protocol {
17433 Protocol::Generic("devlink".as_bytes())
17434 }
17435 fn flags(&self) -> u16 {
17436 self.request.flags
17437 }
17438 fn payload(&self) -> &[u8] {
17439 self.request.buf()
17440 }
17441 type ReplyType<'buf> = IterableDevlink<'buf>;
17442 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
17443 Self::decode_request(buf)
17444 }
17445 fn lookup(
17446 buf: &[u8],
17447 offset: usize,
17448 missing_type: Option<u16>,
17449 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
17450 Self::decode_request(buf).lookup_attr(offset, missing_type)
17451 }
17452}
17453#[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"]
17454#[derive(Debug)]
17455pub struct OpEswitchSetDo<'r> {
17456 request: Request<'r>,
17457}
17458impl<'r> OpEswitchSetDo<'r> {
17459 pub fn new(mut request: Request<'r>) -> Self {
17460 Self::write_header(request.buf_mut());
17461 Self { request: request }
17462 }
17463 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
17464 Self::write_header(buf);
17465 PushDevlink::new(buf)
17466 }
17467 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
17468 PushDevlink::new(self.request.buf_mut())
17469 }
17470 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
17471 PushDevlink::new(self.request.buf)
17472 }
17473 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
17474 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
17475 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
17476 }
17477 fn write_header<Prev: Rec>(prev: &mut Prev) {
17478 let mut header = BuiltinNfgenmsg::new();
17479 header.cmd = 30u8;
17480 header.version = 1u8;
17481 prev.as_rec_mut().extend(header.as_slice());
17482 }
17483}
17484impl NetlinkRequest for OpEswitchSetDo<'_> {
17485 fn protocol(&self) -> Protocol {
17486 Protocol::Generic("devlink".as_bytes())
17487 }
17488 fn flags(&self) -> u16 {
17489 self.request.flags
17490 }
17491 fn payload(&self) -> &[u8] {
17492 self.request.buf()
17493 }
17494 type ReplyType<'buf> = IterableDevlink<'buf>;
17495 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
17496 Self::decode_request(buf)
17497 }
17498 fn lookup(
17499 buf: &[u8],
17500 offset: usize,
17501 missing_type: Option<u16>,
17502 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
17503 Self::decode_request(buf).lookup_attr(offset, missing_type)
17504 }
17505}
17506#[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"]
17507#[derive(Debug)]
17508pub struct OpDpipeTableGetDo<'r> {
17509 request: Request<'r>,
17510}
17511impl<'r> OpDpipeTableGetDo<'r> {
17512 pub fn new(mut request: Request<'r>) -> Self {
17513 Self::write_header(request.buf_mut());
17514 Self { request: request }
17515 }
17516 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
17517 Self::write_header(buf);
17518 PushDevlink::new(buf)
17519 }
17520 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
17521 PushDevlink::new(self.request.buf_mut())
17522 }
17523 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
17524 PushDevlink::new(self.request.buf)
17525 }
17526 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
17527 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
17528 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
17529 }
17530 fn write_header<Prev: Rec>(prev: &mut Prev) {
17531 let mut header = BuiltinNfgenmsg::new();
17532 header.cmd = 31u8;
17533 header.version = 1u8;
17534 prev.as_rec_mut().extend(header.as_slice());
17535 }
17536}
17537impl NetlinkRequest for OpDpipeTableGetDo<'_> {
17538 fn protocol(&self) -> Protocol {
17539 Protocol::Generic("devlink".as_bytes())
17540 }
17541 fn flags(&self) -> u16 {
17542 self.request.flags
17543 }
17544 fn payload(&self) -> &[u8] {
17545 self.request.buf()
17546 }
17547 type ReplyType<'buf> = IterableDevlink<'buf>;
17548 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
17549 Self::decode_request(buf)
17550 }
17551 fn lookup(
17552 buf: &[u8],
17553 offset: usize,
17554 missing_type: Option<u16>,
17555 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
17556 Self::decode_request(buf).lookup_attr(offset, missing_type)
17557 }
17558}
17559#[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"]
17560#[derive(Debug)]
17561pub struct OpDpipeEntriesGetDo<'r> {
17562 request: Request<'r>,
17563}
17564impl<'r> OpDpipeEntriesGetDo<'r> {
17565 pub fn new(mut request: Request<'r>) -> Self {
17566 Self::write_header(request.buf_mut());
17567 Self { request: request }
17568 }
17569 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
17570 Self::write_header(buf);
17571 PushDevlink::new(buf)
17572 }
17573 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
17574 PushDevlink::new(self.request.buf_mut())
17575 }
17576 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
17577 PushDevlink::new(self.request.buf)
17578 }
17579 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
17580 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
17581 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
17582 }
17583 fn write_header<Prev: Rec>(prev: &mut Prev) {
17584 let mut header = BuiltinNfgenmsg::new();
17585 header.cmd = 32u8;
17586 header.version = 1u8;
17587 prev.as_rec_mut().extend(header.as_slice());
17588 }
17589}
17590impl NetlinkRequest for OpDpipeEntriesGetDo<'_> {
17591 fn protocol(&self) -> Protocol {
17592 Protocol::Generic("devlink".as_bytes())
17593 }
17594 fn flags(&self) -> u16 {
17595 self.request.flags
17596 }
17597 fn payload(&self) -> &[u8] {
17598 self.request.buf()
17599 }
17600 type ReplyType<'buf> = IterableDevlink<'buf>;
17601 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
17602 Self::decode_request(buf)
17603 }
17604 fn lookup(
17605 buf: &[u8],
17606 offset: usize,
17607 missing_type: Option<u16>,
17608 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
17609 Self::decode_request(buf).lookup_attr(offset, missing_type)
17610 }
17611}
17612#[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"]
17613#[derive(Debug)]
17614pub struct OpDpipeHeadersGetDo<'r> {
17615 request: Request<'r>,
17616}
17617impl<'r> OpDpipeHeadersGetDo<'r> {
17618 pub fn new(mut request: Request<'r>) -> Self {
17619 Self::write_header(request.buf_mut());
17620 Self { request: request }
17621 }
17622 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
17623 Self::write_header(buf);
17624 PushDevlink::new(buf)
17625 }
17626 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
17627 PushDevlink::new(self.request.buf_mut())
17628 }
17629 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
17630 PushDevlink::new(self.request.buf)
17631 }
17632 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
17633 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
17634 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
17635 }
17636 fn write_header<Prev: Rec>(prev: &mut Prev) {
17637 let mut header = BuiltinNfgenmsg::new();
17638 header.cmd = 33u8;
17639 header.version = 1u8;
17640 prev.as_rec_mut().extend(header.as_slice());
17641 }
17642}
17643impl NetlinkRequest for OpDpipeHeadersGetDo<'_> {
17644 fn protocol(&self) -> Protocol {
17645 Protocol::Generic("devlink".as_bytes())
17646 }
17647 fn flags(&self) -> u16 {
17648 self.request.flags
17649 }
17650 fn payload(&self) -> &[u8] {
17651 self.request.buf()
17652 }
17653 type ReplyType<'buf> = IterableDevlink<'buf>;
17654 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
17655 Self::decode_request(buf)
17656 }
17657 fn lookup(
17658 buf: &[u8],
17659 offset: usize,
17660 missing_type: Option<u16>,
17661 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
17662 Self::decode_request(buf).lookup_attr(offset, missing_type)
17663 }
17664}
17665#[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"]
17666#[derive(Debug)]
17667pub struct OpDpipeTableCountersSetDo<'r> {
17668 request: Request<'r>,
17669}
17670impl<'r> OpDpipeTableCountersSetDo<'r> {
17671 pub fn new(mut request: Request<'r>) -> Self {
17672 Self::write_header(request.buf_mut());
17673 Self { request: request }
17674 }
17675 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
17676 Self::write_header(buf);
17677 PushDevlink::new(buf)
17678 }
17679 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
17680 PushDevlink::new(self.request.buf_mut())
17681 }
17682 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
17683 PushDevlink::new(self.request.buf)
17684 }
17685 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
17686 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
17687 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
17688 }
17689 fn write_header<Prev: Rec>(prev: &mut Prev) {
17690 let mut header = BuiltinNfgenmsg::new();
17691 header.cmd = 34u8;
17692 header.version = 1u8;
17693 prev.as_rec_mut().extend(header.as_slice());
17694 }
17695}
17696impl NetlinkRequest for OpDpipeTableCountersSetDo<'_> {
17697 fn protocol(&self) -> Protocol {
17698 Protocol::Generic("devlink".as_bytes())
17699 }
17700 fn flags(&self) -> u16 {
17701 self.request.flags
17702 }
17703 fn payload(&self) -> &[u8] {
17704 self.request.buf()
17705 }
17706 type ReplyType<'buf> = IterableDevlink<'buf>;
17707 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
17708 Self::decode_request(buf)
17709 }
17710 fn lookup(
17711 buf: &[u8],
17712 offset: usize,
17713 missing_type: Option<u16>,
17714 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
17715 Self::decode_request(buf).lookup_attr(offset, missing_type)
17716 }
17717}
17718#[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"]
17719#[derive(Debug)]
17720pub struct OpResourceSetDo<'r> {
17721 request: Request<'r>,
17722}
17723impl<'r> OpResourceSetDo<'r> {
17724 pub fn new(mut request: Request<'r>) -> Self {
17725 Self::write_header(request.buf_mut());
17726 Self { request: request }
17727 }
17728 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
17729 Self::write_header(buf);
17730 PushDevlink::new(buf)
17731 }
17732 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
17733 PushDevlink::new(self.request.buf_mut())
17734 }
17735 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
17736 PushDevlink::new(self.request.buf)
17737 }
17738 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
17739 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
17740 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
17741 }
17742 fn write_header<Prev: Rec>(prev: &mut Prev) {
17743 let mut header = BuiltinNfgenmsg::new();
17744 header.cmd = 35u8;
17745 header.version = 1u8;
17746 prev.as_rec_mut().extend(header.as_slice());
17747 }
17748}
17749impl NetlinkRequest for OpResourceSetDo<'_> {
17750 fn protocol(&self) -> Protocol {
17751 Protocol::Generic("devlink".as_bytes())
17752 }
17753 fn flags(&self) -> u16 {
17754 self.request.flags
17755 }
17756 fn payload(&self) -> &[u8] {
17757 self.request.buf()
17758 }
17759 type ReplyType<'buf> = IterableDevlink<'buf>;
17760 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
17761 Self::decode_request(buf)
17762 }
17763 fn lookup(
17764 buf: &[u8],
17765 offset: usize,
17766 missing_type: Option<u16>,
17767 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
17768 Self::decode_request(buf).lookup_attr(offset, missing_type)
17769 }
17770}
17771#[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"]
17772#[derive(Debug)]
17773pub struct OpResourceDumpDump<'r> {
17774 request: Request<'r>,
17775}
17776impl<'r> OpResourceDumpDump<'r> {
17777 pub fn new(mut request: Request<'r>) -> Self {
17778 Self::write_header(request.buf_mut());
17779 Self {
17780 request: request.set_dump(),
17781 }
17782 }
17783 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
17784 Self::write_header(buf);
17785 PushDevlink::new(buf)
17786 }
17787 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
17788 PushDevlink::new(self.request.buf_mut())
17789 }
17790 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
17791 PushDevlink::new(self.request.buf)
17792 }
17793 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
17794 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
17795 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
17796 }
17797 fn write_header<Prev: Rec>(prev: &mut Prev) {
17798 let mut header = BuiltinNfgenmsg::new();
17799 header.cmd = 36u8;
17800 header.version = 1u8;
17801 prev.as_rec_mut().extend(header.as_slice());
17802 }
17803}
17804impl NetlinkRequest for OpResourceDumpDump<'_> {
17805 fn protocol(&self) -> Protocol {
17806 Protocol::Generic("devlink".as_bytes())
17807 }
17808 fn flags(&self) -> u16 {
17809 self.request.flags
17810 }
17811 fn payload(&self) -> &[u8] {
17812 self.request.buf()
17813 }
17814 type ReplyType<'buf> = IterableDevlink<'buf>;
17815 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
17816 Self::decode_request(buf)
17817 }
17818 fn lookup(
17819 buf: &[u8],
17820 offset: usize,
17821 missing_type: Option<u16>,
17822 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
17823 Self::decode_request(buf).lookup_attr(offset, missing_type)
17824 }
17825}
17826#[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"]
17827#[derive(Debug)]
17828pub struct OpResourceDumpDo<'r> {
17829 request: Request<'r>,
17830}
17831impl<'r> OpResourceDumpDo<'r> {
17832 pub fn new(mut request: Request<'r>) -> Self {
17833 Self::write_header(request.buf_mut());
17834 Self { request: request }
17835 }
17836 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
17837 Self::write_header(buf);
17838 PushDevlink::new(buf)
17839 }
17840 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
17841 PushDevlink::new(self.request.buf_mut())
17842 }
17843 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
17844 PushDevlink::new(self.request.buf)
17845 }
17846 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
17847 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
17848 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
17849 }
17850 fn write_header<Prev: Rec>(prev: &mut Prev) {
17851 let mut header = BuiltinNfgenmsg::new();
17852 header.cmd = 36u8;
17853 header.version = 1u8;
17854 prev.as_rec_mut().extend(header.as_slice());
17855 }
17856}
17857impl NetlinkRequest for OpResourceDumpDo<'_> {
17858 fn protocol(&self) -> Protocol {
17859 Protocol::Generic("devlink".as_bytes())
17860 }
17861 fn flags(&self) -> u16 {
17862 self.request.flags
17863 }
17864 fn payload(&self) -> &[u8] {
17865 self.request.buf()
17866 }
17867 type ReplyType<'buf> = IterableDevlink<'buf>;
17868 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
17869 Self::decode_request(buf)
17870 }
17871 fn lookup(
17872 buf: &[u8],
17873 offset: usize,
17874 missing_type: Option<u16>,
17875 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
17876 Self::decode_request(buf).lookup_attr(offset, missing_type)
17877 }
17878}
17879#[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"]
17880#[derive(Debug)]
17881pub struct OpReloadDo<'r> {
17882 request: Request<'r>,
17883}
17884impl<'r> OpReloadDo<'r> {
17885 pub fn new(mut request: Request<'r>) -> Self {
17886 Self::write_header(request.buf_mut());
17887 Self { request: request }
17888 }
17889 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
17890 Self::write_header(buf);
17891 PushDevlink::new(buf)
17892 }
17893 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
17894 PushDevlink::new(self.request.buf_mut())
17895 }
17896 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
17897 PushDevlink::new(self.request.buf)
17898 }
17899 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
17900 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
17901 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
17902 }
17903 fn write_header<Prev: Rec>(prev: &mut Prev) {
17904 let mut header = BuiltinNfgenmsg::new();
17905 header.cmd = 37u8;
17906 header.version = 1u8;
17907 prev.as_rec_mut().extend(header.as_slice());
17908 }
17909}
17910impl NetlinkRequest for OpReloadDo<'_> {
17911 fn protocol(&self) -> Protocol {
17912 Protocol::Generic("devlink".as_bytes())
17913 }
17914 fn flags(&self) -> u16 {
17915 self.request.flags
17916 }
17917 fn payload(&self) -> &[u8] {
17918 self.request.buf()
17919 }
17920 type ReplyType<'buf> = IterableDevlink<'buf>;
17921 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
17922 Self::decode_request(buf)
17923 }
17924 fn lookup(
17925 buf: &[u8],
17926 offset: usize,
17927 missing_type: Option<u16>,
17928 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
17929 Self::decode_request(buf).lookup_attr(offset, missing_type)
17930 }
17931}
17932#[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"]
17933#[derive(Debug)]
17934pub struct OpParamGetDump<'r> {
17935 request: Request<'r>,
17936}
17937impl<'r> OpParamGetDump<'r> {
17938 pub fn new(mut request: Request<'r>) -> Self {
17939 Self::write_header(request.buf_mut());
17940 Self {
17941 request: request.set_dump(),
17942 }
17943 }
17944 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
17945 Self::write_header(buf);
17946 PushDevlink::new(buf)
17947 }
17948 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
17949 PushDevlink::new(self.request.buf_mut())
17950 }
17951 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
17952 PushDevlink::new(self.request.buf)
17953 }
17954 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
17955 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
17956 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
17957 }
17958 fn write_header<Prev: Rec>(prev: &mut Prev) {
17959 let mut header = BuiltinNfgenmsg::new();
17960 header.cmd = 38u8;
17961 header.version = 1u8;
17962 prev.as_rec_mut().extend(header.as_slice());
17963 }
17964}
17965impl NetlinkRequest for OpParamGetDump<'_> {
17966 fn protocol(&self) -> Protocol {
17967 Protocol::Generic("devlink".as_bytes())
17968 }
17969 fn flags(&self) -> u16 {
17970 self.request.flags
17971 }
17972 fn payload(&self) -> &[u8] {
17973 self.request.buf()
17974 }
17975 type ReplyType<'buf> = IterableDevlink<'buf>;
17976 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
17977 Self::decode_request(buf)
17978 }
17979 fn lookup(
17980 buf: &[u8],
17981 offset: usize,
17982 missing_type: Option<u16>,
17983 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
17984 Self::decode_request(buf).lookup_attr(offset, missing_type)
17985 }
17986}
17987#[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"]
17988#[derive(Debug)]
17989pub struct OpParamGetDo<'r> {
17990 request: Request<'r>,
17991}
17992impl<'r> OpParamGetDo<'r> {
17993 pub fn new(mut request: Request<'r>) -> Self {
17994 Self::write_header(request.buf_mut());
17995 Self { request: request }
17996 }
17997 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
17998 Self::write_header(buf);
17999 PushDevlink::new(buf)
18000 }
18001 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
18002 PushDevlink::new(self.request.buf_mut())
18003 }
18004 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
18005 PushDevlink::new(self.request.buf)
18006 }
18007 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
18008 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
18009 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
18010 }
18011 fn write_header<Prev: Rec>(prev: &mut Prev) {
18012 let mut header = BuiltinNfgenmsg::new();
18013 header.cmd = 38u8;
18014 header.version = 1u8;
18015 prev.as_rec_mut().extend(header.as_slice());
18016 }
18017}
18018impl NetlinkRequest for OpParamGetDo<'_> {
18019 fn protocol(&self) -> Protocol {
18020 Protocol::Generic("devlink".as_bytes())
18021 }
18022 fn flags(&self) -> u16 {
18023 self.request.flags
18024 }
18025 fn payload(&self) -> &[u8] {
18026 self.request.buf()
18027 }
18028 type ReplyType<'buf> = IterableDevlink<'buf>;
18029 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
18030 Self::decode_request(buf)
18031 }
18032 fn lookup(
18033 buf: &[u8],
18034 offset: usize,
18035 missing_type: Option<u16>,
18036 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
18037 Self::decode_request(buf).lookup_attr(offset, missing_type)
18038 }
18039}
18040#[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"]
18041#[derive(Debug)]
18042pub struct OpParamSetDo<'r> {
18043 request: Request<'r>,
18044}
18045impl<'r> OpParamSetDo<'r> {
18046 pub fn new(mut request: Request<'r>) -> Self {
18047 Self::write_header(request.buf_mut());
18048 Self { request: request }
18049 }
18050 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
18051 Self::write_header(buf);
18052 PushDevlink::new(buf)
18053 }
18054 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
18055 PushDevlink::new(self.request.buf_mut())
18056 }
18057 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
18058 PushDevlink::new(self.request.buf)
18059 }
18060 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
18061 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
18062 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
18063 }
18064 fn write_header<Prev: Rec>(prev: &mut Prev) {
18065 let mut header = BuiltinNfgenmsg::new();
18066 header.cmd = 39u8;
18067 header.version = 1u8;
18068 prev.as_rec_mut().extend(header.as_slice());
18069 }
18070}
18071impl NetlinkRequest for OpParamSetDo<'_> {
18072 fn protocol(&self) -> Protocol {
18073 Protocol::Generic("devlink".as_bytes())
18074 }
18075 fn flags(&self) -> u16 {
18076 self.request.flags
18077 }
18078 fn payload(&self) -> &[u8] {
18079 self.request.buf()
18080 }
18081 type ReplyType<'buf> = IterableDevlink<'buf>;
18082 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
18083 Self::decode_request(buf)
18084 }
18085 fn lookup(
18086 buf: &[u8],
18087 offset: usize,
18088 missing_type: Option<u16>,
18089 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
18090 Self::decode_request(buf).lookup_attr(offset, missing_type)
18091 }
18092}
18093#[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"]
18094#[derive(Debug)]
18095pub struct OpRegionGetDump<'r> {
18096 request: Request<'r>,
18097}
18098impl<'r> OpRegionGetDump<'r> {
18099 pub fn new(mut request: Request<'r>) -> Self {
18100 Self::write_header(request.buf_mut());
18101 Self {
18102 request: request.set_dump(),
18103 }
18104 }
18105 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
18106 Self::write_header(buf);
18107 PushDevlink::new(buf)
18108 }
18109 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
18110 PushDevlink::new(self.request.buf_mut())
18111 }
18112 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
18113 PushDevlink::new(self.request.buf)
18114 }
18115 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
18116 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
18117 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
18118 }
18119 fn write_header<Prev: Rec>(prev: &mut Prev) {
18120 let mut header = BuiltinNfgenmsg::new();
18121 header.cmd = 42u8;
18122 header.version = 1u8;
18123 prev.as_rec_mut().extend(header.as_slice());
18124 }
18125}
18126impl NetlinkRequest for OpRegionGetDump<'_> {
18127 fn protocol(&self) -> Protocol {
18128 Protocol::Generic("devlink".as_bytes())
18129 }
18130 fn flags(&self) -> u16 {
18131 self.request.flags
18132 }
18133 fn payload(&self) -> &[u8] {
18134 self.request.buf()
18135 }
18136 type ReplyType<'buf> = IterableDevlink<'buf>;
18137 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
18138 Self::decode_request(buf)
18139 }
18140 fn lookup(
18141 buf: &[u8],
18142 offset: usize,
18143 missing_type: Option<u16>,
18144 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
18145 Self::decode_request(buf).lookup_attr(offset, missing_type)
18146 }
18147}
18148#[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"]
18149#[derive(Debug)]
18150pub struct OpRegionGetDo<'r> {
18151 request: Request<'r>,
18152}
18153impl<'r> OpRegionGetDo<'r> {
18154 pub fn new(mut request: Request<'r>) -> Self {
18155 Self::write_header(request.buf_mut());
18156 Self { request: request }
18157 }
18158 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
18159 Self::write_header(buf);
18160 PushDevlink::new(buf)
18161 }
18162 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
18163 PushDevlink::new(self.request.buf_mut())
18164 }
18165 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
18166 PushDevlink::new(self.request.buf)
18167 }
18168 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
18169 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
18170 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
18171 }
18172 fn write_header<Prev: Rec>(prev: &mut Prev) {
18173 let mut header = BuiltinNfgenmsg::new();
18174 header.cmd = 42u8;
18175 header.version = 1u8;
18176 prev.as_rec_mut().extend(header.as_slice());
18177 }
18178}
18179impl NetlinkRequest for OpRegionGetDo<'_> {
18180 fn protocol(&self) -> Protocol {
18181 Protocol::Generic("devlink".as_bytes())
18182 }
18183 fn flags(&self) -> u16 {
18184 self.request.flags
18185 }
18186 fn payload(&self) -> &[u8] {
18187 self.request.buf()
18188 }
18189 type ReplyType<'buf> = IterableDevlink<'buf>;
18190 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
18191 Self::decode_request(buf)
18192 }
18193 fn lookup(
18194 buf: &[u8],
18195 offset: usize,
18196 missing_type: Option<u16>,
18197 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
18198 Self::decode_request(buf).lookup_attr(offset, missing_type)
18199 }
18200}
18201#[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"]
18202#[derive(Debug)]
18203pub struct OpRegionNewDo<'r> {
18204 request: Request<'r>,
18205}
18206impl<'r> OpRegionNewDo<'r> {
18207 pub fn new(mut request: Request<'r>) -> Self {
18208 Self::write_header(request.buf_mut());
18209 Self { request: request }
18210 }
18211 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
18212 Self::write_header(buf);
18213 PushDevlink::new(buf)
18214 }
18215 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
18216 PushDevlink::new(self.request.buf_mut())
18217 }
18218 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
18219 PushDevlink::new(self.request.buf)
18220 }
18221 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
18222 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
18223 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
18224 }
18225 fn write_header<Prev: Rec>(prev: &mut Prev) {
18226 let mut header = BuiltinNfgenmsg::new();
18227 header.cmd = 44u8;
18228 header.version = 1u8;
18229 prev.as_rec_mut().extend(header.as_slice());
18230 }
18231}
18232impl NetlinkRequest for OpRegionNewDo<'_> {
18233 fn protocol(&self) -> Protocol {
18234 Protocol::Generic("devlink".as_bytes())
18235 }
18236 fn flags(&self) -> u16 {
18237 self.request.flags
18238 }
18239 fn payload(&self) -> &[u8] {
18240 self.request.buf()
18241 }
18242 type ReplyType<'buf> = IterableDevlink<'buf>;
18243 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
18244 Self::decode_request(buf)
18245 }
18246 fn lookup(
18247 buf: &[u8],
18248 offset: usize,
18249 missing_type: Option<u16>,
18250 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
18251 Self::decode_request(buf).lookup_attr(offset, missing_type)
18252 }
18253}
18254#[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"]
18255#[derive(Debug)]
18256pub struct OpRegionDelDo<'r> {
18257 request: Request<'r>,
18258}
18259impl<'r> OpRegionDelDo<'r> {
18260 pub fn new(mut request: Request<'r>) -> Self {
18261 Self::write_header(request.buf_mut());
18262 Self { request: request }
18263 }
18264 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
18265 Self::write_header(buf);
18266 PushDevlink::new(buf)
18267 }
18268 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
18269 PushDevlink::new(self.request.buf_mut())
18270 }
18271 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
18272 PushDevlink::new(self.request.buf)
18273 }
18274 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
18275 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
18276 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
18277 }
18278 fn write_header<Prev: Rec>(prev: &mut Prev) {
18279 let mut header = BuiltinNfgenmsg::new();
18280 header.cmd = 45u8;
18281 header.version = 1u8;
18282 prev.as_rec_mut().extend(header.as_slice());
18283 }
18284}
18285impl NetlinkRequest for OpRegionDelDo<'_> {
18286 fn protocol(&self) -> Protocol {
18287 Protocol::Generic("devlink".as_bytes())
18288 }
18289 fn flags(&self) -> u16 {
18290 self.request.flags
18291 }
18292 fn payload(&self) -> &[u8] {
18293 self.request.buf()
18294 }
18295 type ReplyType<'buf> = IterableDevlink<'buf>;
18296 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
18297 Self::decode_request(buf)
18298 }
18299 fn lookup(
18300 buf: &[u8],
18301 offset: usize,
18302 missing_type: Option<u16>,
18303 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
18304 Self::decode_request(buf).lookup_attr(offset, missing_type)
18305 }
18306}
18307#[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"]
18308#[derive(Debug)]
18309pub struct OpRegionReadDump<'r> {
18310 request: Request<'r>,
18311}
18312impl<'r> OpRegionReadDump<'r> {
18313 pub fn new(mut request: Request<'r>) -> Self {
18314 Self::write_header(request.buf_mut());
18315 Self {
18316 request: request.set_dump(),
18317 }
18318 }
18319 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
18320 Self::write_header(buf);
18321 PushDevlink::new(buf)
18322 }
18323 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
18324 PushDevlink::new(self.request.buf_mut())
18325 }
18326 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
18327 PushDevlink::new(self.request.buf)
18328 }
18329 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
18330 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
18331 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
18332 }
18333 fn write_header<Prev: Rec>(prev: &mut Prev) {
18334 let mut header = BuiltinNfgenmsg::new();
18335 header.cmd = 46u8;
18336 header.version = 1u8;
18337 prev.as_rec_mut().extend(header.as_slice());
18338 }
18339}
18340impl NetlinkRequest for OpRegionReadDump<'_> {
18341 fn protocol(&self) -> Protocol {
18342 Protocol::Generic("devlink".as_bytes())
18343 }
18344 fn flags(&self) -> u16 {
18345 self.request.flags
18346 }
18347 fn payload(&self) -> &[u8] {
18348 self.request.buf()
18349 }
18350 type ReplyType<'buf> = IterableDevlink<'buf>;
18351 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
18352 Self::decode_request(buf)
18353 }
18354 fn lookup(
18355 buf: &[u8],
18356 offset: usize,
18357 missing_type: Option<u16>,
18358 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
18359 Self::decode_request(buf).lookup_attr(offset, missing_type)
18360 }
18361}
18362#[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"]
18363#[derive(Debug)]
18364pub struct OpPortParamGetDump<'r> {
18365 request: Request<'r>,
18366}
18367impl<'r> OpPortParamGetDump<'r> {
18368 pub fn new(mut request: Request<'r>) -> Self {
18369 Self::write_header(request.buf_mut());
18370 Self {
18371 request: request.set_dump(),
18372 }
18373 }
18374 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
18375 Self::write_header(buf);
18376 PushDevlink::new(buf)
18377 }
18378 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
18379 PushDevlink::new(self.request.buf_mut())
18380 }
18381 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
18382 PushDevlink::new(self.request.buf)
18383 }
18384 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
18385 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
18386 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
18387 }
18388 fn write_header<Prev: Rec>(prev: &mut Prev) {
18389 let mut header = BuiltinNfgenmsg::new();
18390 header.cmd = 47u8;
18391 header.version = 1u8;
18392 prev.as_rec_mut().extend(header.as_slice());
18393 }
18394}
18395impl NetlinkRequest for OpPortParamGetDump<'_> {
18396 fn protocol(&self) -> Protocol {
18397 Protocol::Generic("devlink".as_bytes())
18398 }
18399 fn flags(&self) -> u16 {
18400 self.request.flags
18401 }
18402 fn payload(&self) -> &[u8] {
18403 self.request.buf()
18404 }
18405 type ReplyType<'buf> = IterableDevlink<'buf>;
18406 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
18407 Self::decode_request(buf)
18408 }
18409 fn lookup(
18410 buf: &[u8],
18411 offset: usize,
18412 missing_type: Option<u16>,
18413 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
18414 Self::decode_request(buf).lookup_attr(offset, missing_type)
18415 }
18416}
18417#[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"]
18418#[derive(Debug)]
18419pub struct OpPortParamGetDo<'r> {
18420 request: Request<'r>,
18421}
18422impl<'r> OpPortParamGetDo<'r> {
18423 pub fn new(mut request: Request<'r>) -> Self {
18424 Self::write_header(request.buf_mut());
18425 Self { request: request }
18426 }
18427 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
18428 Self::write_header(buf);
18429 PushDevlink::new(buf)
18430 }
18431 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
18432 PushDevlink::new(self.request.buf_mut())
18433 }
18434 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
18435 PushDevlink::new(self.request.buf)
18436 }
18437 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
18438 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
18439 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
18440 }
18441 fn write_header<Prev: Rec>(prev: &mut Prev) {
18442 let mut header = BuiltinNfgenmsg::new();
18443 header.cmd = 47u8;
18444 header.version = 1u8;
18445 prev.as_rec_mut().extend(header.as_slice());
18446 }
18447}
18448impl NetlinkRequest for OpPortParamGetDo<'_> {
18449 fn protocol(&self) -> Protocol {
18450 Protocol::Generic("devlink".as_bytes())
18451 }
18452 fn flags(&self) -> u16 {
18453 self.request.flags
18454 }
18455 fn payload(&self) -> &[u8] {
18456 self.request.buf()
18457 }
18458 type ReplyType<'buf> = IterableDevlink<'buf>;
18459 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
18460 Self::decode_request(buf)
18461 }
18462 fn lookup(
18463 buf: &[u8],
18464 offset: usize,
18465 missing_type: Option<u16>,
18466 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
18467 Self::decode_request(buf).lookup_attr(offset, missing_type)
18468 }
18469}
18470#[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"]
18471#[derive(Debug)]
18472pub struct OpPortParamSetDo<'r> {
18473 request: Request<'r>,
18474}
18475impl<'r> OpPortParamSetDo<'r> {
18476 pub fn new(mut request: Request<'r>) -> Self {
18477 Self::write_header(request.buf_mut());
18478 Self { request: request }
18479 }
18480 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
18481 Self::write_header(buf);
18482 PushDevlink::new(buf)
18483 }
18484 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
18485 PushDevlink::new(self.request.buf_mut())
18486 }
18487 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
18488 PushDevlink::new(self.request.buf)
18489 }
18490 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
18491 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
18492 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
18493 }
18494 fn write_header<Prev: Rec>(prev: &mut Prev) {
18495 let mut header = BuiltinNfgenmsg::new();
18496 header.cmd = 48u8;
18497 header.version = 1u8;
18498 prev.as_rec_mut().extend(header.as_slice());
18499 }
18500}
18501impl NetlinkRequest for OpPortParamSetDo<'_> {
18502 fn protocol(&self) -> Protocol {
18503 Protocol::Generic("devlink".as_bytes())
18504 }
18505 fn flags(&self) -> u16 {
18506 self.request.flags
18507 }
18508 fn payload(&self) -> &[u8] {
18509 self.request.buf()
18510 }
18511 type ReplyType<'buf> = IterableDevlink<'buf>;
18512 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
18513 Self::decode_request(buf)
18514 }
18515 fn lookup(
18516 buf: &[u8],
18517 offset: usize,
18518 missing_type: Option<u16>,
18519 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
18520 Self::decode_request(buf).lookup_attr(offset, missing_type)
18521 }
18522}
18523#[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"]
18524#[derive(Debug)]
18525pub struct OpInfoGetDump<'r> {
18526 request: Request<'r>,
18527}
18528impl<'r> OpInfoGetDump<'r> {
18529 pub fn new(mut request: Request<'r>) -> Self {
18530 Self::write_header(request.buf_mut());
18531 Self {
18532 request: request.set_dump(),
18533 }
18534 }
18535 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
18536 Self::write_header(buf);
18537 PushDevlink::new(buf)
18538 }
18539 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
18540 PushDevlink::new(self.request.buf_mut())
18541 }
18542 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
18543 PushDevlink::new(self.request.buf)
18544 }
18545 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
18546 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
18547 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
18548 }
18549 fn write_header<Prev: Rec>(prev: &mut Prev) {
18550 let mut header = BuiltinNfgenmsg::new();
18551 header.cmd = 51u8;
18552 header.version = 1u8;
18553 prev.as_rec_mut().extend(header.as_slice());
18554 }
18555}
18556impl NetlinkRequest for OpInfoGetDump<'_> {
18557 fn protocol(&self) -> Protocol {
18558 Protocol::Generic("devlink".as_bytes())
18559 }
18560 fn flags(&self) -> u16 {
18561 self.request.flags
18562 }
18563 fn payload(&self) -> &[u8] {
18564 self.request.buf()
18565 }
18566 type ReplyType<'buf> = IterableDevlink<'buf>;
18567 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
18568 Self::decode_request(buf)
18569 }
18570 fn lookup(
18571 buf: &[u8],
18572 offset: usize,
18573 missing_type: Option<u16>,
18574 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
18575 Self::decode_request(buf).lookup_attr(offset, missing_type)
18576 }
18577}
18578#[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"]
18579#[derive(Debug)]
18580pub struct OpInfoGetDo<'r> {
18581 request: Request<'r>,
18582}
18583impl<'r> OpInfoGetDo<'r> {
18584 pub fn new(mut request: Request<'r>) -> Self {
18585 Self::write_header(request.buf_mut());
18586 Self { request: request }
18587 }
18588 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
18589 Self::write_header(buf);
18590 PushDevlink::new(buf)
18591 }
18592 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
18593 PushDevlink::new(self.request.buf_mut())
18594 }
18595 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
18596 PushDevlink::new(self.request.buf)
18597 }
18598 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
18599 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
18600 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
18601 }
18602 fn write_header<Prev: Rec>(prev: &mut Prev) {
18603 let mut header = BuiltinNfgenmsg::new();
18604 header.cmd = 51u8;
18605 header.version = 1u8;
18606 prev.as_rec_mut().extend(header.as_slice());
18607 }
18608}
18609impl NetlinkRequest for OpInfoGetDo<'_> {
18610 fn protocol(&self) -> Protocol {
18611 Protocol::Generic("devlink".as_bytes())
18612 }
18613 fn flags(&self) -> u16 {
18614 self.request.flags
18615 }
18616 fn payload(&self) -> &[u8] {
18617 self.request.buf()
18618 }
18619 type ReplyType<'buf> = IterableDevlink<'buf>;
18620 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
18621 Self::decode_request(buf)
18622 }
18623 fn lookup(
18624 buf: &[u8],
18625 offset: usize,
18626 missing_type: Option<u16>,
18627 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
18628 Self::decode_request(buf).lookup_attr(offset, missing_type)
18629 }
18630}
18631#[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"]
18632#[derive(Debug)]
18633pub struct OpHealthReporterGetDump<'r> {
18634 request: Request<'r>,
18635}
18636impl<'r> OpHealthReporterGetDump<'r> {
18637 pub fn new(mut request: Request<'r>) -> Self {
18638 Self::write_header(request.buf_mut());
18639 Self {
18640 request: request.set_dump(),
18641 }
18642 }
18643 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
18644 Self::write_header(buf);
18645 PushDevlink::new(buf)
18646 }
18647 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
18648 PushDevlink::new(self.request.buf_mut())
18649 }
18650 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
18651 PushDevlink::new(self.request.buf)
18652 }
18653 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
18654 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
18655 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
18656 }
18657 fn write_header<Prev: Rec>(prev: &mut Prev) {
18658 let mut header = BuiltinNfgenmsg::new();
18659 header.cmd = 52u8;
18660 header.version = 1u8;
18661 prev.as_rec_mut().extend(header.as_slice());
18662 }
18663}
18664impl NetlinkRequest for OpHealthReporterGetDump<'_> {
18665 fn protocol(&self) -> Protocol {
18666 Protocol::Generic("devlink".as_bytes())
18667 }
18668 fn flags(&self) -> u16 {
18669 self.request.flags
18670 }
18671 fn payload(&self) -> &[u8] {
18672 self.request.buf()
18673 }
18674 type ReplyType<'buf> = IterableDevlink<'buf>;
18675 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
18676 Self::decode_request(buf)
18677 }
18678 fn lookup(
18679 buf: &[u8],
18680 offset: usize,
18681 missing_type: Option<u16>,
18682 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
18683 Self::decode_request(buf).lookup_attr(offset, missing_type)
18684 }
18685}
18686#[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"]
18687#[derive(Debug)]
18688pub struct OpHealthReporterGetDo<'r> {
18689 request: Request<'r>,
18690}
18691impl<'r> OpHealthReporterGetDo<'r> {
18692 pub fn new(mut request: Request<'r>) -> Self {
18693 Self::write_header(request.buf_mut());
18694 Self { request: request }
18695 }
18696 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
18697 Self::write_header(buf);
18698 PushDevlink::new(buf)
18699 }
18700 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
18701 PushDevlink::new(self.request.buf_mut())
18702 }
18703 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
18704 PushDevlink::new(self.request.buf)
18705 }
18706 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
18707 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
18708 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
18709 }
18710 fn write_header<Prev: Rec>(prev: &mut Prev) {
18711 let mut header = BuiltinNfgenmsg::new();
18712 header.cmd = 52u8;
18713 header.version = 1u8;
18714 prev.as_rec_mut().extend(header.as_slice());
18715 }
18716}
18717impl NetlinkRequest for OpHealthReporterGetDo<'_> {
18718 fn protocol(&self) -> Protocol {
18719 Protocol::Generic("devlink".as_bytes())
18720 }
18721 fn flags(&self) -> u16 {
18722 self.request.flags
18723 }
18724 fn payload(&self) -> &[u8] {
18725 self.request.buf()
18726 }
18727 type ReplyType<'buf> = IterableDevlink<'buf>;
18728 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
18729 Self::decode_request(buf)
18730 }
18731 fn lookup(
18732 buf: &[u8],
18733 offset: usize,
18734 missing_type: Option<u16>,
18735 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
18736 Self::decode_request(buf).lookup_attr(offset, missing_type)
18737 }
18738}
18739#[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"]
18740#[derive(Debug)]
18741pub struct OpHealthReporterSetDo<'r> {
18742 request: Request<'r>,
18743}
18744impl<'r> OpHealthReporterSetDo<'r> {
18745 pub fn new(mut request: Request<'r>) -> Self {
18746 Self::write_header(request.buf_mut());
18747 Self { request: request }
18748 }
18749 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
18750 Self::write_header(buf);
18751 PushDevlink::new(buf)
18752 }
18753 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
18754 PushDevlink::new(self.request.buf_mut())
18755 }
18756 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
18757 PushDevlink::new(self.request.buf)
18758 }
18759 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
18760 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
18761 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
18762 }
18763 fn write_header<Prev: Rec>(prev: &mut Prev) {
18764 let mut header = BuiltinNfgenmsg::new();
18765 header.cmd = 53u8;
18766 header.version = 1u8;
18767 prev.as_rec_mut().extend(header.as_slice());
18768 }
18769}
18770impl NetlinkRequest for OpHealthReporterSetDo<'_> {
18771 fn protocol(&self) -> Protocol {
18772 Protocol::Generic("devlink".as_bytes())
18773 }
18774 fn flags(&self) -> u16 {
18775 self.request.flags
18776 }
18777 fn payload(&self) -> &[u8] {
18778 self.request.buf()
18779 }
18780 type ReplyType<'buf> = IterableDevlink<'buf>;
18781 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
18782 Self::decode_request(buf)
18783 }
18784 fn lookup(
18785 buf: &[u8],
18786 offset: usize,
18787 missing_type: Option<u16>,
18788 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
18789 Self::decode_request(buf).lookup_attr(offset, missing_type)
18790 }
18791}
18792#[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"]
18793#[derive(Debug)]
18794pub struct OpHealthReporterRecoverDo<'r> {
18795 request: Request<'r>,
18796}
18797impl<'r> OpHealthReporterRecoverDo<'r> {
18798 pub fn new(mut request: Request<'r>) -> Self {
18799 Self::write_header(request.buf_mut());
18800 Self { request: request }
18801 }
18802 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
18803 Self::write_header(buf);
18804 PushDevlink::new(buf)
18805 }
18806 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
18807 PushDevlink::new(self.request.buf_mut())
18808 }
18809 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
18810 PushDevlink::new(self.request.buf)
18811 }
18812 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
18813 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
18814 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
18815 }
18816 fn write_header<Prev: Rec>(prev: &mut Prev) {
18817 let mut header = BuiltinNfgenmsg::new();
18818 header.cmd = 54u8;
18819 header.version = 1u8;
18820 prev.as_rec_mut().extend(header.as_slice());
18821 }
18822}
18823impl NetlinkRequest for OpHealthReporterRecoverDo<'_> {
18824 fn protocol(&self) -> Protocol {
18825 Protocol::Generic("devlink".as_bytes())
18826 }
18827 fn flags(&self) -> u16 {
18828 self.request.flags
18829 }
18830 fn payload(&self) -> &[u8] {
18831 self.request.buf()
18832 }
18833 type ReplyType<'buf> = IterableDevlink<'buf>;
18834 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
18835 Self::decode_request(buf)
18836 }
18837 fn lookup(
18838 buf: &[u8],
18839 offset: usize,
18840 missing_type: Option<u16>,
18841 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
18842 Self::decode_request(buf).lookup_attr(offset, missing_type)
18843 }
18844}
18845#[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"]
18846#[derive(Debug)]
18847pub struct OpHealthReporterDiagnoseDo<'r> {
18848 request: Request<'r>,
18849}
18850impl<'r> OpHealthReporterDiagnoseDo<'r> {
18851 pub fn new(mut request: Request<'r>) -> Self {
18852 Self::write_header(request.buf_mut());
18853 Self { request: request }
18854 }
18855 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
18856 Self::write_header(buf);
18857 PushDevlink::new(buf)
18858 }
18859 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
18860 PushDevlink::new(self.request.buf_mut())
18861 }
18862 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
18863 PushDevlink::new(self.request.buf)
18864 }
18865 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
18866 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
18867 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
18868 }
18869 fn write_header<Prev: Rec>(prev: &mut Prev) {
18870 let mut header = BuiltinNfgenmsg::new();
18871 header.cmd = 55u8;
18872 header.version = 1u8;
18873 prev.as_rec_mut().extend(header.as_slice());
18874 }
18875}
18876impl NetlinkRequest for OpHealthReporterDiagnoseDo<'_> {
18877 fn protocol(&self) -> Protocol {
18878 Protocol::Generic("devlink".as_bytes())
18879 }
18880 fn flags(&self) -> u16 {
18881 self.request.flags
18882 }
18883 fn payload(&self) -> &[u8] {
18884 self.request.buf()
18885 }
18886 type ReplyType<'buf> = IterableDevlink<'buf>;
18887 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
18888 Self::decode_request(buf)
18889 }
18890 fn lookup(
18891 buf: &[u8],
18892 offset: usize,
18893 missing_type: Option<u16>,
18894 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
18895 Self::decode_request(buf).lookup_attr(offset, missing_type)
18896 }
18897}
18898#[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"]
18899#[derive(Debug)]
18900pub struct OpHealthReporterDumpGetDump<'r> {
18901 request: Request<'r>,
18902}
18903impl<'r> OpHealthReporterDumpGetDump<'r> {
18904 pub fn new(mut request: Request<'r>) -> Self {
18905 Self::write_header(request.buf_mut());
18906 Self {
18907 request: request.set_dump(),
18908 }
18909 }
18910 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
18911 Self::write_header(buf);
18912 PushDevlink::new(buf)
18913 }
18914 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
18915 PushDevlink::new(self.request.buf_mut())
18916 }
18917 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
18918 PushDevlink::new(self.request.buf)
18919 }
18920 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
18921 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
18922 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
18923 }
18924 fn write_header<Prev: Rec>(prev: &mut Prev) {
18925 let mut header = BuiltinNfgenmsg::new();
18926 header.cmd = 56u8;
18927 header.version = 1u8;
18928 prev.as_rec_mut().extend(header.as_slice());
18929 }
18930}
18931impl NetlinkRequest for OpHealthReporterDumpGetDump<'_> {
18932 fn protocol(&self) -> Protocol {
18933 Protocol::Generic("devlink".as_bytes())
18934 }
18935 fn flags(&self) -> u16 {
18936 self.request.flags
18937 }
18938 fn payload(&self) -> &[u8] {
18939 self.request.buf()
18940 }
18941 type ReplyType<'buf> = IterableDevlink<'buf>;
18942 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
18943 Self::decode_request(buf)
18944 }
18945 fn lookup(
18946 buf: &[u8],
18947 offset: usize,
18948 missing_type: Option<u16>,
18949 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
18950 Self::decode_request(buf).lookup_attr(offset, missing_type)
18951 }
18952}
18953#[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"]
18954#[derive(Debug)]
18955pub struct OpHealthReporterDumpClearDo<'r> {
18956 request: Request<'r>,
18957}
18958impl<'r> OpHealthReporterDumpClearDo<'r> {
18959 pub fn new(mut request: Request<'r>) -> Self {
18960 Self::write_header(request.buf_mut());
18961 Self { request: request }
18962 }
18963 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
18964 Self::write_header(buf);
18965 PushDevlink::new(buf)
18966 }
18967 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
18968 PushDevlink::new(self.request.buf_mut())
18969 }
18970 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
18971 PushDevlink::new(self.request.buf)
18972 }
18973 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
18974 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
18975 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
18976 }
18977 fn write_header<Prev: Rec>(prev: &mut Prev) {
18978 let mut header = BuiltinNfgenmsg::new();
18979 header.cmd = 57u8;
18980 header.version = 1u8;
18981 prev.as_rec_mut().extend(header.as_slice());
18982 }
18983}
18984impl NetlinkRequest for OpHealthReporterDumpClearDo<'_> {
18985 fn protocol(&self) -> Protocol {
18986 Protocol::Generic("devlink".as_bytes())
18987 }
18988 fn flags(&self) -> u16 {
18989 self.request.flags
18990 }
18991 fn payload(&self) -> &[u8] {
18992 self.request.buf()
18993 }
18994 type ReplyType<'buf> = IterableDevlink<'buf>;
18995 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
18996 Self::decode_request(buf)
18997 }
18998 fn lookup(
18999 buf: &[u8],
19000 offset: usize,
19001 missing_type: Option<u16>,
19002 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
19003 Self::decode_request(buf).lookup_attr(offset, missing_type)
19004 }
19005}
19006#[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"]
19007#[derive(Debug)]
19008pub struct OpFlashUpdateDo<'r> {
19009 request: Request<'r>,
19010}
19011impl<'r> OpFlashUpdateDo<'r> {
19012 pub fn new(mut request: Request<'r>) -> Self {
19013 Self::write_header(request.buf_mut());
19014 Self { request: request }
19015 }
19016 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
19017 Self::write_header(buf);
19018 PushDevlink::new(buf)
19019 }
19020 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
19021 PushDevlink::new(self.request.buf_mut())
19022 }
19023 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
19024 PushDevlink::new(self.request.buf)
19025 }
19026 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
19027 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
19028 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
19029 }
19030 fn write_header<Prev: Rec>(prev: &mut Prev) {
19031 let mut header = BuiltinNfgenmsg::new();
19032 header.cmd = 58u8;
19033 header.version = 1u8;
19034 prev.as_rec_mut().extend(header.as_slice());
19035 }
19036}
19037impl NetlinkRequest for OpFlashUpdateDo<'_> {
19038 fn protocol(&self) -> Protocol {
19039 Protocol::Generic("devlink".as_bytes())
19040 }
19041 fn flags(&self) -> u16 {
19042 self.request.flags
19043 }
19044 fn payload(&self) -> &[u8] {
19045 self.request.buf()
19046 }
19047 type ReplyType<'buf> = IterableDevlink<'buf>;
19048 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
19049 Self::decode_request(buf)
19050 }
19051 fn lookup(
19052 buf: &[u8],
19053 offset: usize,
19054 missing_type: Option<u16>,
19055 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
19056 Self::decode_request(buf).lookup_attr(offset, missing_type)
19057 }
19058}
19059#[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"]
19060#[derive(Debug)]
19061pub struct OpTrapGetDump<'r> {
19062 request: Request<'r>,
19063}
19064impl<'r> OpTrapGetDump<'r> {
19065 pub fn new(mut request: Request<'r>) -> Self {
19066 Self::write_header(request.buf_mut());
19067 Self {
19068 request: request.set_dump(),
19069 }
19070 }
19071 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
19072 Self::write_header(buf);
19073 PushDevlink::new(buf)
19074 }
19075 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
19076 PushDevlink::new(self.request.buf_mut())
19077 }
19078 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
19079 PushDevlink::new(self.request.buf)
19080 }
19081 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
19082 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
19083 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
19084 }
19085 fn write_header<Prev: Rec>(prev: &mut Prev) {
19086 let mut header = BuiltinNfgenmsg::new();
19087 header.cmd = 61u8;
19088 header.version = 1u8;
19089 prev.as_rec_mut().extend(header.as_slice());
19090 }
19091}
19092impl NetlinkRequest for OpTrapGetDump<'_> {
19093 fn protocol(&self) -> Protocol {
19094 Protocol::Generic("devlink".as_bytes())
19095 }
19096 fn flags(&self) -> u16 {
19097 self.request.flags
19098 }
19099 fn payload(&self) -> &[u8] {
19100 self.request.buf()
19101 }
19102 type ReplyType<'buf> = IterableDevlink<'buf>;
19103 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
19104 Self::decode_request(buf)
19105 }
19106 fn lookup(
19107 buf: &[u8],
19108 offset: usize,
19109 missing_type: Option<u16>,
19110 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
19111 Self::decode_request(buf).lookup_attr(offset, missing_type)
19112 }
19113}
19114#[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"]
19115#[derive(Debug)]
19116pub struct OpTrapGetDo<'r> {
19117 request: Request<'r>,
19118}
19119impl<'r> OpTrapGetDo<'r> {
19120 pub fn new(mut request: Request<'r>) -> Self {
19121 Self::write_header(request.buf_mut());
19122 Self { request: request }
19123 }
19124 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
19125 Self::write_header(buf);
19126 PushDevlink::new(buf)
19127 }
19128 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
19129 PushDevlink::new(self.request.buf_mut())
19130 }
19131 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
19132 PushDevlink::new(self.request.buf)
19133 }
19134 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
19135 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
19136 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
19137 }
19138 fn write_header<Prev: Rec>(prev: &mut Prev) {
19139 let mut header = BuiltinNfgenmsg::new();
19140 header.cmd = 61u8;
19141 header.version = 1u8;
19142 prev.as_rec_mut().extend(header.as_slice());
19143 }
19144}
19145impl NetlinkRequest for OpTrapGetDo<'_> {
19146 fn protocol(&self) -> Protocol {
19147 Protocol::Generic("devlink".as_bytes())
19148 }
19149 fn flags(&self) -> u16 {
19150 self.request.flags
19151 }
19152 fn payload(&self) -> &[u8] {
19153 self.request.buf()
19154 }
19155 type ReplyType<'buf> = IterableDevlink<'buf>;
19156 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
19157 Self::decode_request(buf)
19158 }
19159 fn lookup(
19160 buf: &[u8],
19161 offset: usize,
19162 missing_type: Option<u16>,
19163 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
19164 Self::decode_request(buf).lookup_attr(offset, missing_type)
19165 }
19166}
19167#[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"]
19168#[derive(Debug)]
19169pub struct OpTrapSetDo<'r> {
19170 request: Request<'r>,
19171}
19172impl<'r> OpTrapSetDo<'r> {
19173 pub fn new(mut request: Request<'r>) -> Self {
19174 Self::write_header(request.buf_mut());
19175 Self { request: request }
19176 }
19177 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
19178 Self::write_header(buf);
19179 PushDevlink::new(buf)
19180 }
19181 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
19182 PushDevlink::new(self.request.buf_mut())
19183 }
19184 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
19185 PushDevlink::new(self.request.buf)
19186 }
19187 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
19188 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
19189 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
19190 }
19191 fn write_header<Prev: Rec>(prev: &mut Prev) {
19192 let mut header = BuiltinNfgenmsg::new();
19193 header.cmd = 62u8;
19194 header.version = 1u8;
19195 prev.as_rec_mut().extend(header.as_slice());
19196 }
19197}
19198impl NetlinkRequest for OpTrapSetDo<'_> {
19199 fn protocol(&self) -> Protocol {
19200 Protocol::Generic("devlink".as_bytes())
19201 }
19202 fn flags(&self) -> u16 {
19203 self.request.flags
19204 }
19205 fn payload(&self) -> &[u8] {
19206 self.request.buf()
19207 }
19208 type ReplyType<'buf> = IterableDevlink<'buf>;
19209 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
19210 Self::decode_request(buf)
19211 }
19212 fn lookup(
19213 buf: &[u8],
19214 offset: usize,
19215 missing_type: Option<u16>,
19216 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
19217 Self::decode_request(buf).lookup_attr(offset, missing_type)
19218 }
19219}
19220#[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"]
19221#[derive(Debug)]
19222pub struct OpTrapGroupGetDump<'r> {
19223 request: Request<'r>,
19224}
19225impl<'r> OpTrapGroupGetDump<'r> {
19226 pub fn new(mut request: Request<'r>) -> Self {
19227 Self::write_header(request.buf_mut());
19228 Self {
19229 request: request.set_dump(),
19230 }
19231 }
19232 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
19233 Self::write_header(buf);
19234 PushDevlink::new(buf)
19235 }
19236 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
19237 PushDevlink::new(self.request.buf_mut())
19238 }
19239 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
19240 PushDevlink::new(self.request.buf)
19241 }
19242 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
19243 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
19244 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
19245 }
19246 fn write_header<Prev: Rec>(prev: &mut Prev) {
19247 let mut header = BuiltinNfgenmsg::new();
19248 header.cmd = 65u8;
19249 header.version = 1u8;
19250 prev.as_rec_mut().extend(header.as_slice());
19251 }
19252}
19253impl NetlinkRequest for OpTrapGroupGetDump<'_> {
19254 fn protocol(&self) -> Protocol {
19255 Protocol::Generic("devlink".as_bytes())
19256 }
19257 fn flags(&self) -> u16 {
19258 self.request.flags
19259 }
19260 fn payload(&self) -> &[u8] {
19261 self.request.buf()
19262 }
19263 type ReplyType<'buf> = IterableDevlink<'buf>;
19264 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
19265 Self::decode_request(buf)
19266 }
19267 fn lookup(
19268 buf: &[u8],
19269 offset: usize,
19270 missing_type: Option<u16>,
19271 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
19272 Self::decode_request(buf).lookup_attr(offset, missing_type)
19273 }
19274}
19275#[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"]
19276#[derive(Debug)]
19277pub struct OpTrapGroupGetDo<'r> {
19278 request: Request<'r>,
19279}
19280impl<'r> OpTrapGroupGetDo<'r> {
19281 pub fn new(mut request: Request<'r>) -> Self {
19282 Self::write_header(request.buf_mut());
19283 Self { request: request }
19284 }
19285 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
19286 Self::write_header(buf);
19287 PushDevlink::new(buf)
19288 }
19289 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
19290 PushDevlink::new(self.request.buf_mut())
19291 }
19292 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
19293 PushDevlink::new(self.request.buf)
19294 }
19295 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
19296 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
19297 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
19298 }
19299 fn write_header<Prev: Rec>(prev: &mut Prev) {
19300 let mut header = BuiltinNfgenmsg::new();
19301 header.cmd = 65u8;
19302 header.version = 1u8;
19303 prev.as_rec_mut().extend(header.as_slice());
19304 }
19305}
19306impl NetlinkRequest for OpTrapGroupGetDo<'_> {
19307 fn protocol(&self) -> Protocol {
19308 Protocol::Generic("devlink".as_bytes())
19309 }
19310 fn flags(&self) -> u16 {
19311 self.request.flags
19312 }
19313 fn payload(&self) -> &[u8] {
19314 self.request.buf()
19315 }
19316 type ReplyType<'buf> = IterableDevlink<'buf>;
19317 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
19318 Self::decode_request(buf)
19319 }
19320 fn lookup(
19321 buf: &[u8],
19322 offset: usize,
19323 missing_type: Option<u16>,
19324 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
19325 Self::decode_request(buf).lookup_attr(offset, missing_type)
19326 }
19327}
19328#[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"]
19329#[derive(Debug)]
19330pub struct OpTrapGroupSetDo<'r> {
19331 request: Request<'r>,
19332}
19333impl<'r> OpTrapGroupSetDo<'r> {
19334 pub fn new(mut request: Request<'r>) -> Self {
19335 Self::write_header(request.buf_mut());
19336 Self { request: request }
19337 }
19338 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
19339 Self::write_header(buf);
19340 PushDevlink::new(buf)
19341 }
19342 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
19343 PushDevlink::new(self.request.buf_mut())
19344 }
19345 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
19346 PushDevlink::new(self.request.buf)
19347 }
19348 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
19349 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
19350 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
19351 }
19352 fn write_header<Prev: Rec>(prev: &mut Prev) {
19353 let mut header = BuiltinNfgenmsg::new();
19354 header.cmd = 66u8;
19355 header.version = 1u8;
19356 prev.as_rec_mut().extend(header.as_slice());
19357 }
19358}
19359impl NetlinkRequest for OpTrapGroupSetDo<'_> {
19360 fn protocol(&self) -> Protocol {
19361 Protocol::Generic("devlink".as_bytes())
19362 }
19363 fn flags(&self) -> u16 {
19364 self.request.flags
19365 }
19366 fn payload(&self) -> &[u8] {
19367 self.request.buf()
19368 }
19369 type ReplyType<'buf> = IterableDevlink<'buf>;
19370 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
19371 Self::decode_request(buf)
19372 }
19373 fn lookup(
19374 buf: &[u8],
19375 offset: usize,
19376 missing_type: Option<u16>,
19377 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
19378 Self::decode_request(buf).lookup_attr(offset, missing_type)
19379 }
19380}
19381#[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"]
19382#[derive(Debug)]
19383pub struct OpTrapPolicerGetDump<'r> {
19384 request: Request<'r>,
19385}
19386impl<'r> OpTrapPolicerGetDump<'r> {
19387 pub fn new(mut request: Request<'r>) -> Self {
19388 Self::write_header(request.buf_mut());
19389 Self {
19390 request: request.set_dump(),
19391 }
19392 }
19393 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
19394 Self::write_header(buf);
19395 PushDevlink::new(buf)
19396 }
19397 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
19398 PushDevlink::new(self.request.buf_mut())
19399 }
19400 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
19401 PushDevlink::new(self.request.buf)
19402 }
19403 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
19404 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
19405 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
19406 }
19407 fn write_header<Prev: Rec>(prev: &mut Prev) {
19408 let mut header = BuiltinNfgenmsg::new();
19409 header.cmd = 69u8;
19410 header.version = 1u8;
19411 prev.as_rec_mut().extend(header.as_slice());
19412 }
19413}
19414impl NetlinkRequest for OpTrapPolicerGetDump<'_> {
19415 fn protocol(&self) -> Protocol {
19416 Protocol::Generic("devlink".as_bytes())
19417 }
19418 fn flags(&self) -> u16 {
19419 self.request.flags
19420 }
19421 fn payload(&self) -> &[u8] {
19422 self.request.buf()
19423 }
19424 type ReplyType<'buf> = IterableDevlink<'buf>;
19425 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
19426 Self::decode_request(buf)
19427 }
19428 fn lookup(
19429 buf: &[u8],
19430 offset: usize,
19431 missing_type: Option<u16>,
19432 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
19433 Self::decode_request(buf).lookup_attr(offset, missing_type)
19434 }
19435}
19436#[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"]
19437#[derive(Debug)]
19438pub struct OpTrapPolicerGetDo<'r> {
19439 request: Request<'r>,
19440}
19441impl<'r> OpTrapPolicerGetDo<'r> {
19442 pub fn new(mut request: Request<'r>) -> Self {
19443 Self::write_header(request.buf_mut());
19444 Self { request: request }
19445 }
19446 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
19447 Self::write_header(buf);
19448 PushDevlink::new(buf)
19449 }
19450 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
19451 PushDevlink::new(self.request.buf_mut())
19452 }
19453 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
19454 PushDevlink::new(self.request.buf)
19455 }
19456 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
19457 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
19458 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
19459 }
19460 fn write_header<Prev: Rec>(prev: &mut Prev) {
19461 let mut header = BuiltinNfgenmsg::new();
19462 header.cmd = 69u8;
19463 header.version = 1u8;
19464 prev.as_rec_mut().extend(header.as_slice());
19465 }
19466}
19467impl NetlinkRequest for OpTrapPolicerGetDo<'_> {
19468 fn protocol(&self) -> Protocol {
19469 Protocol::Generic("devlink".as_bytes())
19470 }
19471 fn flags(&self) -> u16 {
19472 self.request.flags
19473 }
19474 fn payload(&self) -> &[u8] {
19475 self.request.buf()
19476 }
19477 type ReplyType<'buf> = IterableDevlink<'buf>;
19478 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
19479 Self::decode_request(buf)
19480 }
19481 fn lookup(
19482 buf: &[u8],
19483 offset: usize,
19484 missing_type: Option<u16>,
19485 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
19486 Self::decode_request(buf).lookup_attr(offset, missing_type)
19487 }
19488}
19489#[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"]
19490#[derive(Debug)]
19491pub struct OpTrapPolicerSetDo<'r> {
19492 request: Request<'r>,
19493}
19494impl<'r> OpTrapPolicerSetDo<'r> {
19495 pub fn new(mut request: Request<'r>) -> Self {
19496 Self::write_header(request.buf_mut());
19497 Self { request: request }
19498 }
19499 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
19500 Self::write_header(buf);
19501 PushDevlink::new(buf)
19502 }
19503 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
19504 PushDevlink::new(self.request.buf_mut())
19505 }
19506 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
19507 PushDevlink::new(self.request.buf)
19508 }
19509 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
19510 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
19511 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
19512 }
19513 fn write_header<Prev: Rec>(prev: &mut Prev) {
19514 let mut header = BuiltinNfgenmsg::new();
19515 header.cmd = 70u8;
19516 header.version = 1u8;
19517 prev.as_rec_mut().extend(header.as_slice());
19518 }
19519}
19520impl NetlinkRequest for OpTrapPolicerSetDo<'_> {
19521 fn protocol(&self) -> Protocol {
19522 Protocol::Generic("devlink".as_bytes())
19523 }
19524 fn flags(&self) -> u16 {
19525 self.request.flags
19526 }
19527 fn payload(&self) -> &[u8] {
19528 self.request.buf()
19529 }
19530 type ReplyType<'buf> = IterableDevlink<'buf>;
19531 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
19532 Self::decode_request(buf)
19533 }
19534 fn lookup(
19535 buf: &[u8],
19536 offset: usize,
19537 missing_type: Option<u16>,
19538 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
19539 Self::decode_request(buf).lookup_attr(offset, missing_type)
19540 }
19541}
19542#[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"]
19543#[derive(Debug)]
19544pub struct OpHealthReporterTestDo<'r> {
19545 request: Request<'r>,
19546}
19547impl<'r> OpHealthReporterTestDo<'r> {
19548 pub fn new(mut request: Request<'r>) -> Self {
19549 Self::write_header(request.buf_mut());
19550 Self { request: request }
19551 }
19552 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
19553 Self::write_header(buf);
19554 PushDevlink::new(buf)
19555 }
19556 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
19557 PushDevlink::new(self.request.buf_mut())
19558 }
19559 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
19560 PushDevlink::new(self.request.buf)
19561 }
19562 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
19563 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
19564 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
19565 }
19566 fn write_header<Prev: Rec>(prev: &mut Prev) {
19567 let mut header = BuiltinNfgenmsg::new();
19568 header.cmd = 73u8;
19569 header.version = 1u8;
19570 prev.as_rec_mut().extend(header.as_slice());
19571 }
19572}
19573impl NetlinkRequest for OpHealthReporterTestDo<'_> {
19574 fn protocol(&self) -> Protocol {
19575 Protocol::Generic("devlink".as_bytes())
19576 }
19577 fn flags(&self) -> u16 {
19578 self.request.flags
19579 }
19580 fn payload(&self) -> &[u8] {
19581 self.request.buf()
19582 }
19583 type ReplyType<'buf> = IterableDevlink<'buf>;
19584 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
19585 Self::decode_request(buf)
19586 }
19587 fn lookup(
19588 buf: &[u8],
19589 offset: usize,
19590 missing_type: Option<u16>,
19591 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
19592 Self::decode_request(buf).lookup_attr(offset, missing_type)
19593 }
19594}
19595#[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"]
19596#[derive(Debug)]
19597pub struct OpRateGetDump<'r> {
19598 request: Request<'r>,
19599}
19600impl<'r> OpRateGetDump<'r> {
19601 pub fn new(mut request: Request<'r>) -> Self {
19602 Self::write_header(request.buf_mut());
19603 Self {
19604 request: request.set_dump(),
19605 }
19606 }
19607 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
19608 Self::write_header(buf);
19609 PushDevlink::new(buf)
19610 }
19611 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
19612 PushDevlink::new(self.request.buf_mut())
19613 }
19614 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
19615 PushDevlink::new(self.request.buf)
19616 }
19617 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
19618 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
19619 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
19620 }
19621 fn write_header<Prev: Rec>(prev: &mut Prev) {
19622 let mut header = BuiltinNfgenmsg::new();
19623 header.cmd = 74u8;
19624 header.version = 1u8;
19625 prev.as_rec_mut().extend(header.as_slice());
19626 }
19627}
19628impl NetlinkRequest for OpRateGetDump<'_> {
19629 fn protocol(&self) -> Protocol {
19630 Protocol::Generic("devlink".as_bytes())
19631 }
19632 fn flags(&self) -> u16 {
19633 self.request.flags
19634 }
19635 fn payload(&self) -> &[u8] {
19636 self.request.buf()
19637 }
19638 type ReplyType<'buf> = IterableDevlink<'buf>;
19639 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
19640 Self::decode_request(buf)
19641 }
19642 fn lookup(
19643 buf: &[u8],
19644 offset: usize,
19645 missing_type: Option<u16>,
19646 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
19647 Self::decode_request(buf).lookup_attr(offset, missing_type)
19648 }
19649}
19650#[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"]
19651#[derive(Debug)]
19652pub struct OpRateGetDo<'r> {
19653 request: Request<'r>,
19654}
19655impl<'r> OpRateGetDo<'r> {
19656 pub fn new(mut request: Request<'r>) -> Self {
19657 Self::write_header(request.buf_mut());
19658 Self { request: request }
19659 }
19660 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
19661 Self::write_header(buf);
19662 PushDevlink::new(buf)
19663 }
19664 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
19665 PushDevlink::new(self.request.buf_mut())
19666 }
19667 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
19668 PushDevlink::new(self.request.buf)
19669 }
19670 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
19671 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
19672 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
19673 }
19674 fn write_header<Prev: Rec>(prev: &mut Prev) {
19675 let mut header = BuiltinNfgenmsg::new();
19676 header.cmd = 74u8;
19677 header.version = 1u8;
19678 prev.as_rec_mut().extend(header.as_slice());
19679 }
19680}
19681impl NetlinkRequest for OpRateGetDo<'_> {
19682 fn protocol(&self) -> Protocol {
19683 Protocol::Generic("devlink".as_bytes())
19684 }
19685 fn flags(&self) -> u16 {
19686 self.request.flags
19687 }
19688 fn payload(&self) -> &[u8] {
19689 self.request.buf()
19690 }
19691 type ReplyType<'buf> = IterableDevlink<'buf>;
19692 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
19693 Self::decode_request(buf)
19694 }
19695 fn lookup(
19696 buf: &[u8],
19697 offset: usize,
19698 missing_type: Option<u16>,
19699 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
19700 Self::decode_request(buf).lookup_attr(offset, missing_type)
19701 }
19702}
19703#[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"]
19704#[derive(Debug)]
19705pub struct OpRateSetDo<'r> {
19706 request: Request<'r>,
19707}
19708impl<'r> OpRateSetDo<'r> {
19709 pub fn new(mut request: Request<'r>) -> Self {
19710 Self::write_header(request.buf_mut());
19711 Self { request: request }
19712 }
19713 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
19714 Self::write_header(buf);
19715 PushDevlink::new(buf)
19716 }
19717 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
19718 PushDevlink::new(self.request.buf_mut())
19719 }
19720 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
19721 PushDevlink::new(self.request.buf)
19722 }
19723 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
19724 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
19725 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
19726 }
19727 fn write_header<Prev: Rec>(prev: &mut Prev) {
19728 let mut header = BuiltinNfgenmsg::new();
19729 header.cmd = 75u8;
19730 header.version = 1u8;
19731 prev.as_rec_mut().extend(header.as_slice());
19732 }
19733}
19734impl NetlinkRequest for OpRateSetDo<'_> {
19735 fn protocol(&self) -> Protocol {
19736 Protocol::Generic("devlink".as_bytes())
19737 }
19738 fn flags(&self) -> u16 {
19739 self.request.flags
19740 }
19741 fn payload(&self) -> &[u8] {
19742 self.request.buf()
19743 }
19744 type ReplyType<'buf> = IterableDevlink<'buf>;
19745 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
19746 Self::decode_request(buf)
19747 }
19748 fn lookup(
19749 buf: &[u8],
19750 offset: usize,
19751 missing_type: Option<u16>,
19752 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
19753 Self::decode_request(buf).lookup_attr(offset, missing_type)
19754 }
19755}
19756#[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"]
19757#[derive(Debug)]
19758pub struct OpRateNewDo<'r> {
19759 request: Request<'r>,
19760}
19761impl<'r> OpRateNewDo<'r> {
19762 pub fn new(mut request: Request<'r>) -> Self {
19763 Self::write_header(request.buf_mut());
19764 Self { request: request }
19765 }
19766 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
19767 Self::write_header(buf);
19768 PushDevlink::new(buf)
19769 }
19770 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
19771 PushDevlink::new(self.request.buf_mut())
19772 }
19773 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
19774 PushDevlink::new(self.request.buf)
19775 }
19776 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
19777 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
19778 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
19779 }
19780 fn write_header<Prev: Rec>(prev: &mut Prev) {
19781 let mut header = BuiltinNfgenmsg::new();
19782 header.cmd = 76u8;
19783 header.version = 1u8;
19784 prev.as_rec_mut().extend(header.as_slice());
19785 }
19786}
19787impl NetlinkRequest for OpRateNewDo<'_> {
19788 fn protocol(&self) -> Protocol {
19789 Protocol::Generic("devlink".as_bytes())
19790 }
19791 fn flags(&self) -> u16 {
19792 self.request.flags
19793 }
19794 fn payload(&self) -> &[u8] {
19795 self.request.buf()
19796 }
19797 type ReplyType<'buf> = IterableDevlink<'buf>;
19798 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
19799 Self::decode_request(buf)
19800 }
19801 fn lookup(
19802 buf: &[u8],
19803 offset: usize,
19804 missing_type: Option<u16>,
19805 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
19806 Self::decode_request(buf).lookup_attr(offset, missing_type)
19807 }
19808}
19809#[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"]
19810#[derive(Debug)]
19811pub struct OpRateDelDo<'r> {
19812 request: Request<'r>,
19813}
19814impl<'r> OpRateDelDo<'r> {
19815 pub fn new(mut request: Request<'r>) -> Self {
19816 Self::write_header(request.buf_mut());
19817 Self { request: request }
19818 }
19819 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
19820 Self::write_header(buf);
19821 PushDevlink::new(buf)
19822 }
19823 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
19824 PushDevlink::new(self.request.buf_mut())
19825 }
19826 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
19827 PushDevlink::new(self.request.buf)
19828 }
19829 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
19830 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
19831 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
19832 }
19833 fn write_header<Prev: Rec>(prev: &mut Prev) {
19834 let mut header = BuiltinNfgenmsg::new();
19835 header.cmd = 77u8;
19836 header.version = 1u8;
19837 prev.as_rec_mut().extend(header.as_slice());
19838 }
19839}
19840impl NetlinkRequest for OpRateDelDo<'_> {
19841 fn protocol(&self) -> Protocol {
19842 Protocol::Generic("devlink".as_bytes())
19843 }
19844 fn flags(&self) -> u16 {
19845 self.request.flags
19846 }
19847 fn payload(&self) -> &[u8] {
19848 self.request.buf()
19849 }
19850 type ReplyType<'buf> = IterableDevlink<'buf>;
19851 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
19852 Self::decode_request(buf)
19853 }
19854 fn lookup(
19855 buf: &[u8],
19856 offset: usize,
19857 missing_type: Option<u16>,
19858 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
19859 Self::decode_request(buf).lookup_attr(offset, missing_type)
19860 }
19861}
19862#[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"]
19863#[derive(Debug)]
19864pub struct OpLinecardGetDump<'r> {
19865 request: Request<'r>,
19866}
19867impl<'r> OpLinecardGetDump<'r> {
19868 pub fn new(mut request: Request<'r>) -> Self {
19869 Self::write_header(request.buf_mut());
19870 Self {
19871 request: request.set_dump(),
19872 }
19873 }
19874 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
19875 Self::write_header(buf);
19876 PushDevlink::new(buf)
19877 }
19878 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
19879 PushDevlink::new(self.request.buf_mut())
19880 }
19881 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
19882 PushDevlink::new(self.request.buf)
19883 }
19884 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
19885 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
19886 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
19887 }
19888 fn write_header<Prev: Rec>(prev: &mut Prev) {
19889 let mut header = BuiltinNfgenmsg::new();
19890 header.cmd = 78u8;
19891 header.version = 1u8;
19892 prev.as_rec_mut().extend(header.as_slice());
19893 }
19894}
19895impl NetlinkRequest for OpLinecardGetDump<'_> {
19896 fn protocol(&self) -> Protocol {
19897 Protocol::Generic("devlink".as_bytes())
19898 }
19899 fn flags(&self) -> u16 {
19900 self.request.flags
19901 }
19902 fn payload(&self) -> &[u8] {
19903 self.request.buf()
19904 }
19905 type ReplyType<'buf> = IterableDevlink<'buf>;
19906 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
19907 Self::decode_request(buf)
19908 }
19909 fn lookup(
19910 buf: &[u8],
19911 offset: usize,
19912 missing_type: Option<u16>,
19913 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
19914 Self::decode_request(buf).lookup_attr(offset, missing_type)
19915 }
19916}
19917#[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"]
19918#[derive(Debug)]
19919pub struct OpLinecardGetDo<'r> {
19920 request: Request<'r>,
19921}
19922impl<'r> OpLinecardGetDo<'r> {
19923 pub fn new(mut request: Request<'r>) -> Self {
19924 Self::write_header(request.buf_mut());
19925 Self { request: request }
19926 }
19927 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
19928 Self::write_header(buf);
19929 PushDevlink::new(buf)
19930 }
19931 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
19932 PushDevlink::new(self.request.buf_mut())
19933 }
19934 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
19935 PushDevlink::new(self.request.buf)
19936 }
19937 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
19938 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
19939 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
19940 }
19941 fn write_header<Prev: Rec>(prev: &mut Prev) {
19942 let mut header = BuiltinNfgenmsg::new();
19943 header.cmd = 78u8;
19944 header.version = 1u8;
19945 prev.as_rec_mut().extend(header.as_slice());
19946 }
19947}
19948impl NetlinkRequest for OpLinecardGetDo<'_> {
19949 fn protocol(&self) -> Protocol {
19950 Protocol::Generic("devlink".as_bytes())
19951 }
19952 fn flags(&self) -> u16 {
19953 self.request.flags
19954 }
19955 fn payload(&self) -> &[u8] {
19956 self.request.buf()
19957 }
19958 type ReplyType<'buf> = IterableDevlink<'buf>;
19959 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
19960 Self::decode_request(buf)
19961 }
19962 fn lookup(
19963 buf: &[u8],
19964 offset: usize,
19965 missing_type: Option<u16>,
19966 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
19967 Self::decode_request(buf).lookup_attr(offset, missing_type)
19968 }
19969}
19970#[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"]
19971#[derive(Debug)]
19972pub struct OpLinecardSetDo<'r> {
19973 request: Request<'r>,
19974}
19975impl<'r> OpLinecardSetDo<'r> {
19976 pub fn new(mut request: Request<'r>) -> Self {
19977 Self::write_header(request.buf_mut());
19978 Self { request: request }
19979 }
19980 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
19981 Self::write_header(buf);
19982 PushDevlink::new(buf)
19983 }
19984 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
19985 PushDevlink::new(self.request.buf_mut())
19986 }
19987 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
19988 PushDevlink::new(self.request.buf)
19989 }
19990 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
19991 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
19992 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
19993 }
19994 fn write_header<Prev: Rec>(prev: &mut Prev) {
19995 let mut header = BuiltinNfgenmsg::new();
19996 header.cmd = 79u8;
19997 header.version = 1u8;
19998 prev.as_rec_mut().extend(header.as_slice());
19999 }
20000}
20001impl NetlinkRequest for OpLinecardSetDo<'_> {
20002 fn protocol(&self) -> Protocol {
20003 Protocol::Generic("devlink".as_bytes())
20004 }
20005 fn flags(&self) -> u16 {
20006 self.request.flags
20007 }
20008 fn payload(&self) -> &[u8] {
20009 self.request.buf()
20010 }
20011 type ReplyType<'buf> = IterableDevlink<'buf>;
20012 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
20013 Self::decode_request(buf)
20014 }
20015 fn lookup(
20016 buf: &[u8],
20017 offset: usize,
20018 missing_type: Option<u16>,
20019 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
20020 Self::decode_request(buf).lookup_attr(offset, missing_type)
20021 }
20022}
20023#[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"]
20024#[derive(Debug)]
20025pub struct OpSelftestsGetDump<'r> {
20026 request: Request<'r>,
20027}
20028impl<'r> OpSelftestsGetDump<'r> {
20029 pub fn new(mut request: Request<'r>) -> Self {
20030 Self::write_header(request.buf_mut());
20031 Self {
20032 request: request.set_dump(),
20033 }
20034 }
20035 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
20036 Self::write_header(buf);
20037 PushDevlink::new(buf)
20038 }
20039 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
20040 PushDevlink::new(self.request.buf_mut())
20041 }
20042 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
20043 PushDevlink::new(self.request.buf)
20044 }
20045 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
20046 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
20047 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
20048 }
20049 fn write_header<Prev: Rec>(prev: &mut Prev) {
20050 let mut header = BuiltinNfgenmsg::new();
20051 header.cmd = 82u8;
20052 header.version = 1u8;
20053 prev.as_rec_mut().extend(header.as_slice());
20054 }
20055}
20056impl NetlinkRequest for OpSelftestsGetDump<'_> {
20057 fn protocol(&self) -> Protocol {
20058 Protocol::Generic("devlink".as_bytes())
20059 }
20060 fn flags(&self) -> u16 {
20061 self.request.flags
20062 }
20063 fn payload(&self) -> &[u8] {
20064 self.request.buf()
20065 }
20066 type ReplyType<'buf> = IterableDevlink<'buf>;
20067 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
20068 Self::decode_request(buf)
20069 }
20070 fn lookup(
20071 buf: &[u8],
20072 offset: usize,
20073 missing_type: Option<u16>,
20074 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
20075 Self::decode_request(buf).lookup_attr(offset, missing_type)
20076 }
20077}
20078#[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"]
20079#[derive(Debug)]
20080pub struct OpSelftestsGetDo<'r> {
20081 request: Request<'r>,
20082}
20083impl<'r> OpSelftestsGetDo<'r> {
20084 pub fn new(mut request: Request<'r>) -> Self {
20085 Self::write_header(request.buf_mut());
20086 Self { request: request }
20087 }
20088 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
20089 Self::write_header(buf);
20090 PushDevlink::new(buf)
20091 }
20092 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
20093 PushDevlink::new(self.request.buf_mut())
20094 }
20095 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
20096 PushDevlink::new(self.request.buf)
20097 }
20098 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
20099 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
20100 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
20101 }
20102 fn write_header<Prev: Rec>(prev: &mut Prev) {
20103 let mut header = BuiltinNfgenmsg::new();
20104 header.cmd = 82u8;
20105 header.version = 1u8;
20106 prev.as_rec_mut().extend(header.as_slice());
20107 }
20108}
20109impl NetlinkRequest for OpSelftestsGetDo<'_> {
20110 fn protocol(&self) -> Protocol {
20111 Protocol::Generic("devlink".as_bytes())
20112 }
20113 fn flags(&self) -> u16 {
20114 self.request.flags
20115 }
20116 fn payload(&self) -> &[u8] {
20117 self.request.buf()
20118 }
20119 type ReplyType<'buf> = IterableDevlink<'buf>;
20120 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
20121 Self::decode_request(buf)
20122 }
20123 fn lookup(
20124 buf: &[u8],
20125 offset: usize,
20126 missing_type: Option<u16>,
20127 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
20128 Self::decode_request(buf).lookup_attr(offset, missing_type)
20129 }
20130}
20131#[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"]
20132#[derive(Debug)]
20133pub struct OpSelftestsRunDo<'r> {
20134 request: Request<'r>,
20135}
20136impl<'r> OpSelftestsRunDo<'r> {
20137 pub fn new(mut request: Request<'r>) -> Self {
20138 Self::write_header(request.buf_mut());
20139 Self { request: request }
20140 }
20141 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
20142 Self::write_header(buf);
20143 PushDevlink::new(buf)
20144 }
20145 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
20146 PushDevlink::new(self.request.buf_mut())
20147 }
20148 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
20149 PushDevlink::new(self.request.buf)
20150 }
20151 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
20152 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
20153 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
20154 }
20155 fn write_header<Prev: Rec>(prev: &mut Prev) {
20156 let mut header = BuiltinNfgenmsg::new();
20157 header.cmd = 83u8;
20158 header.version = 1u8;
20159 prev.as_rec_mut().extend(header.as_slice());
20160 }
20161}
20162impl NetlinkRequest for OpSelftestsRunDo<'_> {
20163 fn protocol(&self) -> Protocol {
20164 Protocol::Generic("devlink".as_bytes())
20165 }
20166 fn flags(&self) -> u16 {
20167 self.request.flags
20168 }
20169 fn payload(&self) -> &[u8] {
20170 self.request.buf()
20171 }
20172 type ReplyType<'buf> = IterableDevlink<'buf>;
20173 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
20174 Self::decode_request(buf)
20175 }
20176 fn lookup(
20177 buf: &[u8],
20178 offset: usize,
20179 missing_type: Option<u16>,
20180 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
20181 Self::decode_request(buf).lookup_attr(offset, missing_type)
20182 }
20183}
20184#[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"]
20185#[derive(Debug)]
20186pub struct OpNotifyFilterSetDo<'r> {
20187 request: Request<'r>,
20188}
20189impl<'r> OpNotifyFilterSetDo<'r> {
20190 pub fn new(mut request: Request<'r>) -> Self {
20191 Self::write_header(request.buf_mut());
20192 Self { request: request }
20193 }
20194 pub fn encode_request<'buf>(buf: &'buf mut Vec<u8>) -> PushDevlink<&'buf mut Vec<u8>> {
20195 Self::write_header(buf);
20196 PushDevlink::new(buf)
20197 }
20198 pub fn encode(&mut self) -> PushDevlink<&mut Vec<u8>> {
20199 PushDevlink::new(self.request.buf_mut())
20200 }
20201 pub fn into_encoder(self) -> PushDevlink<RequestBuf<'r>> {
20202 PushDevlink::new(self.request.buf)
20203 }
20204 pub fn decode_request<'a>(buf: &'a [u8]) -> IterableDevlink<'a> {
20205 let (_header, attrs) = buf.split_at(buf.len().min(BuiltinNfgenmsg::len()));
20206 IterableDevlink::with_loc(attrs, buf.as_ptr() as usize)
20207 }
20208 fn write_header<Prev: Rec>(prev: &mut Prev) {
20209 let mut header = BuiltinNfgenmsg::new();
20210 header.cmd = 84u8;
20211 header.version = 1u8;
20212 prev.as_rec_mut().extend(header.as_slice());
20213 }
20214}
20215impl NetlinkRequest for OpNotifyFilterSetDo<'_> {
20216 fn protocol(&self) -> Protocol {
20217 Protocol::Generic("devlink".as_bytes())
20218 }
20219 fn flags(&self) -> u16 {
20220 self.request.flags
20221 }
20222 fn payload(&self) -> &[u8] {
20223 self.request.buf()
20224 }
20225 type ReplyType<'buf> = IterableDevlink<'buf>;
20226 fn decode_reply<'buf>(buf: &'buf [u8]) -> Self::ReplyType<'buf> {
20227 Self::decode_request(buf)
20228 }
20229 fn lookup(
20230 buf: &[u8],
20231 offset: usize,
20232 missing_type: Option<u16>,
20233 ) -> (Vec<(&'static str, usize)>, Option<&'static str>) {
20234 Self::decode_request(buf).lookup_attr(offset, missing_type)
20235 }
20236}
20237use crate::traits::LookupFn;
20238use crate::utils::RequestBuf;
20239#[derive(Debug)]
20240pub struct Request<'buf> {
20241 buf: RequestBuf<'buf>,
20242 flags: u16,
20243 writeback: Option<&'buf mut Option<RequestInfo>>,
20244}
20245#[allow(unused)]
20246#[derive(Debug, Clone)]
20247pub struct RequestInfo {
20248 protocol: Protocol,
20249 flags: u16,
20250 name: &'static str,
20251 lookup: LookupFn,
20252}
20253impl Request<'static> {
20254 pub fn new() -> Self {
20255 Self::new_from_buf(Vec::new())
20256 }
20257 pub fn new_from_buf(buf: Vec<u8>) -> Self {
20258 Self {
20259 flags: 0,
20260 buf: RequestBuf::Own(buf),
20261 writeback: None,
20262 }
20263 }
20264 pub fn into_buf(self) -> Vec<u8> {
20265 match self.buf {
20266 RequestBuf::Own(buf) => buf,
20267 _ => unreachable!(),
20268 }
20269 }
20270}
20271impl<'buf> Request<'buf> {
20272 pub fn new_with_buf(buf: &'buf mut Vec<u8>) -> Self {
20273 buf.clear();
20274 Self::new_extend(buf)
20275 }
20276 pub fn new_extend(buf: &'buf mut Vec<u8>) -> Self {
20277 Self {
20278 flags: 0,
20279 buf: RequestBuf::Ref(buf),
20280 writeback: None,
20281 }
20282 }
20283 fn do_writeback(&mut self, protocol: Protocol, name: &'static str, lookup: LookupFn) {
20284 let Some(writeback) = &mut self.writeback else {
20285 return;
20286 };
20287 **writeback = Some(RequestInfo {
20288 protocol,
20289 flags: self.flags,
20290 name,
20291 lookup,
20292 })
20293 }
20294 pub fn buf(&self) -> &Vec<u8> {
20295 self.buf.buf()
20296 }
20297 pub fn buf_mut(&mut self) -> &mut Vec<u8> {
20298 self.buf.buf_mut()
20299 }
20300 #[doc = "Set `NLM_F_CREATE` flag"]
20301 pub fn set_create(mut self) -> Self {
20302 self.flags |= consts::NLM_F_CREATE as u16;
20303 self
20304 }
20305 #[doc = "Set `NLM_F_EXCL` flag"]
20306 pub fn set_excl(mut self) -> Self {
20307 self.flags |= consts::NLM_F_EXCL as u16;
20308 self
20309 }
20310 #[doc = "Set `NLM_F_REPLACE` flag"]
20311 pub fn set_replace(mut self) -> Self {
20312 self.flags |= consts::NLM_F_REPLACE as u16;
20313 self
20314 }
20315 #[doc = "Set `NLM_F_CREATE` and `NLM_F_REPLACE` flag"]
20316 pub fn set_change(self) -> Self {
20317 self.set_create().set_replace()
20318 }
20319 #[doc = "Set `NLM_F_APPEND` flag"]
20320 pub fn set_append(mut self) -> Self {
20321 self.flags |= consts::NLM_F_APPEND as u16;
20322 self
20323 }
20324 #[doc = "Set `self.flags |= flags`"]
20325 pub fn set_flags(mut self, flags: u16) -> Self {
20326 self.flags |= flags;
20327 self
20328 }
20329 #[doc = "Set `self.flags ^= self.flags & flags`"]
20330 pub fn unset_flags(mut self, flags: u16) -> Self {
20331 self.flags ^= self.flags & flags;
20332 self
20333 }
20334 #[doc = "Set `NLM_F_DUMP` flag"]
20335 fn set_dump(mut self) -> Self {
20336 self.flags |= consts::NLM_F_DUMP as u16;
20337 self
20338 }
20339 #[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"]
20340 pub fn op_get_dump(self) -> OpGetDump<'buf> {
20341 let mut res = OpGetDump::new(self);
20342 res.request
20343 .do_writeback(res.protocol(), "op-get-dump", OpGetDump::lookup);
20344 res
20345 }
20346 #[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"]
20347 pub fn op_get_do(self) -> OpGetDo<'buf> {
20348 let mut res = OpGetDo::new(self);
20349 res.request
20350 .do_writeback(res.protocol(), "op-get-do", OpGetDo::lookup);
20351 res
20352 }
20353 #[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"]
20354 pub fn op_port_get_dump(self) -> OpPortGetDump<'buf> {
20355 let mut res = OpPortGetDump::new(self);
20356 res.request
20357 .do_writeback(res.protocol(), "op-port-get-dump", OpPortGetDump::lookup);
20358 res
20359 }
20360 #[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"]
20361 pub fn op_port_get_do(self) -> OpPortGetDo<'buf> {
20362 let mut res = OpPortGetDo::new(self);
20363 res.request
20364 .do_writeback(res.protocol(), "op-port-get-do", OpPortGetDo::lookup);
20365 res
20366 }
20367 #[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"]
20368 pub fn op_port_set_do(self) -> OpPortSetDo<'buf> {
20369 let mut res = OpPortSetDo::new(self);
20370 res.request
20371 .do_writeback(res.protocol(), "op-port-set-do", OpPortSetDo::lookup);
20372 res
20373 }
20374 #[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"]
20375 pub fn op_port_new_do(self) -> OpPortNewDo<'buf> {
20376 let mut res = OpPortNewDo::new(self);
20377 res.request
20378 .do_writeback(res.protocol(), "op-port-new-do", OpPortNewDo::lookup);
20379 res
20380 }
20381 #[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"]
20382 pub fn op_port_del_do(self) -> OpPortDelDo<'buf> {
20383 let mut res = OpPortDelDo::new(self);
20384 res.request
20385 .do_writeback(res.protocol(), "op-port-del-do", OpPortDelDo::lookup);
20386 res
20387 }
20388 #[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"]
20389 pub fn op_port_split_do(self) -> OpPortSplitDo<'buf> {
20390 let mut res = OpPortSplitDo::new(self);
20391 res.request
20392 .do_writeback(res.protocol(), "op-port-split-do", OpPortSplitDo::lookup);
20393 res
20394 }
20395 #[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"]
20396 pub fn op_port_unsplit_do(self) -> OpPortUnsplitDo<'buf> {
20397 let mut res = OpPortUnsplitDo::new(self);
20398 res.request.do_writeback(
20399 res.protocol(),
20400 "op-port-unsplit-do",
20401 OpPortUnsplitDo::lookup,
20402 );
20403 res
20404 }
20405 #[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"]
20406 pub fn op_sb_get_dump(self) -> OpSbGetDump<'buf> {
20407 let mut res = OpSbGetDump::new(self);
20408 res.request
20409 .do_writeback(res.protocol(), "op-sb-get-dump", OpSbGetDump::lookup);
20410 res
20411 }
20412 #[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"]
20413 pub fn op_sb_get_do(self) -> OpSbGetDo<'buf> {
20414 let mut res = OpSbGetDo::new(self);
20415 res.request
20416 .do_writeback(res.protocol(), "op-sb-get-do", OpSbGetDo::lookup);
20417 res
20418 }
20419 #[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"]
20420 pub fn op_sb_pool_get_dump(self) -> OpSbPoolGetDump<'buf> {
20421 let mut res = OpSbPoolGetDump::new(self);
20422 res.request.do_writeback(
20423 res.protocol(),
20424 "op-sb-pool-get-dump",
20425 OpSbPoolGetDump::lookup,
20426 );
20427 res
20428 }
20429 #[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"]
20430 pub fn op_sb_pool_get_do(self) -> OpSbPoolGetDo<'buf> {
20431 let mut res = OpSbPoolGetDo::new(self);
20432 res.request
20433 .do_writeback(res.protocol(), "op-sb-pool-get-do", OpSbPoolGetDo::lookup);
20434 res
20435 }
20436 #[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"]
20437 pub fn op_sb_pool_set_do(self) -> OpSbPoolSetDo<'buf> {
20438 let mut res = OpSbPoolSetDo::new(self);
20439 res.request
20440 .do_writeback(res.protocol(), "op-sb-pool-set-do", OpSbPoolSetDo::lookup);
20441 res
20442 }
20443 #[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"]
20444 pub fn op_sb_port_pool_get_dump(self) -> OpSbPortPoolGetDump<'buf> {
20445 let mut res = OpSbPortPoolGetDump::new(self);
20446 res.request.do_writeback(
20447 res.protocol(),
20448 "op-sb-port-pool-get-dump",
20449 OpSbPortPoolGetDump::lookup,
20450 );
20451 res
20452 }
20453 #[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"]
20454 pub fn op_sb_port_pool_get_do(self) -> OpSbPortPoolGetDo<'buf> {
20455 let mut res = OpSbPortPoolGetDo::new(self);
20456 res.request.do_writeback(
20457 res.protocol(),
20458 "op-sb-port-pool-get-do",
20459 OpSbPortPoolGetDo::lookup,
20460 );
20461 res
20462 }
20463 #[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"]
20464 pub fn op_sb_port_pool_set_do(self) -> OpSbPortPoolSetDo<'buf> {
20465 let mut res = OpSbPortPoolSetDo::new(self);
20466 res.request.do_writeback(
20467 res.protocol(),
20468 "op-sb-port-pool-set-do",
20469 OpSbPortPoolSetDo::lookup,
20470 );
20471 res
20472 }
20473 #[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"]
20474 pub fn op_sb_tc_pool_bind_get_dump(self) -> OpSbTcPoolBindGetDump<'buf> {
20475 let mut res = OpSbTcPoolBindGetDump::new(self);
20476 res.request.do_writeback(
20477 res.protocol(),
20478 "op-sb-tc-pool-bind-get-dump",
20479 OpSbTcPoolBindGetDump::lookup,
20480 );
20481 res
20482 }
20483 #[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"]
20484 pub fn op_sb_tc_pool_bind_get_do(self) -> OpSbTcPoolBindGetDo<'buf> {
20485 let mut res = OpSbTcPoolBindGetDo::new(self);
20486 res.request.do_writeback(
20487 res.protocol(),
20488 "op-sb-tc-pool-bind-get-do",
20489 OpSbTcPoolBindGetDo::lookup,
20490 );
20491 res
20492 }
20493 #[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"]
20494 pub fn op_sb_tc_pool_bind_set_do(self) -> OpSbTcPoolBindSetDo<'buf> {
20495 let mut res = OpSbTcPoolBindSetDo::new(self);
20496 res.request.do_writeback(
20497 res.protocol(),
20498 "op-sb-tc-pool-bind-set-do",
20499 OpSbTcPoolBindSetDo::lookup,
20500 );
20501 res
20502 }
20503 #[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"]
20504 pub fn op_sb_occ_snapshot_do(self) -> OpSbOccSnapshotDo<'buf> {
20505 let mut res = OpSbOccSnapshotDo::new(self);
20506 res.request.do_writeback(
20507 res.protocol(),
20508 "op-sb-occ-snapshot-do",
20509 OpSbOccSnapshotDo::lookup,
20510 );
20511 res
20512 }
20513 #[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"]
20514 pub fn op_sb_occ_max_clear_do(self) -> OpSbOccMaxClearDo<'buf> {
20515 let mut res = OpSbOccMaxClearDo::new(self);
20516 res.request.do_writeback(
20517 res.protocol(),
20518 "op-sb-occ-max-clear-do",
20519 OpSbOccMaxClearDo::lookup,
20520 );
20521 res
20522 }
20523 #[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"]
20524 pub fn op_eswitch_get_do(self) -> OpEswitchGetDo<'buf> {
20525 let mut res = OpEswitchGetDo::new(self);
20526 res.request
20527 .do_writeback(res.protocol(), "op-eswitch-get-do", OpEswitchGetDo::lookup);
20528 res
20529 }
20530 #[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"]
20531 pub fn op_eswitch_set_do(self) -> OpEswitchSetDo<'buf> {
20532 let mut res = OpEswitchSetDo::new(self);
20533 res.request
20534 .do_writeback(res.protocol(), "op-eswitch-set-do", OpEswitchSetDo::lookup);
20535 res
20536 }
20537 #[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"]
20538 pub fn op_dpipe_table_get_do(self) -> OpDpipeTableGetDo<'buf> {
20539 let mut res = OpDpipeTableGetDo::new(self);
20540 res.request.do_writeback(
20541 res.protocol(),
20542 "op-dpipe-table-get-do",
20543 OpDpipeTableGetDo::lookup,
20544 );
20545 res
20546 }
20547 #[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"]
20548 pub fn op_dpipe_entries_get_do(self) -> OpDpipeEntriesGetDo<'buf> {
20549 let mut res = OpDpipeEntriesGetDo::new(self);
20550 res.request.do_writeback(
20551 res.protocol(),
20552 "op-dpipe-entries-get-do",
20553 OpDpipeEntriesGetDo::lookup,
20554 );
20555 res
20556 }
20557 #[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"]
20558 pub fn op_dpipe_headers_get_do(self) -> OpDpipeHeadersGetDo<'buf> {
20559 let mut res = OpDpipeHeadersGetDo::new(self);
20560 res.request.do_writeback(
20561 res.protocol(),
20562 "op-dpipe-headers-get-do",
20563 OpDpipeHeadersGetDo::lookup,
20564 );
20565 res
20566 }
20567 #[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"]
20568 pub fn op_dpipe_table_counters_set_do(self) -> OpDpipeTableCountersSetDo<'buf> {
20569 let mut res = OpDpipeTableCountersSetDo::new(self);
20570 res.request.do_writeback(
20571 res.protocol(),
20572 "op-dpipe-table-counters-set-do",
20573 OpDpipeTableCountersSetDo::lookup,
20574 );
20575 res
20576 }
20577 #[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"]
20578 pub fn op_resource_set_do(self) -> OpResourceSetDo<'buf> {
20579 let mut res = OpResourceSetDo::new(self);
20580 res.request.do_writeback(
20581 res.protocol(),
20582 "op-resource-set-do",
20583 OpResourceSetDo::lookup,
20584 );
20585 res
20586 }
20587 #[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"]
20588 pub fn op_resource_dump_dump(self) -> OpResourceDumpDump<'buf> {
20589 let mut res = OpResourceDumpDump::new(self);
20590 res.request.do_writeback(
20591 res.protocol(),
20592 "op-resource-dump-dump",
20593 OpResourceDumpDump::lookup,
20594 );
20595 res
20596 }
20597 #[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"]
20598 pub fn op_resource_dump_do(self) -> OpResourceDumpDo<'buf> {
20599 let mut res = OpResourceDumpDo::new(self);
20600 res.request.do_writeback(
20601 res.protocol(),
20602 "op-resource-dump-do",
20603 OpResourceDumpDo::lookup,
20604 );
20605 res
20606 }
20607 #[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"]
20608 pub fn op_reload_do(self) -> OpReloadDo<'buf> {
20609 let mut res = OpReloadDo::new(self);
20610 res.request
20611 .do_writeback(res.protocol(), "op-reload-do", OpReloadDo::lookup);
20612 res
20613 }
20614 #[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"]
20615 pub fn op_param_get_dump(self) -> OpParamGetDump<'buf> {
20616 let mut res = OpParamGetDump::new(self);
20617 res.request
20618 .do_writeback(res.protocol(), "op-param-get-dump", OpParamGetDump::lookup);
20619 res
20620 }
20621 #[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"]
20622 pub fn op_param_get_do(self) -> OpParamGetDo<'buf> {
20623 let mut res = OpParamGetDo::new(self);
20624 res.request
20625 .do_writeback(res.protocol(), "op-param-get-do", OpParamGetDo::lookup);
20626 res
20627 }
20628 #[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"]
20629 pub fn op_param_set_do(self) -> OpParamSetDo<'buf> {
20630 let mut res = OpParamSetDo::new(self);
20631 res.request
20632 .do_writeback(res.protocol(), "op-param-set-do", OpParamSetDo::lookup);
20633 res
20634 }
20635 #[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"]
20636 pub fn op_region_get_dump(self) -> OpRegionGetDump<'buf> {
20637 let mut res = OpRegionGetDump::new(self);
20638 res.request.do_writeback(
20639 res.protocol(),
20640 "op-region-get-dump",
20641 OpRegionGetDump::lookup,
20642 );
20643 res
20644 }
20645 #[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"]
20646 pub fn op_region_get_do(self) -> OpRegionGetDo<'buf> {
20647 let mut res = OpRegionGetDo::new(self);
20648 res.request
20649 .do_writeback(res.protocol(), "op-region-get-do", OpRegionGetDo::lookup);
20650 res
20651 }
20652 #[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"]
20653 pub fn op_region_new_do(self) -> OpRegionNewDo<'buf> {
20654 let mut res = OpRegionNewDo::new(self);
20655 res.request
20656 .do_writeback(res.protocol(), "op-region-new-do", OpRegionNewDo::lookup);
20657 res
20658 }
20659 #[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"]
20660 pub fn op_region_del_do(self) -> OpRegionDelDo<'buf> {
20661 let mut res = OpRegionDelDo::new(self);
20662 res.request
20663 .do_writeback(res.protocol(), "op-region-del-do", OpRegionDelDo::lookup);
20664 res
20665 }
20666 #[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"]
20667 pub fn op_region_read_dump(self) -> OpRegionReadDump<'buf> {
20668 let mut res = OpRegionReadDump::new(self);
20669 res.request.do_writeback(
20670 res.protocol(),
20671 "op-region-read-dump",
20672 OpRegionReadDump::lookup,
20673 );
20674 res
20675 }
20676 #[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"]
20677 pub fn op_port_param_get_dump(self) -> OpPortParamGetDump<'buf> {
20678 let mut res = OpPortParamGetDump::new(self);
20679 res.request.do_writeback(
20680 res.protocol(),
20681 "op-port-param-get-dump",
20682 OpPortParamGetDump::lookup,
20683 );
20684 res
20685 }
20686 #[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"]
20687 pub fn op_port_param_get_do(self) -> OpPortParamGetDo<'buf> {
20688 let mut res = OpPortParamGetDo::new(self);
20689 res.request.do_writeback(
20690 res.protocol(),
20691 "op-port-param-get-do",
20692 OpPortParamGetDo::lookup,
20693 );
20694 res
20695 }
20696 #[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"]
20697 pub fn op_port_param_set_do(self) -> OpPortParamSetDo<'buf> {
20698 let mut res = OpPortParamSetDo::new(self);
20699 res.request.do_writeback(
20700 res.protocol(),
20701 "op-port-param-set-do",
20702 OpPortParamSetDo::lookup,
20703 );
20704 res
20705 }
20706 #[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"]
20707 pub fn op_info_get_dump(self) -> OpInfoGetDump<'buf> {
20708 let mut res = OpInfoGetDump::new(self);
20709 res.request
20710 .do_writeback(res.protocol(), "op-info-get-dump", OpInfoGetDump::lookup);
20711 res
20712 }
20713 #[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"]
20714 pub fn op_info_get_do(self) -> OpInfoGetDo<'buf> {
20715 let mut res = OpInfoGetDo::new(self);
20716 res.request
20717 .do_writeback(res.protocol(), "op-info-get-do", OpInfoGetDo::lookup);
20718 res
20719 }
20720 #[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"]
20721 pub fn op_health_reporter_get_dump(self) -> OpHealthReporterGetDump<'buf> {
20722 let mut res = OpHealthReporterGetDump::new(self);
20723 res.request.do_writeback(
20724 res.protocol(),
20725 "op-health-reporter-get-dump",
20726 OpHealthReporterGetDump::lookup,
20727 );
20728 res
20729 }
20730 #[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"]
20731 pub fn op_health_reporter_get_do(self) -> OpHealthReporterGetDo<'buf> {
20732 let mut res = OpHealthReporterGetDo::new(self);
20733 res.request.do_writeback(
20734 res.protocol(),
20735 "op-health-reporter-get-do",
20736 OpHealthReporterGetDo::lookup,
20737 );
20738 res
20739 }
20740 #[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"]
20741 pub fn op_health_reporter_set_do(self) -> OpHealthReporterSetDo<'buf> {
20742 let mut res = OpHealthReporterSetDo::new(self);
20743 res.request.do_writeback(
20744 res.protocol(),
20745 "op-health-reporter-set-do",
20746 OpHealthReporterSetDo::lookup,
20747 );
20748 res
20749 }
20750 #[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"]
20751 pub fn op_health_reporter_recover_do(self) -> OpHealthReporterRecoverDo<'buf> {
20752 let mut res = OpHealthReporterRecoverDo::new(self);
20753 res.request.do_writeback(
20754 res.protocol(),
20755 "op-health-reporter-recover-do",
20756 OpHealthReporterRecoverDo::lookup,
20757 );
20758 res
20759 }
20760 #[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"]
20761 pub fn op_health_reporter_diagnose_do(self) -> OpHealthReporterDiagnoseDo<'buf> {
20762 let mut res = OpHealthReporterDiagnoseDo::new(self);
20763 res.request.do_writeback(
20764 res.protocol(),
20765 "op-health-reporter-diagnose-do",
20766 OpHealthReporterDiagnoseDo::lookup,
20767 );
20768 res
20769 }
20770 #[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"]
20771 pub fn op_health_reporter_dump_get_dump(self) -> OpHealthReporterDumpGetDump<'buf> {
20772 let mut res = OpHealthReporterDumpGetDump::new(self);
20773 res.request.do_writeback(
20774 res.protocol(),
20775 "op-health-reporter-dump-get-dump",
20776 OpHealthReporterDumpGetDump::lookup,
20777 );
20778 res
20779 }
20780 #[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"]
20781 pub fn op_health_reporter_dump_clear_do(self) -> OpHealthReporterDumpClearDo<'buf> {
20782 let mut res = OpHealthReporterDumpClearDo::new(self);
20783 res.request.do_writeback(
20784 res.protocol(),
20785 "op-health-reporter-dump-clear-do",
20786 OpHealthReporterDumpClearDo::lookup,
20787 );
20788 res
20789 }
20790 #[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"]
20791 pub fn op_flash_update_do(self) -> OpFlashUpdateDo<'buf> {
20792 let mut res = OpFlashUpdateDo::new(self);
20793 res.request.do_writeback(
20794 res.protocol(),
20795 "op-flash-update-do",
20796 OpFlashUpdateDo::lookup,
20797 );
20798 res
20799 }
20800 #[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"]
20801 pub fn op_trap_get_dump(self) -> OpTrapGetDump<'buf> {
20802 let mut res = OpTrapGetDump::new(self);
20803 res.request
20804 .do_writeback(res.protocol(), "op-trap-get-dump", OpTrapGetDump::lookup);
20805 res
20806 }
20807 #[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"]
20808 pub fn op_trap_get_do(self) -> OpTrapGetDo<'buf> {
20809 let mut res = OpTrapGetDo::new(self);
20810 res.request
20811 .do_writeback(res.protocol(), "op-trap-get-do", OpTrapGetDo::lookup);
20812 res
20813 }
20814 #[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"]
20815 pub fn op_trap_set_do(self) -> OpTrapSetDo<'buf> {
20816 let mut res = OpTrapSetDo::new(self);
20817 res.request
20818 .do_writeback(res.protocol(), "op-trap-set-do", OpTrapSetDo::lookup);
20819 res
20820 }
20821 #[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"]
20822 pub fn op_trap_group_get_dump(self) -> OpTrapGroupGetDump<'buf> {
20823 let mut res = OpTrapGroupGetDump::new(self);
20824 res.request.do_writeback(
20825 res.protocol(),
20826 "op-trap-group-get-dump",
20827 OpTrapGroupGetDump::lookup,
20828 );
20829 res
20830 }
20831 #[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"]
20832 pub fn op_trap_group_get_do(self) -> OpTrapGroupGetDo<'buf> {
20833 let mut res = OpTrapGroupGetDo::new(self);
20834 res.request.do_writeback(
20835 res.protocol(),
20836 "op-trap-group-get-do",
20837 OpTrapGroupGetDo::lookup,
20838 );
20839 res
20840 }
20841 #[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"]
20842 pub fn op_trap_group_set_do(self) -> OpTrapGroupSetDo<'buf> {
20843 let mut res = OpTrapGroupSetDo::new(self);
20844 res.request.do_writeback(
20845 res.protocol(),
20846 "op-trap-group-set-do",
20847 OpTrapGroupSetDo::lookup,
20848 );
20849 res
20850 }
20851 #[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"]
20852 pub fn op_trap_policer_get_dump(self) -> OpTrapPolicerGetDump<'buf> {
20853 let mut res = OpTrapPolicerGetDump::new(self);
20854 res.request.do_writeback(
20855 res.protocol(),
20856 "op-trap-policer-get-dump",
20857 OpTrapPolicerGetDump::lookup,
20858 );
20859 res
20860 }
20861 #[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"]
20862 pub fn op_trap_policer_get_do(self) -> OpTrapPolicerGetDo<'buf> {
20863 let mut res = OpTrapPolicerGetDo::new(self);
20864 res.request.do_writeback(
20865 res.protocol(),
20866 "op-trap-policer-get-do",
20867 OpTrapPolicerGetDo::lookup,
20868 );
20869 res
20870 }
20871 #[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"]
20872 pub fn op_trap_policer_set_do(self) -> OpTrapPolicerSetDo<'buf> {
20873 let mut res = OpTrapPolicerSetDo::new(self);
20874 res.request.do_writeback(
20875 res.protocol(),
20876 "op-trap-policer-set-do",
20877 OpTrapPolicerSetDo::lookup,
20878 );
20879 res
20880 }
20881 #[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"]
20882 pub fn op_health_reporter_test_do(self) -> OpHealthReporterTestDo<'buf> {
20883 let mut res = OpHealthReporterTestDo::new(self);
20884 res.request.do_writeback(
20885 res.protocol(),
20886 "op-health-reporter-test-do",
20887 OpHealthReporterTestDo::lookup,
20888 );
20889 res
20890 }
20891 #[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"]
20892 pub fn op_rate_get_dump(self) -> OpRateGetDump<'buf> {
20893 let mut res = OpRateGetDump::new(self);
20894 res.request
20895 .do_writeback(res.protocol(), "op-rate-get-dump", OpRateGetDump::lookup);
20896 res
20897 }
20898 #[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"]
20899 pub fn op_rate_get_do(self) -> OpRateGetDo<'buf> {
20900 let mut res = OpRateGetDo::new(self);
20901 res.request
20902 .do_writeback(res.protocol(), "op-rate-get-do", OpRateGetDo::lookup);
20903 res
20904 }
20905 #[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"]
20906 pub fn op_rate_set_do(self) -> OpRateSetDo<'buf> {
20907 let mut res = OpRateSetDo::new(self);
20908 res.request
20909 .do_writeback(res.protocol(), "op-rate-set-do", OpRateSetDo::lookup);
20910 res
20911 }
20912 #[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"]
20913 pub fn op_rate_new_do(self) -> OpRateNewDo<'buf> {
20914 let mut res = OpRateNewDo::new(self);
20915 res.request
20916 .do_writeback(res.protocol(), "op-rate-new-do", OpRateNewDo::lookup);
20917 res
20918 }
20919 #[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"]
20920 pub fn op_rate_del_do(self) -> OpRateDelDo<'buf> {
20921 let mut res = OpRateDelDo::new(self);
20922 res.request
20923 .do_writeback(res.protocol(), "op-rate-del-do", OpRateDelDo::lookup);
20924 res
20925 }
20926 #[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"]
20927 pub fn op_linecard_get_dump(self) -> OpLinecardGetDump<'buf> {
20928 let mut res = OpLinecardGetDump::new(self);
20929 res.request.do_writeback(
20930 res.protocol(),
20931 "op-linecard-get-dump",
20932 OpLinecardGetDump::lookup,
20933 );
20934 res
20935 }
20936 #[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"]
20937 pub fn op_linecard_get_do(self) -> OpLinecardGetDo<'buf> {
20938 let mut res = OpLinecardGetDo::new(self);
20939 res.request.do_writeback(
20940 res.protocol(),
20941 "op-linecard-get-do",
20942 OpLinecardGetDo::lookup,
20943 );
20944 res
20945 }
20946 #[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"]
20947 pub fn op_linecard_set_do(self) -> OpLinecardSetDo<'buf> {
20948 let mut res = OpLinecardSetDo::new(self);
20949 res.request.do_writeback(
20950 res.protocol(),
20951 "op-linecard-set-do",
20952 OpLinecardSetDo::lookup,
20953 );
20954 res
20955 }
20956 #[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"]
20957 pub fn op_selftests_get_dump(self) -> OpSelftestsGetDump<'buf> {
20958 let mut res = OpSelftestsGetDump::new(self);
20959 res.request.do_writeback(
20960 res.protocol(),
20961 "op-selftests-get-dump",
20962 OpSelftestsGetDump::lookup,
20963 );
20964 res
20965 }
20966 #[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"]
20967 pub fn op_selftests_get_do(self) -> OpSelftestsGetDo<'buf> {
20968 let mut res = OpSelftestsGetDo::new(self);
20969 res.request.do_writeback(
20970 res.protocol(),
20971 "op-selftests-get-do",
20972 OpSelftestsGetDo::lookup,
20973 );
20974 res
20975 }
20976 #[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"]
20977 pub fn op_selftests_run_do(self) -> OpSelftestsRunDo<'buf> {
20978 let mut res = OpSelftestsRunDo::new(self);
20979 res.request.do_writeback(
20980 res.protocol(),
20981 "op-selftests-run-do",
20982 OpSelftestsRunDo::lookup,
20983 );
20984 res
20985 }
20986 #[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"]
20987 pub fn op_notify_filter_set_do(self) -> OpNotifyFilterSetDo<'buf> {
20988 let mut res = OpNotifyFilterSetDo::new(self);
20989 res.request.do_writeback(
20990 res.protocol(),
20991 "op-notify-filter-set-do",
20992 OpNotifyFilterSetDo::lookup,
20993 );
20994 res
20995 }
20996}
20997#[cfg(test)]
20998mod generated_tests {
20999 use super::*;
21000 #[test]
21001 fn tests() {
21002 let _ = IterableDevlink::get_bus_name;
21003 let _ = IterableDevlink::get_dev_name;
21004 let _ = IterableDevlink::get_dev_stats;
21005 let _ = IterableDevlink::get_dpipe_entries;
21006 let _ = IterableDevlink::get_dpipe_headers;
21007 let _ = IterableDevlink::get_dpipe_tables;
21008 let _ = IterableDevlink::get_eswitch_encap_mode;
21009 let _ = IterableDevlink::get_eswitch_inline_mode;
21010 let _ = IterableDevlink::get_eswitch_mode;
21011 let _ = IterableDevlink::get_fmsg;
21012 let _ = IterableDevlink::get_health_reporter_name;
21013 let _ = IterableDevlink::get_index;
21014 let _ = IterableDevlink::get_info_board_serial_number;
21015 let _ = IterableDevlink::get_info_driver_name;
21016 let _ = IterableDevlink::get_info_serial_number;
21017 let _ = IterableDevlink::get_info_version_fixed;
21018 let _ = IterableDevlink::get_info_version_running;
21019 let _ = IterableDevlink::get_info_version_stored;
21020 let _ = IterableDevlink::get_linecard_index;
21021 let _ = IterableDevlink::get_param_name;
21022 let _ = IterableDevlink::get_port_index;
21023 let _ = IterableDevlink::get_rate_node_name;
21024 let _ = IterableDevlink::get_region_name;
21025 let _ = IterableDevlink::get_region_snapshot_id;
21026 let _ = IterableDevlink::get_reload_actions_performed;
21027 let _ = IterableDevlink::get_reload_failed;
21028 let _ = IterableDevlink::get_resource_list;
21029 let _ = IterableDevlink::get_sb_index;
21030 let _ = IterableDevlink::get_sb_pool_index;
21031 let _ = IterableDevlink::get_sb_pool_type;
21032 let _ = IterableDevlink::get_sb_tc_index;
21033 let _ = IterableDevlink::get_trap_group_name;
21034 let _ = IterableDevlink::get_trap_name;
21035 let _ = IterableDevlink::get_trap_policer_id;
21036 let _ = PushDevlink::<&mut Vec<u8>>::nested_port_function;
21037 let _ = PushDevlink::<&mut Vec<u8>>::nested_rate_tc_bws;
21038 let _ = PushDevlink::<&mut Vec<u8>>::nested_selftests;
21039 let _ = PushDevlink::<&mut Vec<u8>>::push_bus_name;
21040 let _ = PushDevlink::<&mut Vec<u8>>::push_dev_name;
21041 let _ = PushDevlink::<&mut Vec<u8>>::push_dpipe_table_counters_enabled;
21042 let _ = PushDevlink::<&mut Vec<u8>>::push_dpipe_table_name;
21043 let _ = PushDevlink::<&mut Vec<u8>>::push_eswitch_encap_mode;
21044 let _ = PushDevlink::<&mut Vec<u8>>::push_eswitch_inline_mode;
21045 let _ = PushDevlink::<&mut Vec<u8>>::push_eswitch_mode;
21046 let _ = PushDevlink::<&mut Vec<u8>>::push_flash_update_component;
21047 let _ = PushDevlink::<&mut Vec<u8>>::push_flash_update_file_name;
21048 let _ = PushDevlink::<&mut Vec<u8>>::push_flash_update_overwrite_mask;
21049 let _ = PushDevlink::<&mut Vec<u8>>::push_health_reporter_auto_dump;
21050 let _ = PushDevlink::<&mut Vec<u8>>::push_health_reporter_auto_recover;
21051 let _ = PushDevlink::<&mut Vec<u8>>::push_health_reporter_burst_period;
21052 let _ = PushDevlink::<&mut Vec<u8>>::push_health_reporter_graceful_period;
21053 let _ = PushDevlink::<&mut Vec<u8>>::push_health_reporter_name;
21054 let _ = PushDevlink::<&mut Vec<u8>>::push_index;
21055 let _ = PushDevlink::<&mut Vec<u8>>::push_linecard_index;
21056 let _ = PushDevlink::<&mut Vec<u8>>::push_linecard_type;
21057 let _ = PushDevlink::<&mut Vec<u8>>::push_netns_fd;
21058 let _ = PushDevlink::<&mut Vec<u8>>::push_netns_id;
21059 let _ = PushDevlink::<&mut Vec<u8>>::push_netns_pid;
21060 let _ = PushDevlink::<&mut Vec<u8>>::push_param_name;
21061 let _ = PushDevlink::<&mut Vec<u8>>::push_param_reset_default;
21062 let _ = PushDevlink::<&mut Vec<u8>>::push_param_type;
21063 let _ = PushDevlink::<&mut Vec<u8>>::push_param_value_cmode;
21064 let _ = PushDevlink::<&mut Vec<u8>>::push_port_controller_number;
21065 let _ = PushDevlink::<&mut Vec<u8>>::push_port_flavour;
21066 let _ = PushDevlink::<&mut Vec<u8>>::push_port_index;
21067 let _ = PushDevlink::<&mut Vec<u8>>::push_port_pci_pf_number;
21068 let _ = PushDevlink::<&mut Vec<u8>>::push_port_pci_sf_number;
21069 let _ = PushDevlink::<&mut Vec<u8>>::push_port_split_count;
21070 let _ = PushDevlink::<&mut Vec<u8>>::push_port_type;
21071 let _ = PushDevlink::<&mut Vec<u8>>::push_rate_node_name;
21072 let _ = PushDevlink::<&mut Vec<u8>>::push_rate_parent_node_name;
21073 let _ = PushDevlink::<&mut Vec<u8>>::push_rate_tx_max;
21074 let _ = PushDevlink::<&mut Vec<u8>>::push_rate_tx_priority;
21075 let _ = PushDevlink::<&mut Vec<u8>>::push_rate_tx_share;
21076 let _ = PushDevlink::<&mut Vec<u8>>::push_rate_tx_weight;
21077 let _ = PushDevlink::<&mut Vec<u8>>::push_region_chunk_addr;
21078 let _ = PushDevlink::<&mut Vec<u8>>::push_region_chunk_len;
21079 let _ = PushDevlink::<&mut Vec<u8>>::push_region_direct;
21080 let _ = PushDevlink::<&mut Vec<u8>>::push_region_name;
21081 let _ = PushDevlink::<&mut Vec<u8>>::push_region_snapshot_id;
21082 let _ = PushDevlink::<&mut Vec<u8>>::push_reload_action;
21083 let _ = PushDevlink::<&mut Vec<u8>>::push_reload_limits;
21084 let _ = PushDevlink::<&mut Vec<u8>>::push_resource_id;
21085 let _ = PushDevlink::<&mut Vec<u8>>::push_resource_scope_mask;
21086 let _ = PushDevlink::<&mut Vec<u8>>::push_resource_size;
21087 let _ = PushDevlink::<&mut Vec<u8>>::push_sb_index;
21088 let _ = PushDevlink::<&mut Vec<u8>>::push_sb_pool_index;
21089 let _ = PushDevlink::<&mut Vec<u8>>::push_sb_pool_size;
21090 let _ = PushDevlink::<&mut Vec<u8>>::push_sb_pool_threshold_type;
21091 let _ = PushDevlink::<&mut Vec<u8>>::push_sb_pool_type;
21092 let _ = PushDevlink::<&mut Vec<u8>>::push_sb_tc_index;
21093 let _ = PushDevlink::<&mut Vec<u8>>::push_sb_threshold;
21094 let _ = PushDevlink::<&mut Vec<u8>>::push_trap_action;
21095 let _ = PushDevlink::<&mut Vec<u8>>::push_trap_group_name;
21096 let _ = PushDevlink::<&mut Vec<u8>>::push_trap_name;
21097 let _ = PushDevlink::<&mut Vec<u8>>::push_trap_policer_burst;
21098 let _ = PushDevlink::<&mut Vec<u8>>::push_trap_policer_id;
21099 let _ = PushDevlink::<&mut Vec<u8>>::push_trap_policer_rate;
21100 }
21101}