make-kpkg

Changes the Debian revision number for the packages produced to the argument R number. This has certain constraints: the --revision option only has an effect during the configure phase (in other words, if a file called stamp-configure exists, this option has no effect -- run make-kpkg clean or manually remove stamp-configure and stamp-debian for it to have an effect -- I strongly suggest you run make-kpkg clean unless you know what you are doing). Additionally, official source package maintainers provide their own version numbers and data for the official uploads, and hence a number of things, including the Debian revision, is not modified by make-kpkg. If you happen to have an official source, (that would mean that the file debian/official exists, and is not empty), and want to use your own revision number, make sure you remove debian/official before running make-kpkg clean for this option to have an effect. So, if you want to re-run make-kpkg with a different revision number, you have to make sure you start with a clean slate. Secondly, the version may contain only alphanumerics and the characters ~ + . (tilde, full stop and plus) and must contain a digit. (Look at the Policy manual for details). Actually, that is a lie: official kernel and modules maintainers have special dispensation to use hyphens, but it is strongly deprecated for most people, since no sanitization of the version number is done, and dpkg and friends may choke on it at the end of the compile unless one knows what one is doing. Optionally, you may prepend the revision with a digit followed by a colon (:). The default is 10.00.Custom unless the environment variable DEBIAN_REVISION_MANDATORY is set, in which case an error is generated if the revision is not set on the command line or the configuration file.

This argument ( foo ) is appended to the value of the EXTRAVERSION variable present in the kernel Makefile. Since EXTRAVERSION is a component of the kernel version, it is also added to the Debian package name, and, as such must obey the policy governing the package name. That means it may contain only lowercase alphanumerics and the characters ~ - + . (tilde, full stop, hyphen, and plus). Uppercase letters are not permitted under the Policy for a new package. If the environment variable IGNORE_UPPERCASE_VERSION is set, make-kpkg shall lower case version numbers set in the Makefile or in the localversion file. This option over rides the environment variable APPEND_TO_VERSION Please note that you \s-1must\s0 run a make-kpkg clean after configuring the kernel using make (x|menu)?config, since that creates the file include/linux/version.h without the append_to_version data (foo). This file won't be updated by the make-kpkg run (make-kpkg creates version.h if it doesn't exist, but doesn't touch if exists), so the final kernel will _not_ have the append_to_version data in its version number it shall look for the modules and symbols in all the wrong places. The simplest solution is either to remove include/linux/version.h after configuring and before compiling, or running make-kpkg clean after configuring, before compiling. Note also that once you use R --append_to_version foo for configuring, or building the kernel-image, you need to also use the same option in any later invocation of make-kpkg (say, for building stand alone modules, or something). make-kpkg does not remember the argument foo in between invocations (this is different from the behavior of --revision, which we do remember in between invocations). If you are annoyed by make-kpkg whining about using R --append_to_version and there already being a version.h file from before, you can set the environment variable VERSION_H_OK which shall shut off the warning.

The argument should be a comma separated list of additional add-on modules (not in the main kernel tree) that you wish to build when you invoke the modules_blah targets. You may give full path names of the directory the modules reside in, or just the module name if it can be found in MODULE_LOC, which defaults to /usr/src/modules. The default is that all modules in MODULE_LOC, are compiled when the modules_blah targets are invoked.

The argument should be a comma separated list of additional patches to the kernel sources. This automatically sets the patch_the_kernel configuration option to YES.

This is useful for setting the architecture when you are cross compiling. If you are not cross compiling, the architecture is determined automatically. The same effect can be achieved by setting the environment variable KPKG_ARCH. The value should be whatever DEB_HOST_ARCH_CPU contains when dpkg-architecture is run on the target machine, or it can be an other architecture in a multi-arch set (like i386/amd64).

This is useful for setting the target string when you are cross compiling. Use the dummy target "-" if you are building for other arches of a multiarch set, like i386/amd64. The same effect can be achieved by setting the environment variable. Please note that this does not in any way set the compiler the kernel build process shall use; if the default compiler that the build process comes up with is not the one desired, please explicitly specify the compiler that should be used. CROSS_COMPILE

