Because of the fact the Overlord is a core plus a set of modules, it is very likely that end-users will want to customize what components are actually built into the system. The build system for the overlord is designed with this in mind.
The build environment is set out in such a way that there is no need for any configuration files, the makefiles are generic and they deduce what to compile by the structure of the build directory itself.
The general procedure is:
Eg. if there is a directory called ola under the build directory then it will attempt to compile a component called ola. So, you simply need to create the directory ola then run make. The highest-level build directory will find the makefile needed to make ola and place it in the ola directory. It will then recurse into the ola directory and start to make there. At this point the build is left up to the Makefile supplied by the component (typically called component.mk. When it finished making the build will unrecurse and look for a new directory to make (probably olc, or olrt).
So, you supply what components to build by simply making an empty directory of those component's names in the build directory.
The idea continues for those components that have sub-components (notably olrt). FilenameOlrt has the ability to compile in different modules that supply different functionality to the overlord runtime. These modules can either be compiled directly into the filenameolrt executable or made into a shared object package that can be dynamically linked into the filenameolrt executable at runtime.
So, to specify which modules are to be compiled in statically to filenameolrt, you simply create a directory of that modules name under build-dir/olrt. Eg. To create an filenameolrt executable with mod_null and mod_var statically linked in, you would first create the build-dir/olrt directory then create build-dir/olrt/mod_null and create build-dir/olrt/mod_var. When you run make the build environment will recurse through all the directories present, copy in the appropriate makefiles and make the filenameolrt executable.
To make a shared object package for use in filenameolrt, you simply create a directory called build-dir/olrt/pkg_something this will create a shared object libpkg_something.so in that directory. To specify which modules are to included in that package you simply make a directory for each module under that package directory, in a similar manner to specifying modules to be compiled statically.
To get an idea of the structure needed in the build tree, you may run `make default' at the overlord/ level. This will create a default build structure in the directory build-platform, where platform is your current platform. If then run make in that directory it will copy all the necessary makefiles into place compile the components specified.