zircon/kernel/lib/userabi/BUILD.gn - fuchsia - Git at Google

 # Copyright 2019 The Fuchsia Authors
 #
 # Use of this source code is governed by a MIT-style
 # license that can be found in the LICENSE file or at
 # https://opensource.org/licenses/MIT

 import("$zx/public/gn/toolchain/c_utils.gni")
 import("$zx/public/gn/toolchain/environment_redirect.gni")
 import("$zx/public/gn/zbi.gni")

 zx_library("userabi") {
   kernel = true
   sources = []
   public_deps = [
     # <lib/userabi/userboot.h> has #include <lib/instrumentation/vmo.h>.
     "$zx/kernel/lib/instrumentation:headers",
   ]
   if (is_kernel) {
     deps = [
       ":userboot",
       ":vdso",
       "$zx/kernel/lib/instrumentation",
     ]
     public_configs = [ ":vdso-valid-sysret" ]
     public_deps += [
       # Dependents can use the generated header via $public_configs
       # (above), and so need to depend on the generation action.
       ":gen-vdso-valid-sysret",

       # <lib/userabi/rodso.h> has #include <object/handle.h>.
       "$zx/kernel/object",
     ]
   } else {
     # Our own embedded "user" code needs some shared headers.
     visibility = [
       "./*",
       "$zx/system/ulib/zircon/*",
     ]
   }
 }

 # Embed an RODSO layout object and extract address constants from it.
 #
 # The userboot loadable_module() and the vdso (libzircon) shared_library()
 # both use the special RODSO layout (by default in lld or via rodso.ld in
 # gold).  The kernel needs to use address constants extracted from these
 # ELF files' headers and symbols.
 #
 # This generates three targets:
 #  * "$target_name-code.h" generates the eponymous header in $target_gen_dir
 #  * "$target_name.rsp" generates the eponymous link_output_rspfile()
 #  * "$target_name.image" is a source_set() to embed the image in the kernel
 #
 # Parameters
 #
 #   name
 #     - Required: "USERBOOT" or "VDSO", used in generated macro names
 #     - Type: string
 #
 #   deps
 #     - Required; Should reach the loadable_module() or library() target
 #     and no other linking targets; see link_output_rspfile().
 #     - Type: list(label)
 #
 #   writable
 #     - Optional: Writable segments allowed (not for userboot or vDSO!).
 #     - Type: bool
 #     - Default: false
 #
 template("rodso") {
   rspfile_target = "$target_name.rsp"
   rspfile = "$target_gen_dir/$rspfile_target"

   link_output_rspfile(rspfile_target) {
     forward_variables_from(invoker,
                            [
                              "deps",
                              "testonly",
                              "visibility",
                            ])
     outputs = [ rspfile ]
   }

   if (is_kernel) {
     # This generated header file tells the kernel code where the segment
     # boundaries and entry points are.
     header_target = "$target_name-code.h"
     header = "$target_gen_dir/$header_target"

     toolchain_utils_action(header_target) {
       forward_variables_from(invoker,
                              [
                                "testonly",
                                "visibility",
                              ])

       deps = [ ":$rspfile_target" ]
       outputs = [ header ]
       depfile = "$header.d"

       script = "gen-rodso-code.sh"
       utils = [
         "nm",
         "readelf",
       ]
       sources = [ rspfile ]
       args = [
         "--depfile",
         rebase_path(depfile, root_build_dir),
         rebase_path(header, root_build_dir),
       ]
       if (defined(invoker.writable) && invoker.writable) {
         args += [ "--writable" ]
       }
       args += [
         invoker.name,
         "@" + rebase_path(rspfile, root_build_dir),
       ]

       metadata = {
         generated_sources = rebase_path(outputs, root_build_dir)

         # Prevent deps from propagating up to code that uses this action.
         manifest_barrier = []
       }
     }

     # Embed the image itself.
     rodso_name = target_name
     source_set("$target_name.image") {
       visibility = [ ":*" ]
       sources = [ "$target_gen_dir/$target_name.S" ]

       # The generated header is also needed to tell .incbin how much of the
       # image file to embed (see rodso-asm.h).
       header = rebase_path(header, target_gen_dir)
       include_dirs = [
         target_gen_dir,
         ".",
       ]
       deps = [ ":$header_target" ]

       # $target_name.S includes the image contents and so must be
       # reassembled when that changes.  We can't express that in $inputs here
       # because we don't know the exact name of the file since that depends
       # on the toolchain selected.  Fortunately, we already depend on the
       # generated $header, which is always regenerated whenever the image
       # binary itself changes.  So this indirect dependency is sufficient.
       if (defined(invoker.writable) && invoker.writable) {
         code_or_data = "DATA"
       } else {
         code_or_data = "CODE"
       }
       write_file(sources[0],
                  [
                    "#include \"rodso-asm.h\"",
                    "#include \"$header\"",
                    "RODSO_IMAGE($rodso_name, ${invoker.name}, $code_or_data)",
                  ])
     }
   } else {
     not_needed(invoker, [ "name" ])
   }
 }

 # Redirect to the userland vDSO shared library target.
 environment_redirect("userland-vdso") {
   visibility = [ ":*" ]
   environment_label = "$zx/public/gn/toolchain:user"
   deps = [ "$zx/system/ulib/zircon" ]
 }

 rodso("vdso") {
   visibility = [ "./*" ]
   name = "VDSO"
   deps = [ ":userland-vdso" ]
 }

 if (is_kernel) {
   # Support for loading embedded ELF files, used for both vdso and userboot.
   source_set("rodso") {
     visibility = [ ":*" ]
     sources = [ "rodso.cc" ]
     deps = [
       ":headers",
       "$zx/kernel/vm:headers",
     ]
   }

   # Initializing, supporting, and validating the vDSO itself.
   source_set("vdso") {
     visibility = [ ":*" ]
     sources = [ "vdso.cc" ]
     deps = [
       ":headers",
       ":rodso",
       ":vdso-code.h",
       ":vdso.image",
       "$zx/kernel/lib/cmdline",
       "$zx/kernel/lib/syscalls",
       "$zx/kernel/lib/version",
       "$zx/kernel/vm:headers",
       "$zx/system/ulib/affine",
       "$zx/system/ulib/fbl",
     ]
   }

   config("vdso-valid-sysret") {
     visibility = [ ":*" ]
     include_dirs = [ target_gen_dir ]
   }

   action("gen-vdso-valid-sysret") {
     visibility = [ ":*" ]
     script = "gen-vdso-valid-sysret.sh"
     deps = [ ":vdso-code.h" ]
     sources = get_target_outputs(":vdso-code.h")
     outputs = [ "$target_gen_dir/vdso-valid-sysret.h" ]
     args = rebase_path(sources + outputs)
   }

   group("vdso-code-header") {
     deps = [ ":vdso-code.h" ]
     public_configs = [ ":vdso-code-header.config" ]

     # The following metadata allows the vDSO header to be exposed to the GN
     # build under //zircon/public/lib/vdso-code-header.
     metadata = {
       legacy_barrier = []
       legacy_dirs = [ "lib/vdso-code-header" ]
       legacy_targets = [
         {
           _zircon_public = "lib"
           import = "//build/zircon/zircon_library.gni"
           target_type = "zircon_library"
           target_name = "vdso-code-header"
           include_dirs = [ target_gen_dir ]
           compilation_include_dirs = []
           compilation_defines = []
           disable_ubsan = false
           headers = [ "$target_gen_dir/vdso-code.h" ]
           publishable = false
           sources = []
           deps = []
           public_deps = []
           install = []
           debug = []
         }
       ]
     }
   }

   config("vdso-code-header.config") {
     visibility = [ ":vdso-code-header" ]
     include_dirs = [ target_gen_dir ]
   }

   decompress_zbi = zbi_compression_algorithm != "none"

   # Loading and launching userboot, which loads and launches "real" userland.
   source_set("userboot") {
     visibility = [ ":*" ]
     sources = [ "userboot.cc" ]
     include_dirs = [ target_gen_dir ]
     deps = [
       ":headers",
       ":rodso",
       ":userboot-code.h",
       ":userboot.image",
       "$zx/kernel/lib/cmdline",
       "$zx/kernel/lib/console",
       "$zx/kernel/lib/counters",
       "$zx/system/ulib/elf-psabi",
       "$zx/system/ulib/zircon-internal",
     ]
     if (decompress_zbi) {
       defines = [ "DECOMPRESS_ZBI" ]
       deps += [
         ":decompress_zbi-code.h",
         ":decompress_zbi.image",
       ]
     }
   }

   rodso("userboot") {
     visibility = [ ":*" ]
     name = "USERBOOT"
     deps = [ "userboot" ]
   }

   if (zbi_compression_algorithm != "none") {
     rodso("decompress_zbi") {
       visibility = [ ":*" ]
       name = "DECOMPRESS_ZBI"
       deps = [ "$zx/system/ulib/hermetic-decompressor:decompress-$zbi_compression_algorithm" ]

       # It's hermetic, but it's allowed to have data and bss.
       writable = true
     }
   }
 }
	# Copyright 2019 The Fuchsia Authors
	#
	# Use of this source code is governed by a MIT-style
	# license that can be found in the LICENSE file or at
	# https://opensource.org/licenses/MIT

	import("$zx/public/gn/toolchain/c_utils.gni")
	import("$zx/public/gn/toolchain/environment_redirect.gni")
	import("$zx/public/gn/zbi.gni")

	zx_library("userabi") {
	kernel = true
	sources = []
	public_deps = [
	# <lib/userabi/userboot.h> has #include <lib/instrumentation/vmo.h>.
	"$zx/kernel/lib/instrumentation:headers",
	]
	if (is_kernel) {
	deps = [
	":userboot",
	":vdso",
	"$zx/kernel/lib/instrumentation",
	]
	public_configs = [ ":vdso-valid-sysret" ]
	public_deps += [
	# Dependents can use the generated header via $public_configs
	# (above), and so need to depend on the generation action.
	":gen-vdso-valid-sysret",

	# <lib/userabi/rodso.h> has #include <object/handle.h>.
	"$zx/kernel/object",
	]
	} else {
	# Our own embedded "user" code needs some shared headers.
	visibility = [
	"./*",
	"$zx/system/ulib/zircon/*",
	]
	}
	}

	# Embed an RODSO layout object and extract address constants from it.
	#
	# The userboot loadable_module() and the vdso (libzircon) shared_library()
	# both use the special RODSO layout (by default in lld or via rodso.ld in
	# gold). The kernel needs to use address constants extracted from these
	# ELF files' headers and symbols.
	#
	# This generates three targets:
	# * "$target_name-code.h" generates the eponymous header in $target_gen_dir
	# * "$target_name.rsp" generates the eponymous link_output_rspfile()
	# * "$target_name.image" is a source_set() to embed the image in the kernel
	#
	# Parameters
	#
	# name
	# - Required: "USERBOOT" or "VDSO", used in generated macro names
	# - Type: string
	#
	# deps
	# - Required; Should reach the loadable_module() or library() target
	# and no other linking targets; see link_output_rspfile().
	# - Type: list(label)
	#
	# writable
	# - Optional: Writable segments allowed (not for userboot or vDSO!).
	# - Type: bool
	# - Default: false
	#
	template("rodso") {
	rspfile_target = "$target_name.rsp"
	rspfile = "$target_gen_dir/$rspfile_target"

	link_output_rspfile(rspfile_target) {
	forward_variables_from(invoker,
	[
	"deps",
	"testonly",
	"visibility",
	])
	outputs = [ rspfile ]
	}

	if (is_kernel) {
	# This generated header file tells the kernel code where the segment
	# boundaries and entry points are.
	header_target = "$target_name-code.h"
	header = "$target_gen_dir/$header_target"

	toolchain_utils_action(header_target) {
	forward_variables_from(invoker,
	[
	"testonly",
	"visibility",
	])

	deps = [ ":$rspfile_target" ]
	outputs = [ header ]
	depfile = "$header.d"

	script = "gen-rodso-code.sh"
	utils = [
	"nm",
	"readelf",
	]
	sources = [ rspfile ]
	args = [
	"--depfile",
	rebase_path(depfile, root_build_dir),
	rebase_path(header, root_build_dir),
	]
	if (defined(invoker.writable) && invoker.writable) {
	args += [ "--writable" ]
	}
	args += [
	invoker.name,
	"@" + rebase_path(rspfile, root_build_dir),
	]

	metadata = {
	generated_sources = rebase_path(outputs, root_build_dir)

	# Prevent deps from propagating up to code that uses this action.
	manifest_barrier = []
	}
	}

	# Embed the image itself.
	rodso_name = target_name
	source_set("$target_name.image") {
	visibility = [ ":*" ]
	sources = [ "$target_gen_dir/$target_name.S" ]

	# The generated header is also needed to tell .incbin how much of the
	# image file to embed (see rodso-asm.h).
	header = rebase_path(header, target_gen_dir)
	include_dirs = [
	target_gen_dir,
	".",
	]
	deps = [ ":$header_target" ]

	# $target_name.S includes the image contents and so must be
	# reassembled when that changes. We can't express that in $inputs here
	# because we don't know the exact name of the file since that depends
	# on the toolchain selected. Fortunately, we already depend on the
	# generated $header, which is always regenerated whenever the image
	# binary itself changes. So this indirect dependency is sufficient.
	if (defined(invoker.writable) && invoker.writable) {
	code_or_data = "DATA"
	} else {
	code_or_data = "CODE"
	}
	write_file(sources[0],
	[
	"#include \"rodso-asm.h\"",
	"#include \"$header\"",
	"RODSO_IMAGE($rodso_name, ${invoker.name}, $code_or_data)",
	])
	}
	} else {
	not_needed(invoker, [ "name" ])
	}
	}

	# Redirect to the userland vDSO shared library target.
	environment_redirect("userland-vdso") {
	visibility = [ ":*" ]
	environment_label = "$zx/public/gn/toolchain:user"
	deps = [ "$zx/system/ulib/zircon" ]
	}

	rodso("vdso") {
	visibility = [ "./*" ]
	name = "VDSO"
	deps = [ ":userland-vdso" ]
	}

	if (is_kernel) {
	# Support for loading embedded ELF files, used for both vdso and userboot.
	source_set("rodso") {
	visibility = [ ":*" ]
	sources = [ "rodso.cc" ]
	deps = [
	":headers",
	"$zx/kernel/vm:headers",
	]
	}

	# Initializing, supporting, and validating the vDSO itself.
	source_set("vdso") {
	visibility = [ ":*" ]
	sources = [ "vdso.cc" ]
	deps = [
	":headers",
	":rodso",
	":vdso-code.h",
	":vdso.image",
	"$zx/kernel/lib/cmdline",
	"$zx/kernel/lib/syscalls",
	"$zx/kernel/lib/version",
	"$zx/kernel/vm:headers",
	"$zx/system/ulib/affine",
	"$zx/system/ulib/fbl",
	]
	}

	config("vdso-valid-sysret") {
	visibility = [ ":*" ]
	include_dirs = [ target_gen_dir ]
	}

	action("gen-vdso-valid-sysret") {
	visibility = [ ":*" ]
	script = "gen-vdso-valid-sysret.sh"
	deps = [ ":vdso-code.h" ]
	sources = get_target_outputs(":vdso-code.h")
	outputs = [ "$target_gen_dir/vdso-valid-sysret.h" ]
	args = rebase_path(sources + outputs)
	}

	group("vdso-code-header") {
	deps = [ ":vdso-code.h" ]
	public_configs = [ ":vdso-code-header.config" ]

	# The following metadata allows the vDSO header to be exposed to the GN
	# build under //zircon/public/lib/vdso-code-header.
	metadata = {
	legacy_barrier = []
	legacy_dirs = [ "lib/vdso-code-header" ]
	legacy_targets = [
	{
	_zircon_public = "lib"
	import = "//build/zircon/zircon_library.gni"
	target_type = "zircon_library"
	target_name = "vdso-code-header"
	include_dirs = [ target_gen_dir ]
	compilation_include_dirs = []
	compilation_defines = []
	disable_ubsan = false
	headers = [ "$target_gen_dir/vdso-code.h" ]
	publishable = false
	sources = []
	deps = []
	public_deps = []
	install = []
	debug = []
	}
	]
	}
	}

	config("vdso-code-header.config") {
	visibility = [ ":vdso-code-header" ]
	include_dirs = [ target_gen_dir ]
	}

	decompress_zbi = zbi_compression_algorithm != "none"

	# Loading and launching userboot, which loads and launches "real" userland.
	source_set("userboot") {
	visibility = [ ":*" ]
	sources = [ "userboot.cc" ]
	include_dirs = [ target_gen_dir ]
	deps = [
	":headers",
	":rodso",
	":userboot-code.h",
	":userboot.image",
	"$zx/kernel/lib/cmdline",
	"$zx/kernel/lib/console",
	"$zx/kernel/lib/counters",
	"$zx/system/ulib/elf-psabi",
	"$zx/system/ulib/zircon-internal",
	]
	if (decompress_zbi) {
	defines = [ "DECOMPRESS_ZBI" ]
	deps += [
	":decompress_zbi-code.h",
	":decompress_zbi.image",
	]
	}
	}

	rodso("userboot") {
	visibility = [ ":*" ]
	name = "USERBOOT"
	deps = [ "userboot" ]
	}

	if (zbi_compression_algorithm != "none") {
	rodso("decompress_zbi") {
	visibility = [ ":*" ]
	name = "DECOMPRESS_ZBI"
	deps = [ "$zx/system/ulib/hermetic-decompressor:decompress-$zbi_compression_algorithm" ]

	# It's hermetic, but it's allowed to have data and bss.
	writable = true
	}
	}
	}