xref: /src/usr.bin/config/TODO

o Call module as module.

  Until now, everything is called as attribute.  Separate module from it:

	- Module is a collection of code (*.[cSo]), and provides a function.
	  Module can depend on other modules.

	- Attribute provides metadata for modules.  One module can have
	  multiple attributes.  Attribute doesn't generate a module (*.o,
	  *.ko).

o Emit everything (ioconf.*, Makefile, ...) per-attribute.

  config(9) related metadata (cfdriver, cfattach, cfdata, ...) should be
  collected using linker.  Create ELF sections like
  .{rodata,data}.config.{cfdriver,cfattach,cfdata}.  Provide reference
  symbols (e.g. cfdriverinit[]) using linker script.  Sort entries by name
  to lookup entries by binary search in kernel.

o Generate modular(9) related information.  Especially module dependency.

  At this moment modular(9) modules hardcode dependency in *.c using the
  MODULE() macro:

	MODULE(MODULE_CLASS_DRIVER, hdaudio, "pci");

  This information already exists in config(5) definitions (files.*).
  Extend config(5) to be able to specify module's class.

  Ideally these module metadata are kept somewhere in ELF headers, so that
  loaders (e.g. boot(8)) can easily read.  One idea is to abuse DYNAMIC
  sections to record dependency, as shared library does.  (Feasibility
  unknown.)

o Rename "interface attribute" to "bus".

  Instead of

	define	audiobus {}
	attach	audio at audiobus

  Do like this

	defbus	audiobus {}
	attach	audio at audiobus

  Always provide xxxbusprint() (and xxxbussubmatch if multiple children).
  Extend struct cfiattrdata like:

	struct cfiattrdata {
		const char *ci_name;
		cfprint_t ci_print;
		cfsubmatch_t ci_submatch;
		int ci_loclen;
		const struct cflocdesc ci_locdesc[];
	};

o Simplify child configuration API

  With said struct cfiattrdata extension, config_found*() can omit
  print/submatch args.  If the found child is known (e.g., "pcibus" creating
  "pci"):

	config_found(self, "pcibus");

  If finding unknown children (e.g. "pci" finding pci devices):

	config_find(self, "pci", locs, aux);

o Retire "attach foo at bar with foo_bar.c"

  Most of these should be rewritten by defining a common interface attribute
  "foobus", instead of writing multiple attachments.  com(4), ld(4), ehci(4)
  are typical examples.  For ehci(4), EHCI-capable controller drivers implement
  "ehcibus" interface, like:

	define	ehcibus {}
	device	imxehci: ehcibus

  These drivers' attach functions call config_found() to attach ehci(4) via
  the "ehcibus" interface attribute, instead of calling ehci_init() directly.
  Same for com(4) (com_attach_subr()) and ld(4) (ldattach()).

