blob: 4c2096e6b912dc22a4d6f9b1e5c06561b349ead3 [file] [log] [blame]
Justin DeMartinocc397382019-11-05 15:59:43 -08001# Copyright 2019 Google Inc. All rights reserved.
2#
3# Licensed under the Apache License, Version 2.0 (the "License");
4# you may not use this file except in compliance with the License.
5# You may obtain a copy of the License at
6#
7# http://www.apache.org/licenses/LICENSE-2.0
8#
9# Unless required by applicable law or agreed to in writing, software
10# distributed under the License is distributed on an "AS IS" BASIS,
11# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12# See the License for the specific language governing permissions and
13# limitations under the License.
14
15"""Generates gen_headers_<arch>.bp or generates/checks kernel headers."""
16
17from __future__ import absolute_import
18from __future__ import division
19from __future__ import print_function
20
21import argparse
22import filecmp
23import os
24import re
25import subprocess
26import sys
27
28
29def gen_version_h(verbose, gen_dir, version_makefile):
30 """Generate linux/version.h
31
32 Scan the version_makefile for the version info, and then generate
33 linux/version.h in the gen_dir as done in kernel Makefile function
34 filechk_version.h
35
36 Args:
37 verbose: Set True to print progress messages.
38 gen_dir: Where to place the generated files.
39 version_makefile: The makefile that contains version info.
40 Return:
41 If version info not found, False. Otherwise, True.
42 """
43
44 version_re = re.compile(r'VERSION\s*=\s*(\d+)')
45 patchlevel_re = re.compile(r'PATCHLEVEL\s*=\s*(\d+)')
46 sublevel_re = re.compile(r'SUBLEVEL\s*=\s*(\d+)')
47
48 version_str = None
49 patchlevel_str = None
50 sublevel_str = None
51
52 if verbose:
53 print('gen_version_h: processing [%s]' % version_makefile)
54
55 with open(version_makefile, 'r') as f:
56 while not version_str or not patchlevel_str or not sublevel_str:
57 line = f.readline()
58
59 if not line:
60 print(
61 'error: gen_version_h: failed to parse kernel version from %s' %
62 version_makefile)
63 return False
64
65 line = line.rstrip()
66
67 if verbose:
68 print('gen_version_h: line is %s' % line)
69
70 if not version_str:
71 match = version_re.match(line)
72 if match:
73 if verbose:
74 print('gen_version_h: matched version [%s]' % line)
75 version_str = match.group(1)
76 continue
77
78 if not patchlevel_str:
79 match = patchlevel_re.match(line)
80 if match:
81 if verbose:
82 print('gen_version_h: matched patchlevel [%s]' % line)
83 patchlevel_str = match.group(1)
84 continue
85
86 if not sublevel_str:
87 match = sublevel_re.match(line)
88 if match:
89 if verbose:
90 print('gen_version_h: matched sublevel [%s]' % line)
91 sublevel_str = match.group(1)
92 continue
93
94 version = int(version_str)
95 patchlevel = int(patchlevel_str)
96 sublevel = int(sublevel_str)
97
98 if verbose:
99 print(
100 'gen_version_h: found kernel version %d.%d.%d' %
101 (version, patchlevel, sublevel))
102
103 version_h = os.path.join(gen_dir, 'linux', 'version.h')
104
105 with open(version_h, 'w') as f:
106 # This code must match the code in Makefile in the make function
107 # filechk_version.h
108 version_code = (version << 16) + (patchlevel << 8) + sublevel
109 f.write('#define LINUX_VERSION_CODE %d\n' % version_code)
110 f.write(
111 '#define KERNEL_VERSION(a,b,c) ' +
112 '(((a) << 16) + ((b) << 8) + (c))\n')
113
114 return True
115
116
117def scan_arch_kbuild(verbose, arch_asm_kbuild, asm_generic_kbuild, arch_include_uapi):
118 """Scan arch_asm_kbuild for generated headers.
119
120 This function processes the Kbuild file to scan for three types of files that
121 need to be generated. The first type are syscall generated headers, which are
122 identified by adding to the generated-y make variable. The second type are
123 generic headers, which are arch-specific headers that simply wrap the
124 asm-generic counterpart, and are identified by adding to the generic-y make
125 variable. The third type are mandatory headers that should be present in the
126 /usr/include/asm folder.
127
128 Args:
129 verbose: Set True to print progress messages.
130 arch_asm_kbuild: The Kbuild file containing lists of headers to generate.
131 asm_generic_kbuild: The Kbuild file containing lists of mandatory headers.
132 arch_include_uapi: Headers in /arch/<arch>/include/uapi directory
133 Return:
134 Two lists of discovered headers, one for generated and one for generic.
135 """
136
137 generated_y_re = re.compile(r'generated-y\s*\+=\s*(\S+)')
138 generic_y_re = re.compile(r'generic-y\s*\+=\s*(\S+)')
139 mandatory_y_re = re.compile(r'mandatory-y\s*\+=\s*(\S+)')
140
141 # This loop parses arch_asm_kbuild for various kinds of headers to generate.
142
143 if verbose:
144 print('scan_arch_kbuild: processing [%s]' % arch_asm_kbuild)
145
146 generated_list = []
147 generic_list = []
148 arch_include_uapi_list = [os.path.basename(x) for x in arch_include_uapi]
149 mandatory_pre_list = []
150 mandatory_list = []
151
152
153 with open(arch_asm_kbuild, 'r') as f:
154 while True:
155 line = f.readline()
156
157 if not line:
158 break
159
160 line = line.rstrip()
161
162 if verbose:
163 print('scan_arch_kbuild: line is %s' % line)
164
165 match = generated_y_re.match(line)
166
167 if match:
168 if verbose:
169 print('scan_arch_kbuild: matched [%s]' % line)
170 generated_list.append(match.group(1))
171 continue
172
173 match = generic_y_re.match(line)
174
175 if match:
176 if verbose:
177 print('scan_arch_kbuild: matched [%s]' % line)
178 generic_list.append(match.group(1))
179 continue
180
181 # This loop parses asm_generic_kbuild for various kinds of headers to generate.
182
183 if verbose:
184 print('scan_arch_kbuild: processing [%s]' % asm_generic_kbuild)
185
186 with open(asm_generic_kbuild, 'r') as f:
187 while True:
188 line = f.readline()
189
190 if not line:
191 break
192
193 line = line.rstrip()
194
195 if verbose:
196 print('scan_arch_kbuild: line is %s' % line)
197
198 match = mandatory_y_re.match(line)
199
200 if match:
201 if verbose:
202 print('scan_arch_kbuild: matched [%s]' % line)
203 mandatory_pre_list.append(match.group(1))
204 continue
205
206 # Mandatory headers need to be generated if they are not already generated.
207 comb_list = generic_list + generated_list + arch_include_uapi_list
208 mandatory_list = [x for x in mandatory_pre_list if x not in comb_list]
209 if verbose:
210 print("generic")
211 for x in generic_list:
212 print(x)
213 print("generated")
214 for x in generated_list:
215 print(x)
216 print("mandatory")
217 for x in mandatory_list:
218 print(x)
219 print("arch_include_uapi_list")
220 for x in arch_include_uapi_list:
221 print(x)
222
223 return (generated_list, generic_list, mandatory_list)
224
225
226def gen_arch_headers(
227 verbose, gen_dir, arch_asm_kbuild, asm_generic_kbuild, arch_syscall_tool, arch_syscall_tbl, arch_include_uapi):
228 """Process arch-specific and asm-generic uapi/asm/Kbuild to generate headers.
229
230 The function consists of a call to scan_arch_kbuild followed by three loops.
231 The first loop generates headers found and placed in the generated_list by
232 scan_arch_kbuild. The second loop generates headers found and placed in the
233 generic_list by the scan_arch_kbuild. The third loop generates headers found
234 in mandatory_list by scan_arch_kbuild.
235
236 The function does some parsing of file names and tool invocations. If that
237 parsing fails for some reason (e.g., we don't know how to generate the
238 header) or a tool invocation fails, then this function will count that as
239 an error but keep processing. In the end, the function returns the number of
240 errors encountered.
241
242 Args:
243 verbose: Set True to print progress messages.
244 gen_dir: Where to place the generated files.
245 arch_asm_kbuild: The Kbuild file containing lists of headers to generate.
246 asm_generic_kbuild: The Kbuild file containing lists of mandatory headers.
247 arch_syscall_tool: The arch script that generates syscall headers, or None.
248 arch_syscall_tbl: The arch script that defines syscall vectors, or None.
249 arch_include_uapi: Headers in arch/<arch>/include/uapi directory.
250 Return:
251 The number of parsing errors encountered.
252 """
253
254 error_count = 0
255
256 # First generate the lists
257
258 (generated_list, generic_list, mandatory_list) = scan_arch_kbuild(verbose, arch_asm_kbuild, asm_generic_kbuild ,arch_include_uapi)
259
260 # Now we're at the first loop, which is able to generate syscall headers
261 # found in the first loop, and placed in generated_list. It's okay for this
262 # list to be empty. In that case, of course, the loop does nothing.
263
264 abi_re = re.compile(r'unistd-(\S+)\.h')
265
266 for generated in generated_list:
267 gen_h = os.path.join(gen_dir, 'asm', generated)
268 match = abi_re.match(generated)
269
270 if match:
271 abi = match.group(1)
272
273 cmd = [
274 '/bin/bash',
275 arch_syscall_tool,
276 arch_syscall_tbl,
277 gen_h,
278 abi,
279 '',
280 '__NR_SYSCALL_BASE',
281 ]
282
283 if verbose:
284 print('gen_arch_headers: cmd is %s' % cmd)
285
286 result = subprocess.call(cmd)
287
288 if result != 0:
289 print('error: gen_arch_headers: cmd %s failed %d' % (cmd, result))
290 error_count += 1
291 else:
292 print('error: gen_arch_headers: syscall header has bad filename: %s' % generated)
293 error_count += 1
294
295 # Now we're at the second loop, which generates wrappers from arch-specific
296 # headers listed in generic_list to the corresponding asm-generic header.
297
298 for generic in generic_list:
299 wrap_h = os.path.join(gen_dir, 'asm', generic)
300 with open(wrap_h, 'w') as f:
301 f.write('#include <asm-generic/%s>\n' % generic)
302
303 # Now we're at the third loop, which generates wrappers from asm
304 # headers listed in mandatory_list to the corresponding asm-generic header.
305
306 for mandatory in mandatory_list:
307 wrap_h = os.path.join(gen_dir, 'asm', mandatory)
308 with open(wrap_h, 'w') as f:
309 f.write('#include <asm-generic/%s>\n' % mandatory)
310 return error_count
311
312
313def run_headers_install(verbose, gen_dir, headers_install, prefix, h):
314 """Process a header through the headers_install script.
315
316 The headers_install script does some processing of a header so that it is
317 appropriate for inclusion in a userland program. This function invokes that
318 script for one header file.
319
320 The input file is a header file found in the directory named by prefix. This
321 function stips the prefix from the header to generate the name of the
322 processed header.
323
324 Args:
325 verbose: Set True to print progress messages.
326 gen_dir: Where to place the generated files.
327 headers_install: The script that munges the header.
328 prefix: The prefix to strip from h to generate the output filename.
329 h: The input header to process.
330 Return:
331 If parsing or the tool fails, False. Otherwise, True
332 """
333
334 if not h.startswith(prefix):
335 print('error: expected prefix [%s] on header [%s]' % (prefix, h))
336 return False
337
338 out_h = os.path.join(gen_dir, h[len(prefix):])
339 (out_h_dirname, out_h_basename) = os.path.split(out_h)
340 h_dirname = os.path.dirname(h)
341
342 cmd = [headers_install, out_h_dirname, h_dirname, out_h_basename]
343
344 if verbose:
345 print('run_headers_install: cmd is %s' % cmd)
346
347 result = subprocess.call(cmd)
348
349 if result != 0:
350 print('error: run_headers_install: cmd %s failed %d' % (cmd, result))
351 return False
352
353 return True
354
355
356def glob_headers(prefix, rel_glob, excludes):
357 """Recursively scan the a directory for headers.
358
359 This function recursively scans the directory identified by prefix for
360 headers. We don't yet have a new enough version of python3 to use the
361 better glob function, so right now we assume the glob is '**/*.h'.
362
363 The function filters out any files that match the items in excludes.
364
365 Args:
366 prefix: The directory to recursively scan for headers.
367 rel_glob: The shell-style glob that identifies the header pattern.
368 excludes: A list of headers to exclude from the glob.
369 Return:
370 A list of headers discovered with excludes excluded.
371 """
372
373 # If we had python 3.5+, we could use the fancy new glob.glob.
374 # full_glob = os.path.join(prefix, rel_glob)
375 # full_srcs = glob.glob(full_glob, recursive=True)
376
377 full_dirs = [prefix]
378 full_srcs = []
379
380 while full_dirs:
381 full_dir = full_dirs.pop(0)
382 items = sorted(os.listdir(full_dir))
383
384 for item in items:
385 full_item = os.path.join(full_dir, item)
386
387 if os.path.isdir(full_item):
388 full_dirs.append(full_item)
389 continue
390
391 if full_item in excludes:
392 continue
393
394 if full_item.endswith('.h'):
395 full_srcs.append(full_item)
396
397 return full_srcs
398
399
400def find_out(verbose, module_dir, prefix, rel_glob, excludes, outs):
401 """Build a list of outputs for the genrule that creates kernel headers.
402
403 This function scans for headers in the source tree and produces a list of
404 output (generated) headers.
405
406 Args:
407 verbose: Set True to print progress messages.
408 module_dir: The root directory of the kernel source.
409 prefix: The prefix with in the kernel source tree to search for headers.
410 rel_glob: The pattern to use when matching headers under prefix.
411 excludes: A list of files to exclude from the glob.
412 outs: The list to populdate with the headers that will be generated.
413 Return:
414 The number of errors encountered.
415 """
416
417 # Turn prefix, which is relative to the soong module, to a full prefix that
418 # is relative to the Android source tree.
419
420 full_prefix = os.path.join(module_dir, prefix)
421
422 # Convert the list of excludes, which are relative to the soong module, to a
423 # set of excludes (for easy hashing), relative to the Android source tree.
424
425 full_excludes = set()
426
427 if excludes:
428 for exclude in excludes:
429 full_exclude = os.path.join(full_prefix, exclude)
430 full_excludes.add(full_exclude)
431
432 # Glob those headers.
433
434 full_srcs = glob_headers(full_prefix, rel_glob, full_excludes)
435
436 # Now convert the file names, which are relative to the Android source tree,
437 # to be relative to the gen dir. This means stripping off the module prefix
438 # and the directory within this module.
439
440 module_dir_sep = module_dir + os.sep
441 prefix_sep = prefix + os.sep
442
443 if verbose:
444 print('find_out: module_dir_sep [%s]' % module_dir_sep)
445 print('find_out: prefix_sep [%s]' % prefix_sep)
446
447 error_count = 0
448
449 for full_src in full_srcs:
450 if verbose:
451 print('find_out: full_src [%s]' % full_src)
452
453 if not full_src.startswith(module_dir_sep):
454 print('error: expected %s to start with %s' % (full_src, module_dir_sep))
455 error_count += 1
456 continue
457
458 local_src = full_src[len(module_dir_sep):]
459
460 if verbose:
461 print('find_out: local_src [%s]' % local_src)
462
463 if not local_src.startswith(prefix_sep):
464 print('error: expected %s to start with %s' % (local_src, prefix_sep))
465 error_count += 1
466 continue
467
468 # After stripping the module directory and the prefix, we're left with the
469 # name of a header that we'll generate, relative to the base of of a the
470 # the include path.
471
472 local_out = local_src[len(prefix_sep):]
473
474 if verbose:
475 print('find_out: local_out [%s]' % local_out)
476
477 outs.append(local_out)
478
479 return error_count
480
481
482def gen_blueprints(
483 verbose, header_arch, gen_dir, arch_asm_kbuild, asm_generic_kbuild, module_dir,
484 rel_arch_asm_kbuild, rel_asm_generic_kbuild, arch_include_uapi, techpack_include_uapi):
485 """Generate a blueprints file containing modules that invoke this script.
486
487 This function generates a blueprints file that contains modules that
488 invoke this script to generate kernel headers. We generate the blueprints
489 file as needed, but we don't actually use the generated file. The blueprints
490 file that we generate ends up in the out directory, and we can use it to
491 detect if the checked-in version of the file (in the source directory) is out
492 of date. This pattern occurs in the Android source tree in several places.
493
494 Args:
495 verbose: Set True to print progress messages.
496 header_arch: The arch for which to generate headers.
497 gen_dir: Where to place the generated files.
498 arch_asm_kbuild: The Kbuild file containing lists of headers to generate.
499 asm_generic_kbuild: The Kbuild file containing lists of mandatory headers.
500 module_dir: The root directory of the kernel source.
501 rel_arch_asm_kbuild: arch_asm_kbuild relative to module_dir.
502 Return:
503 The number of errors encountered.
504 """
505 error_count = 0
506
507 # The old and new blueprints files. We generate the new one, but we need to
508 # refer to the old one in the modules that we generate.
509 old_gen_headers_bp = 'gen_headers_%s.bp' % header_arch
510 new_gen_headers_bp = os.path.join(gen_dir, old_gen_headers_bp)
511
512 # Tools and tool files.
513 headers_install_sh = 'headers_install.sh'
514 kernel_headers_py = 'kernel_headers.py'
515 arm_syscall_tool = 'arch/arm/tools/syscallhdr.sh'
516
517 # Sources
518 makefile = 'Makefile'
519 arm_syscall_tbl = 'arch/arm/tools/syscall.tbl'
520 rel_glob = '**/*.h'
521 generic_prefix = 'include/uapi'
522 arch_prefix = os.path.join('arch', header_arch, generic_prefix)
523 generic_src = os.path.join(generic_prefix, rel_glob)
524 arch_src = os.path.join(arch_prefix, rel_glob)
Rishabh Bhatnagar119960e2020-02-12 13:50:44 -0800525 techpack_src = os.path.join('techpack/*',generic_prefix, '*',rel_glob)
Justin DeMartinocc397382019-11-05 15:59:43 -0800526
527 # Excluded sources, architecture specific.
528 exclude_srcs = []
529
530 if header_arch == "arm":
531 exclude_srcs = ['linux/a.out.h']
532
533 if header_arch == "arm64":
534 exclude_srcs = ['linux/a.out.h', 'linux/kvm_para.h']
535
536 # Scan the arch_asm_kbuild file for files that need to be generated and those
537 # that are generic (i.e., need to be wrapped).
538
539 (generated_list, generic_list, mandatory_list) = scan_arch_kbuild(verbose,
540 arch_asm_kbuild, asm_generic_kbuild, arch_include_uapi)
541
542 generic_out = []
543 error_count += find_out(
544 verbose, module_dir, generic_prefix, rel_glob, exclude_srcs, generic_out)
545
546 arch_out = []
547 error_count += find_out(
548 verbose, module_dir, arch_prefix, rel_glob, None, arch_out)
549
550 techpack_out = [x.split('include/uapi/')[1] for x in techpack_include_uapi]
551
552 if error_count != 0:
553 return error_count
554
555 # Generate the blueprints file.
556
557 if verbose:
558 print('gen_blueprints: generating %s' % new_gen_headers_bp)
559
560 with open(new_gen_headers_bp, 'w') as f:
561 f.write('// ***** DO NOT EDIT *****\n')
562 f.write('// This file is generated by %s\n' % kernel_headers_py)
563 f.write('\n')
Rishabh Bhatnagar119960e2020-02-12 13:50:44 -0800564 f.write('gen_headers_srcs_%s = [\n' % header_arch)
565 f.write(' "%s",\n' % rel_arch_asm_kbuild)
566 f.write(' "%s",\n' % rel_asm_generic_kbuild)
567 f.write(' "%s",\n' % makefile)
568
569 if header_arch == "arm":
570 f.write(' "%s",\n' % arm_syscall_tbl)
571
572 f.write(' "%s",\n' % generic_src)
573 f.write(' "%s",\n' % arch_src)
574 f.write(' "%s",\n' % techpack_src)
575 f.write(']\n')
576 f.write('\n')
577
578 if exclude_srcs:
579 f.write('gen_headers_exclude_srcs_%s = [\n' % header_arch)
580 for h in exclude_srcs:
581 f.write(' "%s",\n' % os.path.join(generic_prefix, h))
582 f.write(']\n')
583 f.write('\n')
584
585 f.write('gen_headers_out_%s = [\n' % header_arch)
Justin DeMartinocc397382019-11-05 15:59:43 -0800586
587 if generated_list:
588 f.write('\n')
589 f.write(' // Matching generated-y:\n')
590 f.write('\n')
591 for h in generated_list:
592 f.write(' "asm/%s",\n' % h)
593
594 if generic_list:
595 f.write('\n')
596 f.write(' // Matching generic-y:\n')
597 f.write('\n')
598 for h in generic_list:
599 f.write(' "asm/%s",\n' % h)
600
601 if mandatory_list:
602 f.write('\n')
603 f.write(' // Matching mandatory-y:\n')
604 f.write('\n')
605 for h in mandatory_list:
606 f.write(' "asm/%s",\n' % h)
607
608 if generic_out:
609 f.write('\n')
610 f.write(' // From %s\n' % generic_src)
611 f.write('\n')
612 for h in generic_out:
613 f.write(' "%s",\n' % h)
614
615 if arch_out:
616 f.write('\n')
617 f.write(' // From %s\n' % arch_src)
618 f.write('\n')
619 for h in arch_out:
620 f.write(' "%s",\n' % h)
621
622 if techpack_out:
623 f.write('\n')
624 f.write(' // From %s\n' % techpack_src)
625 f.write('\n')
626 for h in techpack_out:
627 f.write(' "%s",\n' % h)
628
629 f.write(']\n')
630 f.write('\n')
631
632 gen_blueprints_module_name = 'qti_generate_gen_headers_%s' % header_arch
633
634 f.write('genrule {\n')
635 f.write(' // This module generates the gen_headers_<arch>.bp file\n')
636 f.write(' // (i.e., a new version of this file) so that it can be\n')
637 f.write(' // checked later to ensure that it matches the checked-\n')
638 f.write(' // in version (this file).\n')
639 f.write(' name: "%s",\n' % gen_blueprints_module_name)
Rishabh Bhatnagar119960e2020-02-12 13:50:44 -0800640 f.write(' srcs: gen_headers_srcs_%s,\n' % header_arch)
641 if exclude_srcs:
642 f.write(' exclude_srcs: gen_headers_exclude_srcs_%s,\n' % header_arch)
643
Justin DeMartinocc397382019-11-05 15:59:43 -0800644 f.write(' tool_files: ["kernel_headers.py"],\n')
645 f.write(' cmd: "python3 $(location kernel_headers.py) " +\n')
646 f.write(' kernel_headers_verbose +\n')
647 f.write(' "--header_arch %s " +\n' % header_arch)
648 f.write(' "--gen_dir $(genDir) " +\n')
649 f.write(' "--arch_asm_kbuild $(location %s) " +\n' % rel_arch_asm_kbuild)
650 f.write(' "--arch_include_uapi $(locations %s) " +\n' % arch_src)
Rishabh Bhatnagar119960e2020-02-12 13:50:44 -0800651 f.write(' "--techpack_include_uapi $(locations %s) " +\n' % techpack_src)
Justin DeMartinocc397382019-11-05 15:59:43 -0800652 f.write(' "--asm_generic_kbuild $(location %s) " +\n' % rel_asm_generic_kbuild)
Rishabh Bhatnagar119960e2020-02-12 13:50:44 -0800653 f.write(' "blueprints " +\n')
654 f.write(' "# $(in)",\n')
Justin DeMartinocc397382019-11-05 15:59:43 -0800655 f.write(' out: ["gen_headers_%s.bp"],\n' % header_arch)
656 f.write('}\n')
657 f.write('\n')
658
659 f.write('genrule {\n')
660 f.write(' name: "qti_generate_kernel_headers_%s",\n' % header_arch)
661 f.write(' tools: ["%s"],\n' % headers_install_sh)
662 f.write(' tool_files: [\n')
663 f.write(' "%s",\n' % kernel_headers_py)
664
665 if header_arch == "arm":
666 f.write(' "%s",\n' % arm_syscall_tool)
667
668 f.write(' ],\n')
Rishabh Bhatnagar119960e2020-02-12 13:50:44 -0800669 f.write(' srcs: gen_headers_srcs_%s +[\n' % header_arch)
Justin DeMartinocc397382019-11-05 15:59:43 -0800670 f.write(' "%s",\n' % old_gen_headers_bp)
671 f.write(' ":%s",\n' % gen_blueprints_module_name)
Justin DeMartinocc397382019-11-05 15:59:43 -0800672 f.write(' ],\n')
673
674 if exclude_srcs:
Rishabh Bhatnagar119960e2020-02-12 13:50:44 -0800675 f.write(' exclude_srcs: gen_headers_exclude_srcs_%s,\n' % header_arch)
Justin DeMartinocc397382019-11-05 15:59:43 -0800676
677 f.write(' cmd: "python3 $(location %s) " +\n' % kernel_headers_py)
678 f.write(' kernel_headers_verbose +\n')
679 f.write(' "--header_arch %s " +\n' % header_arch)
680 f.write(' "--gen_dir $(genDir) " +\n')
681 f.write(' "--arch_asm_kbuild $(location %s) " +\n' % rel_arch_asm_kbuild)
682 f.write(' "--arch_include_uapi $(locations %s) " +\n' % arch_src)
Rishabh Bhatnagar119960e2020-02-12 13:50:44 -0800683 f.write(' "--techpack_include_uapi $(locations %s) " +\n' % techpack_src)
Justin DeMartinocc397382019-11-05 15:59:43 -0800684 f.write(' "--asm_generic_kbuild $(location %s) " +\n' % rel_asm_generic_kbuild)
685 f.write(' "headers " +\n')
686 f.write(' "--old_gen_headers_bp $(location %s) " +\n' % old_gen_headers_bp)
687 f.write(' "--new_gen_headers_bp $(location :%s) " +\n' % gen_blueprints_module_name)
688 f.write(' "--version_makefile $(location %s) " +\n' % makefile)
689
690 if header_arch == "arm":
691 f.write(' "--arch_syscall_tool $(location %s) " +\n' % arm_syscall_tool)
692 f.write(' "--arch_syscall_tbl $(location %s) " +\n' % arm_syscall_tbl)
693
694 f.write(' "--headers_install $(location %s) " +\n' % headers_install_sh)
695 f.write(' "--include_uapi $(locations %s)",\n' % generic_src)
Rishabh Bhatnagar119960e2020-02-12 13:50:44 -0800696 f.write(' out: ["linux/version.h"] + gen_headers_out_%s,\n' % header_arch)
Justin DeMartinocc397382019-11-05 15:59:43 -0800697 f.write('}\n')
698
699 return 0
700
Siddharth Gupta6afa65c2020-01-29 17:22:38 -0800701def parse_bp_for_headers(file_name, headers):
702 parsing_headers = False
Rishabh Bhatnagar119960e2020-02-12 13:50:44 -0800703 pattern = re.compile("gen_headers_out_[a-zA-Z0-9]+\s*=\s*\[\s*")
Siddharth Gupta6afa65c2020-01-29 17:22:38 -0800704 with open(file_name, 'r') as f:
705 for line in f:
706 line = line.strip()
707 if pattern.match(line):
708 parsing_headers = True
709 continue
710
711 if line.find("]") != -1 and parsing_headers:
712 break
713
714 if not parsing_headers:
715 continue
716
717 if line.find("//") == 0:
718 continue
719
720 headers.add(line[1:-2])
721
722def headers_diff(old_file, new_file):
723 old_headers = set()
724 new_headers = set()
725 diff_detected = False
726
727 parse_bp_for_headers(old_file, old_headers)
728 parse_bp_for_headers(new_file, new_headers)
729
730 diff = old_headers - new_headers
731 if len(diff):
732 diff_detected = True
733 print("Headers to remove:")
734 for x in diff:
735 print("\t{}".format(x))
736
737 diff = new_headers - old_headers
738 if len(diff):
739 diff_detected = True
740 print("Headers to add:")
741 for x in diff:
742 print("\t{}".format(x))
743
744 return diff_detected
Justin DeMartinocc397382019-11-05 15:59:43 -0800745
746def gen_headers(
747 verbose, header_arch, gen_dir, arch_asm_kbuild, asm_generic_kbuild, module_dir,
748 old_gen_headers_bp, new_gen_headers_bp, version_makefile,
749 arch_syscall_tool, arch_syscall_tbl, headers_install, include_uapi,
750 arch_include_uapi, techpack_include_uapi):
751 """Generate the kernel headers.
752
753 This script generates the version.h file, the arch-specific headers including
754 syscall-related generated files and wrappers around generic files, and uses
755 the headers_install tool to process other generic uapi and arch-specifc uapi
756 files.
757
758 Args:
759 verbose: Set True to print progress messages.
760 header_arch: The arch for which to generate headers.
761 gen_dir: Where to place the generated files.
762 arch_asm_kbuild: The Kbuild file containing lists of headers to generate.
763 asm_generic_kbuild: The Kbuild file containing mandatory headers.
764 module_dir: The root directory of the kernel source.
765 old_gen_headers_bp: The old gen_headers_<arch>.bp file to check.
766 new_gen_headers_bp: The new gen_headers_<arch>.bp file to check.
767 version_makefile: The kernel Makefile that contains version info.
768 arch_syscall_tool: The arch script that generates syscall headers.
769 arch_syscall_tbl: The arch script that defines syscall vectors.
770 headers_install: The headers_install tool to process input headers.
771 include_uapi: The list of include/uapi header files.
772 arch_include_uapi: The list of arch/<arch>/include/uapi header files.
773 Return:
774 The number of errors encountered.
775 """
776
Siddharth Gupta6afa65c2020-01-29 17:22:38 -0800777 if headers_diff(old_gen_headers_bp, new_gen_headers_bp):
Justin DeMartinocc397382019-11-05 15:59:43 -0800778 print('error: gen_headers blueprints file is out of date, suggested fix:')
Siddharth Gupta6afa65c2020-01-29 17:22:38 -0800779 print('#######Please add or remove the above mentioned headers from %s' % (old_gen_headers_bp))
Justin DeMartinocc397382019-11-05 15:59:43 -0800780 print('then re-run the build')
Rishabh Bhatnagar47f762c2020-05-01 13:21:00 -0700781 return 1
Justin DeMartinocc397382019-11-05 15:59:43 -0800782
783 error_count = 0
784
785 if not gen_version_h(verbose, gen_dir, version_makefile):
786 error_count += 1
787
788 error_count += gen_arch_headers(
789 verbose, gen_dir, arch_asm_kbuild, asm_generic_kbuild, arch_syscall_tool, arch_syscall_tbl ,arch_include_uapi)
790
791 uapi_include_prefix = os.path.join(module_dir, 'include', 'uapi') + os.sep
792
793 arch_uapi_include_prefix = os.path.join(
794 module_dir, 'arch', header_arch, 'include', 'uapi') + os.sep
795
796 for h in include_uapi:
797 if not run_headers_install(
798 verbose, gen_dir, headers_install,
799 uapi_include_prefix, h):
800 error_count += 1
801
802 for h in arch_include_uapi:
803 if not run_headers_install(
804 verbose, gen_dir, headers_install,
805 arch_uapi_include_prefix, h):
806 error_count += 1
807
808 for h in techpack_include_uapi:
809 techpack_uapi_include_prefix = os.path.join(h.split('/include/uapi')[0], 'include', 'uapi') + os.sep
810 if not run_headers_install(
811 verbose, gen_dir, headers_install,
812 techpack_uapi_include_prefix, h):
813 error_count += 1
814
815 return error_count
816
817def extract_techpack_uapi_headers(verbose, module_dir):
818
819 """EXtract list of uapi headers from techpack/* directories. We need to export
820 these headers to userspace.
821
822 Args:
823 verbose: Verbose option is provided to script
824 module_dir: Base directory
825 Returs:
826 List of uapi headers
827 """
828
829 techpack_subdir = []
830 techpack_dir = os.path.join(module_dir,'techpack')
831 techpack_uapi = []
832 techpack_uapi_sub = []
833
834 #get list of techpack directories under techpack/
835 if os.path.isdir(techpack_dir):
836 items = sorted(os.listdir(techpack_dir))
837 for x in items:
838 p = os.path.join(techpack_dir, x)
839 if os.path.isdir(p):
840 techpack_subdir.append(p)
841
842 #Print list of subdirs obtained
843 if (verbose):
844 for x in techpack_subdir:
845 print(x)
846
847 #For every subdirectory get list of .h files under include/uapi and append to techpack_uapi list
848 for x in techpack_subdir:
849 techpack_uapi_path = os.path.join(x, 'include/uapi')
850 if (os.path.isdir(techpack_uapi_path)):
851 techpack_uapi_sub = []
852 find_out(verbose, x, 'include/uapi', '**/*.h', None, techpack_uapi_sub)
853 tmp = [os.path.join(techpack_uapi_path, y) for y in techpack_uapi_sub]
854 techpack_uapi = techpack_uapi + tmp
855
856 if (verbose):
857 for x in techpack_uapi:
858 print(x)
859
860 return techpack_uapi
861
862def main():
863 """Parse command line arguments and perform top level control."""
864
865 parser = argparse.ArgumentParser(
866 description=__doc__,
867 formatter_class=argparse.RawDescriptionHelpFormatter)
868
869 # Arguments that apply to every invocation of this script.
870
871 parser.add_argument(
872 '--verbose',
873 action='store_true',
874 help='Print output that describes the workings of this script.')
875 parser.add_argument(
876 '--header_arch',
877 required=True,
878 help='The arch for which to generate headers.')
879 parser.add_argument(
880 '--gen_dir',
881 required=True,
882 help='Where to place the generated files.')
883 parser.add_argument(
884 '--arch_asm_kbuild',
885 required=True,
886 help='The Kbuild file containing lists of headers to generate.')
887 parser.add_argument(
888 '--asm_generic_kbuild',
889 required=True,
890 help='The Kbuild file containing lists of mandatory headers.')
891 parser.add_argument(
892 '--arch_include_uapi',
893 required=True,
894 nargs='*',
895 help='The list of arch/<arch>/include/uapi header files.')
Rishabh Bhatnagar119960e2020-02-12 13:50:44 -0800896 parser.add_argument(
897 '--techpack_include_uapi',
898 required=True,
899 nargs='*',
900 help='The list of techpack/*/include/uapi header files.')
Justin DeMartinocc397382019-11-05 15:59:43 -0800901
902 # The modes.
903
904 subparsers = parser.add_subparsers(
905 dest='mode',
906 help='Select mode')
907 parser_blueprints = subparsers.add_parser(
908 'blueprints',
909 help='Generate the gen_headers_<arch>.bp file.')
910 parser_headers = subparsers.add_parser(
911 'headers',
912 help='Check blueprints, then generate kernel headers.')
913
914 # Arguments that apply to headers mode.
915
916 parser_headers.add_argument(
917 '--old_gen_headers_bp',
918 required=True,
919 help='The old gen_headers_<arch>.bp file to check.')
920 parser_headers.add_argument(
921 '--new_gen_headers_bp',
922 required=True,
923 help='The new gen_headers_<arch>.bp file to check.')
924 parser_headers.add_argument(
925 '--version_makefile',
926 required=True,
927 help='The kernel Makefile that contains version info.')
928 parser_headers.add_argument(
929 '--arch_syscall_tool',
930 help='The arch script that generates syscall headers, if applicable.')
931 parser_headers.add_argument(
932 '--arch_syscall_tbl',
933 help='The arch script that defines syscall vectors, if applicable.')
934 parser_headers.add_argument(
935 '--headers_install',
936 required=True,
937 help='The headers_install tool to process input headers.')
938 parser_headers.add_argument(
939 '--include_uapi',
940 required=True,
941 nargs='*',
942 help='The list of include/uapi header files.')
943
944 args = parser.parse_args()
945
946 if args.verbose:
947 print('mode [%s]' % args.mode)
948 print('header_arch [%s]' % args.header_arch)
949 print('gen_dir [%s]' % args.gen_dir)
950 print('arch_asm_kbuild [%s]' % args.arch_asm_kbuild)
951 print('asm_generic_kbuild [%s]' % args.asm_generic_kbuild)
952
953 # Extract the module_dir from args.arch_asm_kbuild and rel_arch_asm_kbuild.
954
955 rel_arch_asm_kbuild = os.path.join(
956 'arch', args.header_arch, 'include/uapi/asm/Kbuild')
957
958 suffix = os.sep + rel_arch_asm_kbuild
959
960 if not args.arch_asm_kbuild.endswith(suffix):
961 print('error: expected %s to end with %s' % (args.arch_asm_kbuild, suffix))
962 return 1
963
964 module_dir = args.arch_asm_kbuild[:-len(suffix)]
965
966 rel_asm_generic_kbuild = os.path.join('include/uapi/asm-generic', os.path.basename(args.asm_generic_kbuild))
967
968
969 if args.verbose:
970 print('module_dir [%s]' % module_dir)
971
Justin DeMartinocc397382019-11-05 15:59:43 -0800972
973 if args.mode == 'blueprints':
974 return gen_blueprints(
975 args.verbose, args.header_arch, args.gen_dir, args.arch_asm_kbuild,
Rishabh Bhatnagar119960e2020-02-12 13:50:44 -0800976 args.asm_generic_kbuild, module_dir, rel_arch_asm_kbuild, rel_asm_generic_kbuild, args.arch_include_uapi, args.techpack_include_uapi)
Justin DeMartinocc397382019-11-05 15:59:43 -0800977
978 if args.mode == 'headers':
979 if args.verbose:
980 print('old_gen_headers_bp [%s]' % args.old_gen_headers_bp)
981 print('new_gen_headers_bp [%s]' % args.new_gen_headers_bp)
982 print('version_makefile [%s]' % args.version_makefile)
983 print('arch_syscall_tool [%s]' % args.arch_syscall_tool)
984 print('arch_syscall_tbl [%s]' % args.arch_syscall_tbl)
985 print('headers_install [%s]' % args.headers_install)
986
987 return gen_headers(
988 args.verbose, args.header_arch, args.gen_dir, args.arch_asm_kbuild,
989 args.asm_generic_kbuild, module_dir, args.old_gen_headers_bp, args.new_gen_headers_bp,
990 args.version_makefile, args.arch_syscall_tool, args.arch_syscall_tbl,
Rishabh Bhatnagar119960e2020-02-12 13:50:44 -0800991 args.headers_install, args.include_uapi, args.arch_include_uapi, args.techpack_include_uapi)
Justin DeMartinocc397382019-11-05 15:59:43 -0800992
993 print('error: unknown mode: %s' % args.mode)
994 return 1
995
996
997if __name__ == '__main__':
998 sys.exit(main())