1 #!/usr/bin/env python3 1 #!/usr/bin/env python3
2 # SPDX-License-Identifier: GPL-2.0-only 2 # SPDX-License-Identifier: GPL-2.0-only
3 # 3 #
4 # Copyright (C) 2018-2019 Netronome Systems, I 4 # Copyright (C) 2018-2019 Netronome Systems, Inc.
5 # Copyright (C) 2021 Isovalent, Inc. 5 # Copyright (C) 2021 Isovalent, Inc.
6 6
7 # In case user attempts to run with Python 2. 7 # In case user attempts to run with Python 2.
8 from __future__ import print_function 8 from __future__ import print_function
9 9
10 import argparse 10 import argparse
11 import re 11 import re
12 import sys, os 12 import sys, os
13 import subprocess <<
14 <<
15 helpersDocStart = 'Start of BPF helper functio <<
16 13
17 class NoHelperFound(BaseException): 14 class NoHelperFound(BaseException):
18 pass 15 pass
19 16
20 class NoSyscallCommandFound(BaseException): 17 class NoSyscallCommandFound(BaseException):
21 pass 18 pass
22 19
23 class ParsingError(BaseException): 20 class ParsingError(BaseException):
24 def __init__(self, line='<line not provide 21 def __init__(self, line='<line not provided>', reader=None):
25 if reader: 22 if reader:
26 BaseException.__init__(self, 23 BaseException.__init__(self,
27 'Error at f 24 'Error at file offset %d, parsing line: %s' %
28 (reader.tel 25 (reader.tell(), line))
29 else: 26 else:
30 BaseException.__init__(self, 'Erro 27 BaseException.__init__(self, 'Error parsing line: %s' % line)
31 28
32 29
33 class APIElement(object): 30 class APIElement(object):
34 """ 31 """
35 An object representing the description of 32 An object representing the description of an aspect of the eBPF API.
36 @proto: prototype of the API symbol 33 @proto: prototype of the API symbol
37 @desc: textual description of the symbol 34 @desc: textual description of the symbol
38 @ret: (optional) description of any associ 35 @ret: (optional) description of any associated return value
39 """ 36 """
40 def __init__(self, proto='', desc='', ret= 37 def __init__(self, proto='', desc='', ret=''):
41 self.proto = proto 38 self.proto = proto
42 self.desc = desc 39 self.desc = desc
43 self.ret = ret 40 self.ret = ret
44 41
45 42
46 class Helper(APIElement): 43 class Helper(APIElement):
47 """ 44 """
48 An object representing the description of 45 An object representing the description of an eBPF helper function.
49 @proto: function prototype of the helper f 46 @proto: function prototype of the helper function
50 @desc: textual description of the helper f 47 @desc: textual description of the helper function
51 @ret: description of the return value of t 48 @ret: description of the return value of the helper function
52 """ 49 """
53 def __init__(self, *args, **kwargs): <<
54 super().__init__(*args, **kwargs) <<
55 self.enum_val = None <<
56 <<
57 def proto_break_down(self): 50 def proto_break_down(self):
58 """ 51 """
59 Break down helper function protocol in 52 Break down helper function protocol into smaller chunks: return type,
60 name, distincts arguments. 53 name, distincts arguments.
61 """ 54 """
62 arg_re = re.compile(r'((\w+ )*?(\w+|.. !! 55 arg_re = re.compile('((\w+ )*?(\w+|...))( (\**)(\w+))?$')
63 res = {} 56 res = {}
64 proto_re = re.compile(r'(.+) (\**)(\w+ !! 57 proto_re = re.compile('(.+) (\**)(\w+)\(((([^,]+)(, )?){1,5})\)$')
65 58
66 capture = proto_re.match(self.proto) 59 capture = proto_re.match(self.proto)
67 res['ret_type'] = capture.group(1) 60 res['ret_type'] = capture.group(1)
68 res['ret_star'] = capture.group(2) 61 res['ret_star'] = capture.group(2)
69 res['name'] = capture.group(3) 62 res['name'] = capture.group(3)
70 res['args'] = [] 63 res['args'] = []
71 64
72 args = capture.group(4).split(', ') 65 args = capture.group(4).split(', ')
73 for a in args: 66 for a in args:
74 capture = arg_re.match(a) 67 capture = arg_re.match(a)
75 res['args'].append({ 68 res['args'].append({
76 'type' : capture.group(1), 69 'type' : capture.group(1),
77 'star' : capture.group(5), 70 'star' : capture.group(5),
78 'name' : capture.group(6) 71 'name' : capture.group(6)
79 }) 72 })
80 73
81 return res 74 return res
82 75
83 76
84 class HeaderParser(object): 77 class HeaderParser(object):
85 """ 78 """
86 An object used to parse a file in order to 79 An object used to parse a file in order to extract the documentation of a
87 list of eBPF helper functions. All the hel 80 list of eBPF helper functions. All the helpers that can be retrieved are
88 stored as Helper object, in the self.helpe 81 stored as Helper object, in the self.helpers() array.
89 @filename: name of file to parse, usually 82 @filename: name of file to parse, usually include/uapi/linux/bpf.h in the
90 kernel tree 83 kernel tree
91 """ 84 """
92 def __init__(self, filename): 85 def __init__(self, filename):
93 self.reader = open(filename, 'r') 86 self.reader = open(filename, 'r')
94 self.line = '' 87 self.line = ''
95 self.helpers = [] 88 self.helpers = []
96 self.commands = [] 89 self.commands = []
97 self.desc_unique_helpers = set() <<
98 self.define_unique_helpers = [] <<
99 self.helper_enum_vals = {} <<
100 self.helper_enum_pos = {} <<
101 self.desc_syscalls = [] <<
102 self.enum_syscalls = [] <<
103 90
104 def parse_element(self): 91 def parse_element(self):
105 proto = self.parse_symbol() 92 proto = self.parse_symbol()
106 desc = self.parse_desc(proto) !! 93 desc = self.parse_desc()
107 ret = self.parse_ret(proto) !! 94 ret = self.parse_ret()
108 return APIElement(proto=proto, desc=de 95 return APIElement(proto=proto, desc=desc, ret=ret)
109 96
110 def parse_helper(self): 97 def parse_helper(self):
111 proto = self.parse_proto() 98 proto = self.parse_proto()
112 desc = self.parse_desc(proto) !! 99 desc = self.parse_desc()
113 ret = self.parse_ret(proto) !! 100 ret = self.parse_ret()
114 return Helper(proto=proto, desc=desc, 101 return Helper(proto=proto, desc=desc, ret=ret)
115 102
116 def parse_symbol(self): 103 def parse_symbol(self):
117 p = re.compile(r' \* ?(BPF\w+)$') !! 104 p = re.compile(' \* ?(.+)$')
118 capture = p.match(self.line) 105 capture = p.match(self.line)
119 if not capture: 106 if not capture:
120 raise NoSyscallCommandFound 107 raise NoSyscallCommandFound
121 end_re = re.compile(r' \* ?NOTES$') !! 108 end_re = re.compile(' \* ?NOTES$')
122 end = end_re.match(self.line) 109 end = end_re.match(self.line)
123 if end: 110 if end:
124 raise NoSyscallCommandFound 111 raise NoSyscallCommandFound
125 self.line = self.reader.readline() 112 self.line = self.reader.readline()
126 return capture.group(1) 113 return capture.group(1)
127 114
128 def parse_proto(self): 115 def parse_proto(self):
129 # Argument can be of shape: 116 # Argument can be of shape:
130 # - "void" 117 # - "void"
131 # - "type name" 118 # - "type name"
132 # - "type *name" 119 # - "type *name"
133 # - Same as above, with "const" and/ 120 # - Same as above, with "const" and/or "struct" in front of type
134 # - "..." (undefined number of argum 121 # - "..." (undefined number of arguments, for bpf_trace_printk())
135 # There is at least one term ("void"), 122 # There is at least one term ("void"), and at most five arguments.
136 p = re.compile(r' \* ?((.+) \**\w+\((( !! 123 p = re.compile(' \* ?((.+) \**\w+\((((const )?(struct )?(\w+|\.\.\.)( \**\w+)?)(, )?){1,5}\))$')
137 capture = p.match(self.line) 124 capture = p.match(self.line)
138 if not capture: 125 if not capture:
139 raise NoHelperFound 126 raise NoHelperFound
140 self.line = self.reader.readline() 127 self.line = self.reader.readline()
141 return capture.group(1) 128 return capture.group(1)
142 129
143 def parse_desc(self, proto): !! 130 def parse_desc(self):
144 p = re.compile(r' \* ?(?:\t| {5,8})Des !! 131 p = re.compile(' \* ?(?:\t| {5,8})Description$')
145 capture = p.match(self.line) 132 capture = p.match(self.line)
146 if not capture: 133 if not capture:
147 raise Exception("No description se !! 134 # Helper can have empty description and we might be parsing another
>> 135 # attribute: return but do not consume.
>> 136 return ''
148 # Description can be several lines, so 137 # Description can be several lines, some of them possibly empty, and it
149 # stops when another subsection title 138 # stops when another subsection title is met.
150 desc = '' 139 desc = ''
151 desc_present = False <<
152 while True: 140 while True:
153 self.line = self.reader.readline() 141 self.line = self.reader.readline()
154 if self.line == ' *\n': 142 if self.line == ' *\n':
155 desc += '\n' 143 desc += '\n'
156 else: 144 else:
157 p = re.compile(r' \* ?(?:\t| { !! 145 p = re.compile(' \* ?(?:\t| {5,8})(?:\t| {8})(.*)')
158 capture = p.match(self.line) 146 capture = p.match(self.line)
159 if capture: 147 if capture:
160 desc_present = True <<
161 desc += capture.group(1) + 148 desc += capture.group(1) + '\n'
162 else: 149 else:
163 break 150 break
164 <<
165 if not desc_present: <<
166 raise Exception("No description fo <<
167 return desc 151 return desc
168 152
169 def parse_ret(self, proto): !! 153 def parse_ret(self):
170 p = re.compile(r' \* ?(?:\t| {5,8})Ret !! 154 p = re.compile(' \* ?(?:\t| {5,8})Return$')
171 capture = p.match(self.line) 155 capture = p.match(self.line)
172 if not capture: 156 if not capture:
173 raise Exception("No return section !! 157 # Helper can have empty retval and we might be parsing another
>> 158 # attribute: return but do not consume.
>> 159 return ''
174 # Return value description can be seve 160 # Return value description can be several lines, some of them possibly
175 # empty, and it stops when another sub 161 # empty, and it stops when another subsection title is met.
176 ret = '' 162 ret = ''
177 ret_present = False <<
178 while True: 163 while True:
179 self.line = self.reader.readline() 164 self.line = self.reader.readline()
180 if self.line == ' *\n': 165 if self.line == ' *\n':
181 ret += '\n' 166 ret += '\n'
182 else: 167 else:
183 p = re.compile(r' \* ?(?:\t| { !! 168 p = re.compile(' \* ?(?:\t| {5,8})(?:\t| {8})(.*)')
184 capture = p.match(self.line) 169 capture = p.match(self.line)
185 if capture: 170 if capture:
186 ret_present = True <<
187 ret += capture.group(1) + 171 ret += capture.group(1) + '\n'
188 else: 172 else:
189 break 173 break
190 <<
191 if not ret_present: <<
192 raise Exception("No return found f <<
193 return ret 174 return ret
194 175
195 def seek_to(self, target, help_message, di !! 176 def seek_to(self, target, help_message):
196 self.reader.seek(0) 177 self.reader.seek(0)
197 offset = self.reader.read().find(targe 178 offset = self.reader.read().find(target)
198 if offset == -1: 179 if offset == -1:
199 raise Exception(help_message) 180 raise Exception(help_message)
200 self.reader.seek(offset) 181 self.reader.seek(offset)
201 self.reader.readline() 182 self.reader.readline()
202 for _ in range(discard_lines): !! 183 self.reader.readline()
203 self.reader.readline() <<
204 self.line = self.reader.readline() 184 self.line = self.reader.readline()
205 185
206 def parse_desc_syscall(self): !! 186 def parse_syscall(self):
207 self.seek_to('* DOC: eBPF Syscall Comm 187 self.seek_to('* DOC: eBPF Syscall Commands',
208 'Could not find start of 188 'Could not find start of eBPF syscall descriptions list')
209 while True: 189 while True:
210 try: 190 try:
211 command = self.parse_element() 191 command = self.parse_element()
212 self.commands.append(command) 192 self.commands.append(command)
213 self.desc_syscalls.append(comm <<
214 <<
215 except NoSyscallCommandFound: 193 except NoSyscallCommandFound:
216 break 194 break
217 195
218 def parse_enum_syscall(self): !! 196 def parse_helpers(self):
219 self.seek_to('enum bpf_cmd {', !! 197 self.seek_to('* Start of BPF helper function descriptions:',
220 'Could not find start of <<
221 # Searches for either one or more BPF\ <<
222 bpf_p = re.compile(r'\s*(BPF\w+)+') <<
223 # Searches for an enum entry assigned <<
224 # for e.g. BPF_PROG_RUN = BPF_PROG_TES <<
225 # not documented hence should be skipp <<
226 # determine if the right number of sys <<
227 assign_p = re.compile(r'\s*(BPF\w+)\s* <<
228 bpf_cmd_str = '' <<
229 while True: <<
230 capture = assign_p.match(self.line <<
231 if capture: <<
232 # Skip line if an enum entry i <<
233 self.line = self.reader.readli <<
234 continue <<
235 capture = bpf_p.match(self.line) <<
236 if capture: <<
237 bpf_cmd_str += self.line <<
238 else: <<
239 break <<
240 self.line = self.reader.readline() <<
241 # Find the number of occurences of BPF <<
242 self.enum_syscalls = re.findall(r'(BPF <<
243 <<
244 def parse_desc_helpers(self): <<
245 self.seek_to(helpersDocStart, <<
246 'Could not find start of 198 'Could not find start of eBPF helper descriptions list')
247 while True: 199 while True:
248 try: 200 try:
249 helper = self.parse_helper() 201 helper = self.parse_helper()
250 self.helpers.append(helper) 202 self.helpers.append(helper)
251 proto = helper.proto_break_dow <<
252 self.desc_unique_helpers.add(p <<
253 except NoHelperFound: 203 except NoHelperFound:
254 break 204 break
255 205
256 def parse_define_helpers(self): <<
257 # Parse FN(...) in #define ___BPF_FUNC <<
258 # number of unique function names pres <<
259 # correct enumeration value. <<
260 # Note: seek_to(..) discards the first <<
261 # resulting in FN(unspec, 0, ##ctx) be <<
262 # self.define_unique_helpers. <<
263 self.seek_to('#define ___BPF_FUNC_MAPP <<
264 'Could not find start of <<
265 # Searches for one FN(\w+) define or a <<
266 p = re.compile(r'\s*FN\((\w+), (\d+), <<
267 fn_defines_str = '' <<
268 i = 0 <<
269 while True: <<
270 capture = p.match(self.line) <<
271 if capture: <<
272 fn_defines_str += self.line <<
273 helper_name = capture.expand(r <<
274 self.helper_enum_vals[helper_n <<
275 self.helper_enum_pos[helper_na <<
276 i += 1 <<
277 else: <<
278 break <<
279 self.line = self.reader.readline() <<
280 # Find the number of occurences of FN( <<
281 self.define_unique_helpers = re.findal <<
282 <<
283 def validate_helpers(self): <<
284 last_helper = '' <<
285 seen_helpers = set() <<
286 seen_enum_vals = set() <<
287 i = 0 <<
288 for helper in self.helpers: <<
289 proto = helper.proto_break_down() <<
290 name = proto['name'] <<
291 try: <<
292 enum_val = self.helper_enum_va <<
293 enum_pos = self.helper_enum_po <<
294 except KeyError: <<
295 raise Exception("Helper %s is <<
296 <<
297 if name in seen_helpers: <<
298 if last_helper != name: <<
299 raise Exception("Helper %s <<
300 continue <<
301 <<
302 # Enforce current practice of havi <<
303 # by enum value. <<
304 if enum_pos != i: <<
305 raise Exception("Helper %s (ID <<
306 if enum_val in seen_enum_vals: <<
307 raise Exception("Helper %s has <<
308 <<
309 seen_helpers.add(name) <<
310 last_helper = name <<
311 seen_enum_vals.add(enum_val) <<
312 <<
313 helper.enum_val = enum_val <<
314 i += 1 <<
315 <<
316 def run(self): 206 def run(self):
317 self.parse_desc_syscall() !! 207 self.parse_syscall()
318 self.parse_enum_syscall() !! 208 self.parse_helpers()
319 self.parse_desc_helpers() <<
320 self.parse_define_helpers() <<
321 self.validate_helpers() <<
322 self.reader.close() 209 self.reader.close()
323 210
324 ############################################## 211 ###############################################################################
325 212
326 class Printer(object): 213 class Printer(object):
327 """ 214 """
328 A generic class for printers. Printers sho 215 A generic class for printers. Printers should be created with an array of
329 Helper objects, and implement a way to pri 216 Helper objects, and implement a way to print them in the desired fashion.
330 @parser: A HeaderParser with objects to pr 217 @parser: A HeaderParser with objects to print to standard output
331 """ 218 """
332 def __init__(self, parser): 219 def __init__(self, parser):
333 self.parser = parser 220 self.parser = parser
334 self.elements = [] 221 self.elements = []
335 222
336 def print_header(self): 223 def print_header(self):
337 pass 224 pass
338 225
339 def print_footer(self): 226 def print_footer(self):
340 pass 227 pass
341 228
342 def print_one(self, helper): 229 def print_one(self, helper):
343 pass 230 pass
344 231
345 def print_all(self): 232 def print_all(self):
346 self.print_header() 233 self.print_header()
347 for elem in self.elements: 234 for elem in self.elements:
348 self.print_one(elem) 235 self.print_one(elem)
349 self.print_footer() 236 self.print_footer()
350 237
351 def elem_number_check(self, desc_unique_el <<
352 """ <<
353 Checks the number of helpers/syscalls <<
354 description with those defined as part <<
355 Exception if they don't match. <<
356 """ <<
357 nr_desc_unique_elem = len(desc_unique_ <<
358 nr_define_unique_elem = len(define_uni <<
359 if nr_desc_unique_elem != nr_define_un <<
360 exception_msg = ''' <<
361 The number of unique %s in description (%d) do <<
362 ''' % (type, nr_desc_unique_elem, type, instan <<
363 if nr_desc_unique_elem < nr_define <<
364 # Function description is pars <<
365 # misformatting). Hence, only <<
366 exception_msg += ''' <<
367 The description for %s is not present or forma <<
368 ''' % (define_unique_elem[nr_desc_unique_elem] <<
369 raise Exception(exception_msg) <<
370 238
371 class PrinterRST(Printer): 239 class PrinterRST(Printer):
372 """ 240 """
373 A generic class for printers that print Re 241 A generic class for printers that print ReStructured Text. Printers should
374 be created with a HeaderParser object, and 242 be created with a HeaderParser object, and implement a way to print API
375 elements in the desired fashion. 243 elements in the desired fashion.
376 @parser: A HeaderParser with objects to pr 244 @parser: A HeaderParser with objects to print to standard output
377 """ 245 """
378 def __init__(self, parser): 246 def __init__(self, parser):
379 self.parser = parser 247 self.parser = parser
380 248
381 def print_license(self): 249 def print_license(self):
382 license = '''\ 250 license = '''\
383 .. Copyright (C) All BPF authors and contribut 251 .. Copyright (C) All BPF authors and contributors from 2014 to present.
384 .. See git log include/uapi/linux/bpf.h in ker 252 .. See git log include/uapi/linux/bpf.h in kernel tree for details.
385 .. 253 ..
386 .. SPDX-License-Identifier: Linux-man-pages-co !! 254 .. %%%LICENSE_START(VERBATIM)
>> 255 .. Permission is granted to make and distribute verbatim copies of this
>> 256 .. manual provided the copyright notice and this permission notice are
>> 257 .. preserved on all copies.
>> 258 ..
>> 259 .. Permission is granted to copy and distribute modified versions of this
>> 260 .. manual under the conditions for verbatim copying, provided that the
>> 261 .. entire resulting derived work is distributed under the terms of a
>> 262 .. permission notice identical to this one.
>> 263 ..
>> 264 .. Since the Linux kernel and libraries are constantly changing, this
>> 265 .. manual page may be incorrect or out-of-date. The author(s) assume no
>> 266 .. responsibility for errors or omissions, or for damages resulting from
>> 267 .. the use of the information contained herein. The author(s) may not
>> 268 .. have taken the same level of care in the production of this manual,
>> 269 .. which is licensed free of charge, as they might when working
>> 270 .. professionally.
>> 271 ..
>> 272 .. Formatted or processed versions of this manual, if unaccompanied by
>> 273 .. the source, must acknowledge the copyright and authors of this work.
>> 274 .. %%%LICENSE_END
387 .. 275 ..
388 .. Please do not edit this file. It was genera 276 .. Please do not edit this file. It was generated from the documentation
389 .. located in file include/uapi/linux/bpf.h of 277 .. located in file include/uapi/linux/bpf.h of the Linux kernel sources
390 .. (helpers description), and from scripts/bpf 278 .. (helpers description), and from scripts/bpf_doc.py in the same
391 .. repository (header and footer). 279 .. repository (header and footer).
392 ''' 280 '''
393 print(license) 281 print(license)
394 282
395 def print_elem(self, elem): 283 def print_elem(self, elem):
396 if (elem.desc): 284 if (elem.desc):
397 print('\tDescription') 285 print('\tDescription')
398 # Do not strip all newline charact 286 # Do not strip all newline characters: formatted code at the end of
399 # a section must be followed by a 287 # a section must be followed by a blank line.
400 for line in re.sub('\n$', '', elem 288 for line in re.sub('\n$', '', elem.desc, count=1).split('\n'):
401 print('{}{}'.format('\t\t' if 289 print('{}{}'.format('\t\t' if line else '', line))
402 290
403 if (elem.ret): 291 if (elem.ret):
404 print('\tReturn') 292 print('\tReturn')
405 for line in elem.ret.rstrip().spli 293 for line in elem.ret.rstrip().split('\n'):
406 print('{}{}'.format('\t\t' if 294 print('{}{}'.format('\t\t' if line else '', line))
407 295
408 print('') 296 print('')
409 297
410 def get_kernel_version(self): <<
411 try: <<
412 version = subprocess.run(['git', ' <<
413 capture_o <<
414 version = version.stdout.decode(). <<
415 except: <<
416 try: <<
417 version = subprocess.run(['mak <<
418 cwd=l <<
419 version = version.stdout.decod <<
420 except: <<
421 return 'Linux' <<
422 return 'Linux {version}'.format(versio <<
423 <<
424 def get_last_doc_update(self, delimiter): <<
425 try: <<
426 cmd = ['git', 'log', '-1', '--pret <<
427 '-L', <<
428 '/{}/,/\\*\\//:include/uapi <<
429 date = subprocess.run(cmd, cwd=lin <<
430 capture_outp <<
431 return date.stdout.decode().rstrip <<
432 except: <<
433 return '' <<
434 298
435 class PrinterHelpersRST(PrinterRST): 299 class PrinterHelpersRST(PrinterRST):
436 """ 300 """
437 A printer for dumping collected informatio 301 A printer for dumping collected information about helpers as a ReStructured
438 Text page compatible with the rst2man prog 302 Text page compatible with the rst2man program, which can be used to
439 generate a manual page for the helpers. 303 generate a manual page for the helpers.
440 @parser: A HeaderParser with Helper object 304 @parser: A HeaderParser with Helper objects to print to standard output
441 """ 305 """
442 def __init__(self, parser): 306 def __init__(self, parser):
443 self.elements = parser.helpers 307 self.elements = parser.helpers
444 self.elem_number_check(parser.desc_uni <<
445 308
446 def print_header(self): 309 def print_header(self):
447 header = '''\ 310 header = '''\
448 =========== 311 ===========
449 BPF-HELPERS 312 BPF-HELPERS
450 =========== 313 ===========
451 ---------------------------------------------- 314 -------------------------------------------------------------------------------
452 list of eBPF helper functions 315 list of eBPF helper functions
453 ---------------------------------------------- 316 -------------------------------------------------------------------------------
454 317
455 :Manual section: 7 318 :Manual section: 7
456 :Version: {version} <<
457 {date_field}{date} <<
458 319
459 DESCRIPTION 320 DESCRIPTION
460 =========== 321 ===========
461 322
462 The extended Berkeley Packet Filter (eBPF) sub 323 The extended Berkeley Packet Filter (eBPF) subsystem consists in programs
463 written in a pseudo-assembly language, then at 324 written in a pseudo-assembly language, then attached to one of the several
464 kernel hooks and run in reaction of specific e 325 kernel hooks and run in reaction of specific events. This framework differs
465 from the older, "classic" BPF (or "cBPF") in s 326 from the older, "classic" BPF (or "cBPF") in several aspects, one of them being
466 the ability to call special functions (or "hel 327 the ability to call special functions (or "helpers") from within a program.
467 These functions are restricted to a white-list 328 These functions are restricted to a white-list of helpers defined in the
468 kernel. 329 kernel.
469 330
470 These helpers are used by eBPF programs to int 331 These helpers are used by eBPF programs to interact with the system, or with
471 the context in which they work. For instance, 332 the context in which they work. For instance, they can be used to print
472 debugging messages, to get the time since the 333 debugging messages, to get the time since the system was booted, to interact
473 with eBPF maps, or to manipulate network packe 334 with eBPF maps, or to manipulate network packets. Since there are several eBPF
474 program types, and that they do not run in the 335 program types, and that they do not run in the same context, each program type
475 can only call a subset of those helpers. 336 can only call a subset of those helpers.
476 337
477 Due to eBPF conventions, a helper can not have 338 Due to eBPF conventions, a helper can not have more than five arguments.
478 339
479 Internally, eBPF programs call directly into t 340 Internally, eBPF programs call directly into the compiled helper functions
480 without requiring any foreign-function interfa 341 without requiring any foreign-function interface. As a result, calling helpers
481 introduces no overhead, thus offering excellen 342 introduces no overhead, thus offering excellent performance.
482 343
483 This document is an attempt to list and docume 344 This document is an attempt to list and document the helpers available to eBPF
484 developers. They are sorted by chronological o 345 developers. They are sorted by chronological order (the oldest helpers in the
485 kernel at the top). 346 kernel at the top).
486 347
487 HELPERS 348 HELPERS
488 ======= 349 =======
489 ''' 350 '''
490 kernelVersion = self.get_kernel_versio <<
491 lastUpdate = self.get_last_doc_update( <<
492 <<
493 PrinterRST.print_license(self) 351 PrinterRST.print_license(self)
494 print(header.format(version=kernelVers !! 352 print(header)
495 date_field = ':Dat <<
496 date=lastUpdate)) <<
497 353
498 def print_footer(self): 354 def print_footer(self):
499 footer = ''' 355 footer = '''
500 EXAMPLES 356 EXAMPLES
501 ======== 357 ========
502 358
503 Example usage for most of the eBPF helpers lis 359 Example usage for most of the eBPF helpers listed in this manual page are
504 available within the Linux kernel sources, at 360 available within the Linux kernel sources, at the following locations:
505 361
506 * *samples/bpf/* 362 * *samples/bpf/*
507 * *tools/testing/selftests/bpf/* 363 * *tools/testing/selftests/bpf/*
508 364
509 LICENSE 365 LICENSE
510 ======= 366 =======
511 367
512 eBPF programs can have an associated license, 368 eBPF programs can have an associated license, passed along with the bytecode
513 instructions to the kernel when the programs a 369 instructions to the kernel when the programs are loaded. The format for that
514 string is identical to the one in use for kern 370 string is identical to the one in use for kernel modules (Dual licenses, such
515 as "Dual BSD/GPL", may be used). Some helper f 371 as "Dual BSD/GPL", may be used). Some helper functions are only accessible to
516 programs that are compatible with the GNU Gene !! 372 programs that are compatible with the GNU Privacy License (GPL).
517 373
518 In order to use such helpers, the eBPF program 374 In order to use such helpers, the eBPF program must be loaded with the correct
519 license string passed (via **attr**) to the ** !! 375 license string passed (via **attr**) to the **bpf**\ () system call, and this
520 generally translates into the C source code of 376 generally translates into the C source code of the program containing a line
521 similar to the following: 377 similar to the following:
522 378
523 :: 379 ::
524 380
525 char ____license[] __attribute__((sect 381 char ____license[] __attribute__((section("license"), used)) = "GPL";
526 382
527 IMPLEMENTATION 383 IMPLEMENTATION
528 ============== 384 ==============
529 385
530 This manual page is an effort to document the 386 This manual page is an effort to document the existing eBPF helper functions.
531 But as of this writing, the BPF sub-system is 387 But as of this writing, the BPF sub-system is under heavy development. New eBPF
532 program or map types are added, along with new 388 program or map types are added, along with new helper functions. Some helpers
533 are occasionally made available for additional 389 are occasionally made available for additional program types. So in spite of
534 the efforts of the community, this page might 390 the efforts of the community, this page might not be up-to-date. If you want to
535 check by yourself what helper functions exist 391 check by yourself what helper functions exist in your kernel, or what types of
536 programs they can support, here are some files 392 programs they can support, here are some files among the kernel tree that you
537 may be interested in: 393 may be interested in:
538 394
539 * *include/uapi/linux/bpf.h* is the main BPF h 395 * *include/uapi/linux/bpf.h* is the main BPF header. It contains the full list
540 of all helper functions, as well as many oth 396 of all helper functions, as well as many other BPF definitions including most
541 of the flags, structs or constants used by t 397 of the flags, structs or constants used by the helpers.
542 * *net/core/filter.c* contains the definition 398 * *net/core/filter.c* contains the definition of most network-related helper
543 functions, and the list of program types fro 399 functions, and the list of program types from which they can be used.
544 * *kernel/trace/bpf_trace.c* is the equivalent 400 * *kernel/trace/bpf_trace.c* is the equivalent for most tracing program-related
545 helpers. 401 helpers.
546 * *kernel/bpf/verifier.c* contains the functio 402 * *kernel/bpf/verifier.c* contains the functions used to check that valid types
547 of eBPF maps are used with a given helper fu 403 of eBPF maps are used with a given helper function.
548 * *kernel/bpf/* directory contains other files 404 * *kernel/bpf/* directory contains other files in which additional helpers are
549 defined (for cgroups, sockmaps, etc.). 405 defined (for cgroups, sockmaps, etc.).
550 * The bpftool utility can be used to probe the 406 * The bpftool utility can be used to probe the availability of helper functions
551 on the system (as well as supported program 407 on the system (as well as supported program and map types, and a number of
552 other parameters). To do so, run **bpftool f 408 other parameters). To do so, run **bpftool feature probe** (see
553 **bpftool-feature**\\ (8) for details). Add !! 409 **bpftool-feature**\ (8) for details). Add the **unprivileged** keyword to
554 list features available to unprivileged user 410 list features available to unprivileged users.
555 411
556 Compatibility between helper functions and pro 412 Compatibility between helper functions and program types can generally be found
557 in the files where helper functions are define 413 in the files where helper functions are defined. Look for the **struct
558 bpf_func_proto** objects and for functions ret 414 bpf_func_proto** objects and for functions returning them: these functions
559 contain a list of helpers that a given program 415 contain a list of helpers that a given program type can call. Note that the
560 **default:** label of the **switch ... case** 416 **default:** label of the **switch ... case** used to filter helpers can call
561 other functions, themselves allowing access to 417 other functions, themselves allowing access to additional helpers. The
562 requirement for GPL license is also in those * 418 requirement for GPL license is also in those **struct bpf_func_proto**.
563 419
564 Compatibility between helper functions and map 420 Compatibility between helper functions and map types can be found in the
565 **check_map_func_compatibility**\\ () function !! 421 **check_map_func_compatibility**\ () function in file *kernel/bpf/verifier.c*.
566 422
567 Helper functions that invalidate the checks on 423 Helper functions that invalidate the checks on **data** and **data_end**
568 pointers for network processing are listed in 424 pointers for network processing are listed in function
569 **bpf_helper_changes_pkt_data**\\ () in file * !! 425 **bpf_helper_changes_pkt_data**\ () in file *net/core/filter.c*.
570 426
571 SEE ALSO 427 SEE ALSO
572 ======== 428 ========
573 429
574 **bpf**\\ (2), !! 430 **bpf**\ (2),
575 **bpftool**\\ (8), !! 431 **bpftool**\ (8),
576 **cgroups**\\ (7), !! 432 **cgroups**\ (7),
577 **ip**\\ (8), !! 433 **ip**\ (8),
578 **perf_event_open**\\ (2), !! 434 **perf_event_open**\ (2),
579 **sendmsg**\\ (2), !! 435 **sendmsg**\ (2),
580 **socket**\\ (7), !! 436 **socket**\ (7),
581 **tc-bpf**\\ (8)''' !! 437 **tc-bpf**\ (8)'''
582 print(footer) 438 print(footer)
583 439
584 def print_proto(self, helper): 440 def print_proto(self, helper):
585 """ 441 """
586 Format function protocol with bold and 442 Format function protocol with bold and italics markers. This makes RST
587 file less readable, but gives nice res 443 file less readable, but gives nice results in the manual page.
588 """ 444 """
589 proto = helper.proto_break_down() 445 proto = helper.proto_break_down()
590 446
591 print('**%s %s%s(' % (proto['ret_type' 447 print('**%s %s%s(' % (proto['ret_type'],
592 proto['ret_star' 448 proto['ret_star'].replace('*', '\\*'),
593 proto['name']), 449 proto['name']),
594 end='') 450 end='')
595 451
596 comma = '' 452 comma = ''
597 for a in proto['args']: 453 for a in proto['args']:
598 one_arg = '{}{}'.format(comma, a[' 454 one_arg = '{}{}'.format(comma, a['type'])
599 if a['name']: 455 if a['name']:
600 if a['star']: 456 if a['star']:
601 one_arg += ' {}**\\ '.form !! 457 one_arg += ' {}**\ '.format(a['star'].replace('*', '\\*'))
602 else: 458 else:
603 one_arg += '** ' 459 one_arg += '** '
604 one_arg += '*{}*\\ **'.format( 460 one_arg += '*{}*\\ **'.format(a['name'])
605 comma = ', ' 461 comma = ', '
606 print(one_arg, end='') 462 print(one_arg, end='')
607 463
608 print(')**') 464 print(')**')
609 465
610 def print_one(self, helper): 466 def print_one(self, helper):
611 self.print_proto(helper) 467 self.print_proto(helper)
612 self.print_elem(helper) 468 self.print_elem(helper)
613 469
614 470
615 class PrinterSyscallRST(PrinterRST): 471 class PrinterSyscallRST(PrinterRST):
616 """ 472 """
617 A printer for dumping collected informatio 473 A printer for dumping collected information about the syscall API as a
618 ReStructured Text page compatible with the 474 ReStructured Text page compatible with the rst2man program, which can be
619 used to generate a manual page for the sys 475 used to generate a manual page for the syscall.
620 @parser: A HeaderParser with APIElement ob 476 @parser: A HeaderParser with APIElement objects to print to standard
621 output 477 output
622 """ 478 """
623 def __init__(self, parser): 479 def __init__(self, parser):
624 self.elements = parser.commands 480 self.elements = parser.commands
625 self.elem_number_check(parser.desc_sys <<
626 481
627 def print_header(self): 482 def print_header(self):
628 header = '''\ 483 header = '''\
629 === 484 ===
630 bpf 485 bpf
631 === 486 ===
632 ---------------------------------------------- 487 -------------------------------------------------------------------------------
633 Perform a command on an extended BPF object 488 Perform a command on an extended BPF object
634 ---------------------------------------------- 489 -------------------------------------------------------------------------------
635 490
636 :Manual section: 2 491 :Manual section: 2
637 492
638 COMMANDS 493 COMMANDS
639 ======== 494 ========
640 ''' 495 '''
641 PrinterRST.print_license(self) 496 PrinterRST.print_license(self)
642 print(header) 497 print(header)
643 498
644 def print_one(self, command): 499 def print_one(self, command):
645 print('**%s**' % (command.proto)) 500 print('**%s**' % (command.proto))
646 self.print_elem(command) 501 self.print_elem(command)
647 502
648 503
649 class PrinterHelpers(Printer): 504 class PrinterHelpers(Printer):
650 """ 505 """
651 A printer for dumping collected informatio 506 A printer for dumping collected information about helpers as C header to
652 be included from BPF program. 507 be included from BPF program.
653 @parser: A HeaderParser with Helper object 508 @parser: A HeaderParser with Helper objects to print to standard output
654 """ 509 """
655 def __init__(self, parser): 510 def __init__(self, parser):
656 self.elements = parser.helpers 511 self.elements = parser.helpers
657 self.elem_number_check(parser.desc_uni <<
658 512
659 type_fwds = [ 513 type_fwds = [
660 'struct bpf_fib_lookup', 514 'struct bpf_fib_lookup',
661 'struct bpf_sk_lookup', 515 'struct bpf_sk_lookup',
662 'struct bpf_perf_event_data', 516 'struct bpf_perf_event_data',
663 'struct bpf_perf_event_value', 517 'struct bpf_perf_event_value',
664 'struct bpf_pidns_info', 518 'struct bpf_pidns_info',
665 'struct bpf_redir_neigh', 519 'struct bpf_redir_neigh',
666 'struct bpf_sock', 520 'struct bpf_sock',
667 'struct bpf_sock_addr', 521 'struct bpf_sock_addr',
668 'struct bpf_sock_ops', 522 'struct bpf_sock_ops',
669 'struct bpf_sock_tuple', 523 'struct bpf_sock_tuple',
670 'struct bpf_spin_lock', 524 'struct bpf_spin_lock',
671 'struct bpf_sysctl', 525 'struct bpf_sysctl',
672 'struct bpf_tcp_sock', 526 'struct bpf_tcp_sock',
673 'struct bpf_tunnel_key', 527 'struct bpf_tunnel_key',
674 'struct bpf_xfrm_state', 528 'struct bpf_xfrm_state',
675 'struct linux_binprm', 529 'struct linux_binprm',
676 'struct pt_regs', 530 'struct pt_regs',
677 'struct sk_reuseport_md', 531 'struct sk_reuseport_md',
678 'struct sockaddr', 532 'struct sockaddr',
679 'struct tcphdr', 533 'struct tcphdr',
680 'struct seq_file', 534 'struct seq_file',
681 'struct tcp6_sock', 535 'struct tcp6_sock',
682 'struct tcp_sock', 536 'struct tcp_sock',
683 'struct tcp_timewait_sock', 537 'struct tcp_timewait_sock',
684 'struct tcp_request_sock', 538 'struct tcp_request_sock',
685 'struct udp6_sock', 539 'struct udp6_sock',
686 'struct unix_sock', 540 'struct unix_sock',
687 'struct task_struct', 541 'struct task_struct',
688 'struct cgroup', <<
689 542
690 'struct __sk_buff', 543 'struct __sk_buff',
691 'struct sk_msg_md', 544 'struct sk_msg_md',
692 'struct xdp_md', 545 'struct xdp_md',
693 'struct path', 546 'struct path',
694 'struct btf_ptr', 547 'struct btf_ptr',
695 'struct inode', 548 'struct inode',
696 'struct socket', 549 'struct socket',
697 'struct file', 550 'struct file',
698 'struct bpf_timer', 551 'struct bpf_timer',
699 'struct mptcp_sock', <<
700 'struct bpf_dynptr', <<
701 'struct iphdr', <<
702 'struct ipv6hdr', <<
703 ] 552 ]
704 known_types = { 553 known_types = {
705 '...', 554 '...',
706 'void', 555 'void',
707 'const void', 556 'const void',
708 'char', 557 'char',
709 'const char', 558 'const char',
710 'int', 559 'int',
711 'long', 560 'long',
712 'unsigned long', 561 'unsigned long',
713 562
714 '__be16', 563 '__be16',
715 '__be32', 564 '__be32',
716 '__wsum', 565 '__wsum',
717 566
718 'struct bpf_fib_lookup', 567 'struct bpf_fib_lookup',
719 'struct bpf_perf_event_data', 568 'struct bpf_perf_event_data',
720 'struct bpf_perf_event_value', 569 'struct bpf_perf_event_value',
721 'struct bpf_pidns_info', 570 'struct bpf_pidns_info',
722 'struct bpf_redir_neigh', 571 'struct bpf_redir_neigh',
723 'struct bpf_sk_lookup', 572 'struct bpf_sk_lookup',
724 'struct bpf_sock', 573 'struct bpf_sock',
725 'struct bpf_sock_addr', 574 'struct bpf_sock_addr',
726 'struct bpf_sock_ops', 575 'struct bpf_sock_ops',
727 'struct bpf_sock_tuple', 576 'struct bpf_sock_tuple',
728 'struct bpf_spin_lock', 577 'struct bpf_spin_lock',
729 'struct bpf_sysctl', 578 'struct bpf_sysctl',
730 'struct bpf_tcp_sock', 579 'struct bpf_tcp_sock',
731 'struct bpf_tunnel_key', 580 'struct bpf_tunnel_key',
732 'struct bpf_xfrm_state', 581 'struct bpf_xfrm_state',
733 'struct linux_binprm', 582 'struct linux_binprm',
734 'struct pt_regs', 583 'struct pt_regs',
735 'struct sk_reuseport_md', 584 'struct sk_reuseport_md',
736 'struct sockaddr', 585 'struct sockaddr',
737 'struct tcphdr', 586 'struct tcphdr',
738 'struct seq_file', 587 'struct seq_file',
739 'struct tcp6_sock', 588 'struct tcp6_sock',
740 'struct tcp_sock', 589 'struct tcp_sock',
741 'struct tcp_timewait_sock', 590 'struct tcp_timewait_sock',
742 'struct tcp_request_sock', 591 'struct tcp_request_sock',
743 'struct udp6_sock', 592 'struct udp6_sock',
744 'struct unix_sock', 593 'struct unix_sock',
745 'struct task_struct', 594 'struct task_struct',
746 'struct cgroup', <<
747 'struct path', 595 'struct path',
748 'struct btf_ptr', 596 'struct btf_ptr',
749 'struct inode', 597 'struct inode',
750 'struct socket', 598 'struct socket',
751 'struct file', 599 'struct file',
752 'struct bpf_timer', 600 'struct bpf_timer',
753 'struct mptcp_sock', <<
754 'struct bpf_dynptr', <<
755 'const struct bpf_dynptr', <<
756 'struct iphdr', <<
757 'struct ipv6hdr', <<
758 } 601 }
759 mapped_types = { 602 mapped_types = {
760 'u8': '__u8', 603 'u8': '__u8',
761 'u16': '__u16', 604 'u16': '__u16',
762 'u32': '__u32', 605 'u32': '__u32',
763 'u64': '__u64', 606 'u64': '__u64',
764 's8': '__s8', 607 's8': '__s8',
765 's16': '__s16', 608 's16': '__s16',
766 's32': '__s32', 609 's32': '__s32',
767 's64': '__s64', 610 's64': '__s64',
768 'size_t': 'unsigned long', 611 'size_t': 'unsigned long',
769 'struct bpf_map': 'void', 612 'struct bpf_map': 'void',
770 'struct sk_buff': 'struct __sk_buf 613 'struct sk_buff': 'struct __sk_buff',
771 'const struct sk_buff': 'const str 614 'const struct sk_buff': 'const struct __sk_buff',
772 'struct sk_msg_buff': 'struct sk_m 615 'struct sk_msg_buff': 'struct sk_msg_md',
773 'struct xdp_buff': 'struct xdp_md' 616 'struct xdp_buff': 'struct xdp_md',
774 } 617 }
775 # Helpers overloaded for different context 618 # Helpers overloaded for different context types.
776 overloaded_helpers = [ 619 overloaded_helpers = [
777 'bpf_get_socket_cookie', 620 'bpf_get_socket_cookie',
778 'bpf_sk_assign', 621 'bpf_sk_assign',
779 ] 622 ]
780 623
781 def print_header(self): 624 def print_header(self):
782 header = '''\ 625 header = '''\
783 /* This is auto-generated file. See bpf_doc.py 626 /* This is auto-generated file. See bpf_doc.py for details. */
784 627
785 /* Forward declarations of BPF structs */''' 628 /* Forward declarations of BPF structs */'''
786 629
787 print(header) 630 print(header)
788 for fwd in self.type_fwds: 631 for fwd in self.type_fwds:
789 print('%s;' % fwd) 632 print('%s;' % fwd)
790 print('') 633 print('')
791 634
792 def print_footer(self): 635 def print_footer(self):
793 footer = '' 636 footer = ''
794 print(footer) 637 print(footer)
795 638
796 def map_type(self, t): 639 def map_type(self, t):
797 if t in self.known_types: 640 if t in self.known_types:
798 return t 641 return t
799 if t in self.mapped_types: 642 if t in self.mapped_types:
800 return self.mapped_types[t] 643 return self.mapped_types[t]
801 print("Unrecognized type '%s', please 644 print("Unrecognized type '%s', please add it to known types!" % t,
802 file=sys.stderr) 645 file=sys.stderr)
803 sys.exit(1) 646 sys.exit(1)
804 647
805 seen_helpers = set() 648 seen_helpers = set()
806 649
807 def print_one(self, helper): 650 def print_one(self, helper):
808 proto = helper.proto_break_down() 651 proto = helper.proto_break_down()
809 652
810 if proto['name'] in self.seen_helpers: 653 if proto['name'] in self.seen_helpers:
811 return 654 return
812 self.seen_helpers.add(proto['name']) 655 self.seen_helpers.add(proto['name'])
813 656
814 print('/*') 657 print('/*')
815 print(" * %s" % proto['name']) 658 print(" * %s" % proto['name'])
816 print(" *") 659 print(" *")
817 if (helper.desc): 660 if (helper.desc):
818 # Do not strip all newline charact 661 # Do not strip all newline characters: formatted code at the end of
819 # a section must be followed by a 662 # a section must be followed by a blank line.
820 for line in re.sub('\n$', '', help 663 for line in re.sub('\n$', '', helper.desc, count=1).split('\n'):
821 print(' *{}{}'.format(' \t' if 664 print(' *{}{}'.format(' \t' if line else '', line))
822 665
823 if (helper.ret): 666 if (helper.ret):
824 print(' *') 667 print(' *')
825 print(' * Returns') 668 print(' * Returns')
826 for line in helper.ret.rstrip().sp 669 for line in helper.ret.rstrip().split('\n'):
827 print(' *{}{}'.format(' \t' if 670 print(' *{}{}'.format(' \t' if line else '', line))
828 671
829 print(' */') 672 print(' */')
830 print('static %s %s(* const %s)(' % (s !! 673 print('static %s %s(*%s)(' % (self.map_type(proto['ret_type']),
831 proto['r 674 proto['ret_star'], proto['name']), end='')
832 comma = '' 675 comma = ''
833 for i, a in enumerate(proto['args']): 676 for i, a in enumerate(proto['args']):
834 t = a['type'] 677 t = a['type']
835 n = a['name'] 678 n = a['name']
836 if proto['name'] in self.overloade 679 if proto['name'] in self.overloaded_helpers and i == 0:
837 t = 'void' 680 t = 'void'
838 n = 'ctx' 681 n = 'ctx'
839 one_arg = '{}{}'.format(comma, sel 682 one_arg = '{}{}'.format(comma, self.map_type(t))
840 if n: 683 if n:
841 if a['star']: 684 if a['star']:
842 one_arg += ' {}'.format(a[ 685 one_arg += ' {}'.format(a['star'])
843 else: 686 else:
844 one_arg += ' ' 687 one_arg += ' '
845 one_arg += '{}'.format(n) 688 one_arg += '{}'.format(n)
846 comma = ', ' 689 comma = ', '
847 print(one_arg, end='') 690 print(one_arg, end='')
848 691
849 print(') = (void *) %d;' % helper.enum !! 692 print(') = (void *) %d;' % len(self.seen_helpers))
850 print('') 693 print('')
851 694
852 ############################################## 695 ###############################################################################
853 696
854 # If script is launched from scripts/ from ker 697 # If script is launched from scripts/ from kernel tree and can access
855 # ../include/uapi/linux/bpf.h, use it as a def 698 # ../include/uapi/linux/bpf.h, use it as a default name for the file to parse,
856 # otherwise the --filename argument will be re 699 # otherwise the --filename argument will be required from the command line.
857 script = os.path.abspath(sys.argv[0]) 700 script = os.path.abspath(sys.argv[0])
858 linuxRoot = os.path.dirname(os.path.dirname(sc 701 linuxRoot = os.path.dirname(os.path.dirname(script))
859 bpfh = os.path.join(linuxRoot, 'include/uapi/l 702 bpfh = os.path.join(linuxRoot, 'include/uapi/linux/bpf.h')
860 703
861 printers = { 704 printers = {
862 'helpers': PrinterHelpersRST, 705 'helpers': PrinterHelpersRST,
863 'syscall': PrinterSyscallRST, 706 'syscall': PrinterSyscallRST,
864 } 707 }
865 708
866 argParser = argparse.ArgumentParser(descriptio 709 argParser = argparse.ArgumentParser(description="""
867 Parse eBPF header file and generate documentat 710 Parse eBPF header file and generate documentation for the eBPF API.
868 The RST-formatted output produced can be turne 711 The RST-formatted output produced can be turned into a manual page with the
869 rst2man utility. 712 rst2man utility.
870 """) 713 """)
871 argParser.add_argument('--header', action='sto 714 argParser.add_argument('--header', action='store_true',
872 help='generate C header 715 help='generate C header file')
873 if (os.path.isfile(bpfh)): 716 if (os.path.isfile(bpfh)):
874 argParser.add_argument('--filename', help= 717 argParser.add_argument('--filename', help='path to include/uapi/linux/bpf.h',
875 default=bpfh) 718 default=bpfh)
876 else: 719 else:
877 argParser.add_argument('--filename', help= 720 argParser.add_argument('--filename', help='path to include/uapi/linux/bpf.h')
878 argParser.add_argument('target', nargs='?', de 721 argParser.add_argument('target', nargs='?', default='helpers',
879 choices=printers.keys() 722 choices=printers.keys(), help='eBPF API target')
880 args = argParser.parse_args() 723 args = argParser.parse_args()
881 724
882 # Parse file. 725 # Parse file.
883 headerParser = HeaderParser(args.filename) 726 headerParser = HeaderParser(args.filename)
884 headerParser.run() 727 headerParser.run()
885 728
886 # Print formatted output to standard output. 729 # Print formatted output to standard output.
887 if args.header: 730 if args.header:
888 if args.target != 'helpers': 731 if args.target != 'helpers':
889 raise NotImplementedError('Only helper 732 raise NotImplementedError('Only helpers header generation is supported')
890 printer = PrinterHelpers(headerParser) 733 printer = PrinterHelpers(headerParser)
891 else: 734 else:
892 printer = printers[args.target](headerPars 735 printer = printers[args.target](headerParser)
893 printer.print_all() 736 printer.print_all()
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.