o Sort objects in more reasonable order.

  Put machdep.ko in the lowest address.  uvm.ko and kern.ko follow.

  Kill alphabetical sort (${OBJS:O} in sys/conf/Makefile.inc.kern.

  Use ldscript.  Do like this

	.text :
	AT (ADDR(.text) & 0x0fffffff)
	{
	  *(.text.machdep.locore.entry)
	  *(.text.machdep.locore)
	  *(.text.machdep)
	  *(.text)
	  *(.text.*)
	  :

  Kill linker definitions in sys/conf/Makefile.inc.kern.

o Differentiate "options" and "flags"/"params".

  "options" enables features by adding *.c files (via attributes).

  "flags" and "params" are to change contents of *.c files.  These don't add
  *.c files to the result kernel, or don't build attributes (modules).

o Make flags/params per attributes (modules).

  Basically flags and params are cpp(1) #define's generated in opt_*.h.  Make
  them local to one attributes (modules).  Flags/params which affects files
  across attributes (modules) are possible, but should be discouraged.

o Generate things only by definitions.

  In the ideal dynamically modular world, "selection" will be done not at
  compile time but at runtime.  Users select their wanted modules, by
  dynamically loading them.

  This means that the system provides all choices; that is, build all modules
  in the source tree.  Necessary information is defined in the "definition"
  part.

o Split cfdata.

  cfdata is a set of pattern matching rules to enable devices at runtime device
  auto-configuration.  It is pure data and can (should) be generated separately
  from the code.

o Allow easier adding and removing of options.

  It should be possible to add or remove options, flags, etc.,
  without regard to whether or not they are already defined.
  For example, a configuration like this:

	include GENERIC
	options FOO
	no options BAR

  should work regardless of whether or not options FOO and/or
  options BAR were defined in GENERIC.  It should not give
  errors like "options BAR was already defined" or "options FOO
  was not defined".

o Introduce "class".

  Every module should be classified as at least one class, as modular(9)
  modules already do.  For example, file systems are marked as "vfs", network
  protocols are "netproto".

  Consider to merge "devclass" into "class".

  For syntax clarity, class names could be used as a keyword to select the
  class's instance module:

	# Define net80211 module as netproto class
	class netproto
	define net80211: netproto

	# Select net80211 to be builtin
	netproto net80211

  Accordingly device/attach selection syntax should be revisited.

o Support kernel constructor/destructor (.kctors/.kdtors)

  Initialization and finalization should be called via constructors and
  destructors.  Don't hardcode those sequences as sys/kern/init_main.c:main()
  does.

  The order of .kctors/.kdtors is resolved by dependency.  The difference from
  userland is that in kernel depended ones are located in lower addresses;
  "machdep" module is the lowest.  Thus the lowest entry in .ctors must be
  executed the first.

  The .kctors/.kdtors entries are executed by kernel's main() function, unlike
  userland where start code executes .ctors/.dtors before main().  The hardcoded
  sequence of various subsystem initializations in init_main.c:main() will be
  replaced by an array of .kctors invocations, and #ifdef's there will be gone.

o Hide link-set in the final kernel.

  Link-set is used to collect references (pointers) at link time.  It relys on
  the ld(1) behavior that it automatically generates `__start_X' and `__stop_X'
  symbols for the section `X' to reduce coding.

  Don't allow kernel subsystems create random ELF sections.

  Pre-define all the available link-set names and pre-generate a linker script
  to merge them into .rodata.

  (For modular(9) modules, `link_set_modules' is looked up by kernel loader.
  Provide only it.)

  Provide a way for 3rd party modules to declare extra link-set.

o Shared kernel objects.

  Since NetBSD has not established a clear kernel ABI, every single kernel
  has to build all the objects by their own.  As a result, similar kernels
  (e.g. evbarm kernels) repeatedly compile similar objects, that is waste of
  energy & space.

  Share them if possible.  For evb* ports, ideally everything except machdep.ko
  should be shared.

  While leaving optimizations as options (CPU specific optimizations, inlined
  bus_space(9) operations, etc.) for users, the official binaries build
  provided by TNF should be as portable as possible.

o Always use explicit kernel linker script.

  ld(1) has an option -T <ldscript> to use a given linker script.  If not
  specified, a default, built-in linker script, mainly meant for userland
  programs, is used.

  Currently m68k, sh3, and vax don't have kernel linker scripts.  These work
  because these have no constraints about page boundary; they map and access
  kernel .text/.data in the same way.

o Pass input files to ${LD} via linker script.

  Instead of passing input files on command-line, output "INPUT(xxx.o)"
  commands, and include it from generated linker scripts.

o Directly generate `*.d' files.

  Output source/object files in raw texts instead of `Makefile'.  Generate
  `*.d' (make(1) depend) files.  make(1) knows which object files are to be
  compiled.  With "INPUT(xxx.o)" linker scripts, either generated `Makefile'
  or `Makefile.kern.inc' don't need to keep source/object files in variables.

o Control ELF sections using linker script.

  Now kernel is linked and built directly from object files (*.o).  Each port
  has an MD linker script, which does everything needed to be done at link
  time.  As a result, they do from MI alignment restriction (read_mostly,
  cacheline_aligned) to load address specification for external boot loaders.

  Make this into multiple stages to make linkage more structural.  Especially,
  reserve the final link for purely MD purpose.  Note that in modular build,
  *.ko are shared between build of kernel and modular(9) modules (*.kmod).

	Monolithic build:
		     *.o  ---> netbsd.ko	Generic MI linkage
		netbsd.ko ---> netbsd.ro	Kernel MI linkage
		netbsd.ro ---> netbsd		Kernel MD linkage

	Modular build (kernel):
		     *.o  --->      *.ko	Generic + Per-module MI linkage
		     *.ko ---> netbsd.ro	Kernel MI linkage
		netbsd.ro ---> netbsd		Kernel MD linkage

	Modular build (module):
		     *.o  --->      *.ko	Generic + Per-module MI linkage
		     *.ko --->      *.ro	Modular MI linkage
		     *.ro --->      *.kmod	Modular MD linkage

  Generic MI linkage is for processing MI linkage that can be applied generally.
  Data section alignment (.data.read_mostly and .data.cacheline_aligned) is
  processed here.

  Per-module MI linkage is for modules that want some ordering.  For example,
  machdep.ko wants to put entry code at the top of .text and .data.

  Kernel MI linkage is for collecting kernel global section data, that is what
  link-set is used for now.  Once they are collected and symbols to the ranges
  are assigned, those sections are merged into the pre-existing sections
  (.rodata) because link-set sections in "netbsd" will never be interpreted by
  external loaders.

  Kernel MD linkage is used purely for MD purposes, that is, how kernels are
  loaded by external loaders.  It might be possible that one kernel relocatable
  (netbsd.ro) is linked into multiple final kernel image (netbsd) for different
  load addresses.

  Modular MI linkage is to prepare a module to be loadable as modular(9).  This
  may add some extra sections and/or symbols.

  Modular MD linkage is again for pure MD purposes like kernel MD linkage.
  Adjustment and/or optimization may be done.

  Kernel and modular MI linkages may change behavior depending on existence
  of debug information.  In the future .symtab will be copied using linker
  during this stage.

o Fix db_symtab copying (COPY_SYMTAB)

  o Collect all objects and create a relocatable (netbsd.ro).  At this point,
    the number of symbols is known.

  o Relink and allocate .rodata.symtab with the calculated size of .symtab.
    Linker recalculates symbol addresses.

  o Embed the .symtab into .rodata.symtab.

  o Link the final netbsd ELF.

  The make(1) rule (dependency graph) should be identical with/without
  COPY_SYMTAB.  Kill .ifdef COPY_SYMTAB from $S/conf/Makefile.kern.inc.

o Preprocess and generate linker scripts dynamically.

  Include opt_xxx.h and replace some constant values (e.g. COHERENCY_UNIT,
  PAGE_SIZE, KERNEL_BASE_PHYS, KERNEL_BASE_VIRT, ...) with cpp(1).

  Don't unnecessarily define symbols.  Don't use sed(1).

o Clean up linker scripts.

  o Don't specify OUTPUT_FORMAT()/OUTPUT_ARCH()

    These are basically set in compilers/linkers.  If non-default ABI is used,
    command-line arguments should be specified.

  o Remove .rel/.rela handlings.

    These are set in relocatable objects, and handled by dynamic linkers.
    Totally irrelevant for kernels.

  o Clean up debug section handlings.

  o Document (section boundary) symbols set in linker scripts.

    There must be a reason why symbols are defined and exported.

    PROVIDE() is to define internal symbols.

  o Clean up load addresses.

  o Program headers.

  o According to matt@, .ARM.extab/.ARM.exidx sections are no longer needed.

o Redesign swapnetbsd.c (root/swap device specification)

  Don't build a whole kernel only to specify root/swap devices.

  Make these parameter re-configurable afterwards.

o Namespace.

  Investigate namespace of attributes/modules/options.  Figure out the hidden
  design about these, document it, then re-design it.

  At this moment, all of them share the single "selecttab", which means their
  namespaces are common, but they also have respective tables (attrtab,
  opttab, etc.).

  Selecting an option (addoption()), that is also a module name, works only if
  the module doesn't depend on anything, because addoption() doesn't select
  module and its dependencies (selectattr()).  In other words, an option is
  only safely converted to a module (define), only if it doesn't depend on
  anything.  (One example is DDB.)

o Convert pseudo(dev) attach functions to take (void) (== kernel ctors).

  The pseudo attach function was originally designed to take `int n' as
  the number of instances of the pseudo device.  Now most of pseudo
  devices have been converted to be `cloneable', meaning that their
  instances are dynamically allocated at run-time, because guessing how
  much instances are needed for users at compile time is almost impossible.
  Restricting such a pure software resource at compile time is senseless,
  considering that the rest of the world is dynamic.

  If pseudo attach functions once become (void), config(1) no longer
  has to generate iteration to call those functions, by making them part
  of kernel constructors, that are a list of (void) functions.

  Some pseudo devices may have dependency/ordering problems, because
  pseudo attach functions have no choice when to be called.  This could
  be solved by converting to kctors, where functions are called in order
  by dependency.

o Enhance ioconf behavior for pseudo-devices

  See "bin/48571: config(1) ioconf is insufficient for pseudo-devices" for
  more details.  In a nutshell, it would be "useful" for config to emit
  the necessary stuff in the generated ioconf.[ch] to enable use of
  config_{init,fini}_component() for attaching and detaching pseudodev's.

  Currently, you need to manually construct your own data structures, and
  manually "attach" them, one at a time.  This leads to duplication of
  code (where multiple drivers contain the same basic logic), and doesn't
  necessarily handle all of the "frobbing" of the kernel lists.

o Don't use -Ttext ${TEXTADDR}.

  Although ld(1)'s `-Ttext ${TEXTADDR}' is an easy way to specify the virtual
  base address of .text at link time, it needs to change command-line; in
  kernel build, Makefile needs to change to reflect kernel's configuration.
  It is simpler to reflect kernel configuration using linker script via assym.h.

o Convert ${DIAGNOSTIC} and ${DEBUG} as flags (defflag).

  Probably generate opt_diagnostic.h/opt_debug.h and include them in
  sys/param.h.

o Strictly define DIAGNOSTIC.

  It is possible to make DIAGNOSTIC kernel and modules binary-compatible with
  non-DIAGNOSTIC ones.  In that case, debug type information should match
  theoretically (not confirmed).

o Use suffix rules.

  Build objects following suffix rules.  Source files are defined as relative to
  $S (e.g. sys/kern/init_main.c) and objects are generated in the corresponding
  subdirectories under kernel build directories (e.g.
  .../compile/GENERIC/sys/kern/init_main.o).  Dig subdirectories from within
  config(1).

  Debugging (-g) and profiling (-pg) objects could be generated with *.go/*.po
  suffixes as userland libraries do.  Maybe something similar for
  DIAGNOSTIC/DEBUG.

  genassym(1) definitions will be split into per-source instead of the single
  assym.h.  Dependencies are corrected and some of mysterious dependencies on
  `Makefile' in sys/conf/Makefile.kern.inc can go away.

o Define genassym(1) symbols per file.

  Have each file define symbols that have to be generated by genassym(1) so
  that more accurate dependency is reflected.

  For example, if foo.S needs some symbols, it defines them in foo.assym,
  declaring that foo.S depends on foo.assym.h, and includes foo.assym.h.
  foo.assym.h is generated by following the suffix rule of .assym -> .assym.h.
  When one header is updated, only related *.assym.h files are regenerated,
  instead of rebuilding all MD/*.S files that depend on the global, single
  assym.h.

o Support library.

  Provide a consistent way to build library either as .o or .a.

  Build libraries in sub-make.  Don't include library makefiles.  Don't
  pollute search path (.PATH).  libkern does too much.

o Accept `.a' suffix.

  Make "file" command accept `.a' suffix.  Handle it the same way as `.o'.

o Clean up ${MD_OBJS} and friends in Makefile.${MACHINE}.

  Don't use ${MD_OBJS}, ${MD_LIBS}, ${MD_SFILES}, and ${MD_CFILES}.

  List files in config(5)'s "file".  Override build rules only when necessary.

  Rely on the fact that config(1) parses files.${MACHINE} first, outputs
  files in the order it parses files.* (actually include depth), and
  `Makefile.kern.inc' preserve file order to pass to ${LD}.

o Clean up CTF-related rules.

  Don't overwrite compile/link rules conditionally by existence of
  ${CTFCONVERT}/${CTFMERGE}.  Give a separate suffix (*.ctfo) and define its
  rules (.c -> .ctfo).

o Consider using cpp -MD instead of ${MKDEP}.

o Make "make depend" mandatory.

  Automatically execute "make depend".