Some architectures (the Alpha, and the m68k) require a different kernel for each sub-architecture. This option provides a way of specifying it as an argument to make-kpkg. Please note that additional support for sub-architectures may be required in the kernel sources to actually make this do anything. The same effect can be achieved by setting the environment variable KPKG_SUBARCH

This option uses an extended name for the kernel image package by embedding the sub-architecture in the image name, so one could write a script to create multiple sub-architectures one after the other. You may also do this by setting the environment variable ARCH_IN_NAME. Please note that only the package name is affected, not modules locations etc.

Set the string used to sign the changes file for any external modules in R /usr/src/modules/ using PGP. This option will override the builtin default and the site wide customizations stored in the file R /etc/kernel-pkg.conf or R ~/.kernel-pkg.conf.

Change the type of configure done from the default CWoldconfig. target must be one of CWoldconfig, CWconfig, CWmenuconfig, CWgconfig, CWxconfig, CWrandconfig,, CWdefconfig, CWallmodconfig, CWallyesconfig, CWallnoconfig; CWold, CWmenu, CWg, or CWx. This option is particularly useful when using \s-1PATCH_THE_KERNEL\s0 if some of the patches change what configuration options are available. Note however that R make-kpkg scans the config file at startup for some options, notably the fact that modules are enabled or not, so toggling the status during the delayed configuration results in an error. If needed, create the configuration file as close to the desired one before calling make-kpkg with this switch.

Prints out a list of known targets. See the Section Targets below.

Pass a -n option to the make process so that commands are merely printed to the screen but not actually executed. This is very useful for debugging.

This calls make with the -V=1 option, which calls out the top level Make commands, also useful in seeing what is happening.

If make-kpkg is generating a kernel-image package, perform any actions necessary for a kernel loaded using initrd. NOTE: in older kernels, this required a non-standard cramfs initrd patch to the kernel sources, (unless the mkinitrd configuration was modified not to use cramfs) or may result in a unbootable kernel. The patch was usually present in the kernel sources shipped by Debian. Some architectures still need patches to fix cramfs problems. This option may include extra dependencies, and modifications to maintainer scripts. It has no effect when make-kpkg is not making a kernel-image package. The same effect can be achieved by setting the environment variable INITRD to any non empty value.

Makes a zImage kernel rather than a bzImage kernel (the default). Useful for people having problems with bzImage kernels.

Makes a bzImage kernel. Useful for people who want a bzImage kernel on sites where the default is zImage kernels.

This should be a command that produces an initrd image given a directory. It is passed to the mkinitrd program's -m option. For example, it can be "genromfs -d %s -f %s" or "mkcramfs %s %s"

The command that provides a means of gaining super user access (for example, `sudo' or `fakeroot') as needed by dpkg-buildpackage's -r option.

Call the packages foo-* instead of kernel-*. This is useful in helping transition from calling the packages kernel-* to linux-* packages, in preparation for non-linux kernels in the distribution. The default is linux.

This option is passed to dpkg-buildpackage, and directs that package not to sign the source. This is only relevant for the buildpackage target.

This option is passed to dpkg-buildpackage, and directs that package not to sign the changelog. This is only relevant for the buildpackage target.

If defined, this environment variable sets the concurrency level of make used to compile the kernel and the modules set using -j flags to the sub make in the build target of make-kpkg. Should be a (small) integer, if used. You can get the current number of CPUs using the command: "grep -c '^processor' /proc/cpuinfo" WARNING: Do NOT set the -j option in MAKEFLAGS directly, this shall call the build to fail.

Cleans the kernel source directory of all files created by target build, and runs a make distclean. (Please look at a Linux kernel Makefile for details). Please note that although we take care of the list of current kernel configuration contained in the file .config, the file include/linux/autoconf.h is not preserved. This target should not be combined with other targets, since make-kpkg reads in all data before running any target, so the subsequent targets shall be run with the old data, which may not be what you want.

This target runs the targets clean, and binary, and produces the complete package using dpkg-buildpackage

This target produces all four Debian kernel packages by running the targets binary-indep and binary-arch.

This target produces the arch independent packages by running the targets kernel_source, kernel_manual and kernel_doc.

This target produces the arch dependent packages by running the targets kernel_headers and kernel_image.

This target produces a debianised package of the Linux kernel sources. If the environment variable SOURCE_CLEAN_HOOK points to an executable, then that executable shall be run from the temporary (top) directory of the kernel sources just before packaging it, ./debian/tmp-source/usr/src/kernel-source-X.X.XX, so people may take any action they see fit (remove arch trees, prune version control directories, find . -type d -name CVS -prune -exec rm -rf {} \; etc). This has no effect on anything other than the kernel sources that are being packaged -- if the script operates on the current directory and its children, the original source tree should remain intact. The environment variables HEADER_CLEAN_HOOK and DOC_CLEAN_HOOK are similar. They should point to executables, then that executable shall be run from the temporary (top) directory of the kernel headers and documentation just before packaging respectively, so people may take any action they see fit. This also has no effect on anything other than the sources that are being packaged.

This target produces a Debian package containing the header files included in the Linux kernel.

This target produces a Debian package containing the section 9 manual pages included in the Linux kernel. Please note that this is not really an independent target; calling this shall also invoke the kernel_doc target, and creates a kernel-doc package at the same time.

This target produces a Debian package containing the documentation included in the Linux kernel. This can be called independently of the kernel_manual target, but not the other way around.

This target produces a Debian package of the Linux kernel source image, and any modules configured in the kernel configuration file .config. If there is no .config file in the kernel source directory, a default configuration is provided similar to the one used to create the Debian boot-floppies.

This target, used by target kernel_image above, compiles the Linux kernel image.

This target allows you to build all add-on modules and packages that are very dependent on the precise kernel version they are compiled for at the same time you build your kernel image. This target expects to find the modules or packages under /usr/src/modules, and, for all such directories, changes to MODULE_LOC/x (MODULE_LOC defaults to /usr/src/modules. ), and runs the kdist rule in the local debian.rules file. This target should create the Debian module package(s), and may also produce a compressed tar file, and a compressed diff file, with md5sums recorded in a changes file using dpkg-genchanges. The file is signed by the same identity that would be used to sign the kernel packages. This option is used by maintainers uploading the package to the Debian archives.

This target allows you to configure all packages under MODULE_LOC, which defaults to /usr/src/modules. This is useful if you need to manually modify some aspects of the configuration, or if you want to manually compile the add on modules. This should not be called unless you already have a ./debian directory.

This target allows you to build all packages under MODULE_LOC, which defaults to /usr/src/modules, but does not create the source or diff files, and does not create and sign a changes file. This is the only modules related option you need if you just want to compile the add on modules image files for installation on one or more machines. Generally called in conjunction with kernel_image, especially if also using the option append_to_version (prevents spurious warnings). This should not be called unless you already have a ./debian directory.

This target allows you to clean all packages under MODULE_LOC, which defaults to /usr/src/modules, and this should be all that is needed to undo the effect of any of the other modules_ targets. This should not be called unless you already have a ./debian directory.

This target runs configure (actually, config_target, set by --config which defaults to oldconfig ) early, so you may edit files generated by make config in the kernel source directory and not have them stomped by make-kpkg later.

This target creates the ./debian directory, and optionally patches the source. This target is called by the configure target. You may use this target to have the sources patched, and then manually run the configuration step to update the configuration file, with any new configuration options the patches may have introduced.

This is a special target for the libc-dev maintainer, who can use it to create the headers package that libc needs. Please note that it is dangerous to create a libc-kheaders package that is different from the headers libc was compiled with; it is known to subtly break systems. Please look at /usr/share/kernel-package/README.headers for details. Creating and installing a self created libc-kheaders package may break your system unless you know what you are doing. You have been warned.