:: RootR ::  Hosting Order Map Login   Secure Inter-Network Operations  
make-kpkg(1) - phpMan

Command: man perldoc info search(apropos)  

MAKE-KPKG(1)                         Debian GNU/Linux manual                         MAKE-KPKG(1)

       make-kpkg - build Debian kernel packages from Linux kernel sources

       make-kpkg [options] [target [target ...]]

       This manual page explains the Debian make-kpkg utility, which is used to create the kernel
       related Debian packages. This utility needs to be run from a top level Linux kernel source
       directory,  which  has been previously configured (unless you are using the configure tar‐
       get). Normally, if kernel-package does not find a .config file in the  current  directory,
       it  tries  very hard to get an appropriate one (usually a config file already tailored for
       Debian kernels for that architecture), and then calls  make  oldconfig  to  let  the  user
       answer  any new questions. However, this might still result in an inappropriate configura‐
       tion, you are encouraged to confugre  the  kernel  by  the  usual  means  before  invoking

       Typically, make-kpkg should be run under fakeroot,

            make-kpkg --rootcmd fakeroot kernel_image

       but  instead you run this command as root (this is not recommended), or under fakeroot, or
       tell make-kpkg how to become root (not recommended either, fakeroot is perhaps the  safest
       option), like so:

            make-kpkg --rootcmd sudo kernel_image

       The  Debian package file is created in the parent directory of the kernel source directory
       where this command is run.

       Also, please note that some versions of gcc do not interact well with the  kernel  sources
       (gcc 2.95 has problems compiling the kernel without the flag '-fno-strict-aliasing'.  This
       issue has been taken care of for recent kernels (2.2 and 2.4 series are fine) (I think you
       may  have  to  edit  the makefile for older kernels, or something).  You may control which
       version of gcc used in kernel compilation by setting the Makefile variables CC and  HOSTCC
       in  the top level kernel Makefile. You can do this simply by setting the environment vari‐
       able MAKEFLAGS.  To observe, try:

         % KBUILD_VERBOSE=1 MAKEFLAGS="CC=gcc-4.4" make-kpkg configure

       The KBUILD_VERBOSE shows the details of the commands being run.  (please see the top level
       kernel Makefile for variables that can be set).

       WARNING:  Do  NOT  set  the -j option in MAKEFLAGS directly, this shall cause the build to
       fail. Use CONCURRENCY_LEVEL as specified below. There is also a -j flag that can be used.

       --help Print out a usage message.

       --revision number
              Changes the version number for the packages produced to the argument number.   This
              has certain constraints: the version may contain only alphanumerics and the charac‐
              ters ~ + . (tilde, full stop and plus) and must contain a digit. (Look at the  Pol‐
              icy manual for details). Optionally, you may prepend the revision with a digit fol‐
              lowed 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 revi‐
              sion is not set on the command line or the configuration file.  Hint: You  may  set
              it to $(version)-<foo> in the configuration file to get the upstream version number
              prepended to your custom string <foo>.

       --append-to-version foo

       --append_to_version foo
              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 govern‐
              ing  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 overrides the environment
              variable APPEND_TO_VERSION.

       --added-modules foo

       --added_modules foo
              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 tar‐
              gets. 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/mod‐
              ules.  The default is that all modules in MODULE_LOC, are compiled  when  the  mod‐
              ules_blah targets are invoked.

       --arch foo
              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  another  architecture  in a multi-arch set (like

       --cross-compile foo

       --cross_compile foo
              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.

       --subarch foo
              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 environ‐
              ment  variable  ARCH_IN_NAME.   Please note that only the package name is affected,
              not modules locations etc.

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

       --config target
              Change  the  type of configure done from the default oldconfig.  target must be one
              of oldconfig, config, menuconfig, gconfig, nconfig, xconfig, randconfig, defconfig,
              allmodconfig, allyesconfig, allnoconfig,  old, menu, g, or x.

              Note  however  that  make-kpkg  scans the config file at start up 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, arrange to convey  to  the  hook
              scripts  run from the post installation maintainer scripts that this image requires
              an initrd, and that the initrd generation hook scripts  should  not  short  circuit
              early. Without this option, the example initramfs hook scripts bundled in with ker‐
              nel-package will take no action on installation.  The same effect can  be  achieved
              by  setting  the  environment  variable INITRD to any non empty value.  Please note
              that unless there are hook scripts in /etc/kernel or added  into  the  hook  script
              parameter  of /etc/kernel-img.conf, no initrd will be created (the bundled in exam‐
              ple scripts are just examples -- user action is required before anything happens).

       --jobs number

       -j number
              Set the environment variable CONCURRENCY_LEVEL to number.

       --overlay-dir /path/to/directory
              The specified directory should contain files that will be placed  in  the  ./debian
              directory  of  the  kernel sources, in preparation to building the debian packages.
              The files will replace anything in /usr/share/kernel-package that would normally be
              placed  there,  and it is up to the user to make sure that the files in the overlay
              directory are compatible with make-kpkg.  If you break make-kpkg  with  an  overlay
              file,  you  get  to keep the pieces. The same effect can be achieved by setting the
              environment variable KPKG_OVERLAY_DIR.

              Please note that overlay-dir/Control and  overlay-dir/changelog  are  special,  and
              variable  substitution  is  performed  on  these files. Use /usr/share/kernel-pack‐
              age/Control and /usr/share/kernel-package/changelog files as templates.

              If a overlay-dir/post-install executable (or executable script) exists, it shall be
              run  immediately  after  ./debian is populated. The script shall be executed in the
              ./debian directory. This can be used, for instance, to delete files the  user  does
              not want, or to take actions other than simple replacement.

       --rootcmd foo
              The command that provides a means of gaining super user access (for example, `sudo'
              or `fakeroot') as needed by dpkg-buildpackage's -r option.  This  option  does  not
              work  for three of the targets, namely, binary, binary-indep, and binary-arch.  For
              those targets the entire make-kpkg command must be run as (fake)root.

       --stem foo
              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. The stem, since it  is
              the initial part of a package name must consist only of lower case letters (`a-z'),
              digits (`0-9'), plus (`+') and minus (`-') signs, and periods (`.').  It must be at
              least two characters long and must start with an alphanumeric character.

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

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

       The  options maybe shortened to the smallest unique string, and may be entered with either
       a - or a -- prefix, and you may use a space or an = symbol between an option string and  a
       value.  You  may also use the form option=value; for details these and other variant forms
       supported, please read Getopt::Long(3perl).

              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. It is possible to set -j as a make-kpkg argument.

       clean  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.

       binary This  target  produces  all  four  Debian  kernel  packages  by running the targets
              binary-indep and binary-arch.  However, this requires make-kpkg to be run  as  root
              (or fakeroot), since --rootcmd will not work.

              This  target  produces  the  arch  independent packages by running the targets ker‐
              nel_source, kernel_manual and kernel_doc.  However, this also requires make-kpkg to
              be run as root (or fakeroot), since --rootcmd will not work.

              This  target  produces  the  arch  dependent  packages  by running the targets ker‐
              nel_headers and kernel_image.  However, this also requires make-kpkg to be  run  as
              root (or fakeroot), since --rootcmd will not work.

              This  target  produces  a  debianised  package of the Linux kernel sources.  If the
              environment variable SOURCE_CLEAN_HOOK points to  an  executable,  then  that  exe‐
              cutable  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 directo‐
              ries, 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 debugging symbols for the mod‐
              ules contained in the corresponding image package. The basic idea here is  to  keep
              the  space in /lib/modules/<kver> under control, since this could be on a root par‐
              tition with space restrictions. Please note that if module signatures are enable in
              the kernel configuration the corresponding image package will not have modules with
              the debugging link pointing to these debugging symbol files. In order  to  turn  on
              debugging links for modules in the image package you need to turn off module signa‐

              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 ker‐
              nel-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 .con‐
              fig file in the kernel source directory, a default configuration is provided  simi‐
              lar to the one used to create the Debian boot-floppies. If the kernel configuration
              file has enabled support for modules, modules will be  created  and  installed.  If
              module  signatures  are  not enabled, the resulting modules will have a link to the
              location of the debugging symbols file for the mdoule,  usually  installed  by  the
              debug package.

              If  the  file  ./debian/post-install  exists,  and is an executable, it is run just
              before the kernel image package is created.  Also, please note that  if  there  are
              any  scripts  in  ./debian/image.d/  directory,  run-parts  shall be called on that
              directory just before the kernel image package is built. The location of  the  root
              of  the  image  package  being  built  shall  be passed in the environment variable
              IMAGE_TOP, and the kernel version is passed in  through  the  environment  variable
              version for all these scripts.

              Please  see  the  documentation about hooks in kernel-img.conf(5).  These hooks are
              variables that can be pointed by the local sysadmin to scripts that add or remove a
              line  from  the  grub  menu list at kernel image install and remove times. A sample
              script  to  add  lines  to  a  grub  menu  file  is  included  in   the   directory

              Apart from hook variables that the local admin may set, there are a set of directo‐
              ries where packages, or the local admin, may drop in script files. The  directories
              are    /etc/kernel/preinst.d/,    /etc/kernel/postinst.d/,    /etc/kernel/prerm.d/,
              /etc/kernel/postrm.d/,         /etc/kernel/preinst.d/<VERSION>/,          /etc/ker‐
              nel/postinst.d/<VERSION>/,     /etc/kernel/prerm.d/<VERSION>/,     and    /etc/ker‐
              nel/postrm.d/<VERSION>/.  If they exists, the  kernel-image  package  shall  run  a
              run-parts program over the directory (including the versioned one), giving the ver‐
              sion being installed or removed as an  argument,  in  the  corresponding  phase  of
              installation  or removal. Before calling these scripts, the env variable STEM shall
              be set to the value of the --stem argument (or the default value, linux),  and  the
              variable  KERNEL_PACKAGE_VERSION  shall be set to the version of the kernel-package
              that created the package. These scripts shall be called  with  two  arguments,  the
              first  being  the  version  of  the kernel image, and the second argument being the
              location of the kernel image itself. Since debconf is in use before the  script  is
              called,  this  script  should  issue no diagnostic messages to stdout --  while the
              postinst does call db_stop, debconf does not restore stdout, so messages to  stdout

              On  installation,  it also offers to run the Linux loader, LILO (or alternates like
              loadlin, SILO, QUIK, VMELILO, ZIPL, yaboot, PALO or GRUB), creating a configuration
              file  for  supported boot loaders if needed. At that time it also offers to put the
              new kernel on a floppy, formatting the floppy if needed.  On deletion, the  package
              checks  the  version of the kernel running, and refuses to delete a running kernel.
              grub rates a special mention here, since grub  may  not  need  to  be  rerun  after
              installing  a  kernel  image,  though an automated change to the menu list would be
              nice on install and removal of kernel image packages.

       build  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 (MOD‐
              ULE_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.

       debian 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 config‐
              uration 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-pack‐
              age/README.headers for details.  Creating and installing a self created libc-khead‐
              ers package may break your system unless you know what you are doing. You have been

       KPKG_DEBUG, if set, causes make-kpkg to spit out debugging messages about some shell func‐
       tions  executed  internally.  This  is  probably  of  not interest to anyone not debugging
       make-kpkg.  The following variables (documented above) also affect make-kpkg: DEBIAN_REVI‐

       Apart  from  the  runtime options, the debian.rules file run by make-kpkg also looks for a
       per user configuration file ~/.kernel-pkg.conf.  Failing  that,  it  looks  for  site-wide
       defaults in the file /etc/kernel-pkg.conf.  The default configuration allows there to be a
       site wide override for the full name and email address of the person responsible for main‐
       taining  the  kernel  packages  on  the  site,  but  the  /etc/kernel-pkg.conf (or ~/.ker‐
       nel-pkg.conf) file is actually a Makefile snippet, and any legal make  directives  may  be
       included  in  there.   Note: Caution is urged with this file, since you can totally change
       the  way  that  the  make  is  run  by  suitably  editing  this  file.  Please   look   at
       /usr/share/doc/kernel-package/Problems.gz  for  a  list  of known problems while compiling
       kernel  images.   Extensive   tutorial   like   documentation   is   also   available   in
       /usr/share/doc/kernel-package/README.gz  and  it  is recommended that one read that before
       using this utility.

       dpkg-deb(1),  dpkg-source(1),  make(1),  Getopt::Long(3perl),   kernel-img.conf(5),   ker‐
       nel-pkg.conf(5), The Programmers manual, The GNU Make manual, and the extensive documenta‐
       tion in the /usr/share/doc/kernel-package directory

       This manual page was written by Manoj Srivastava  <srivasta AT debian.org>,  for  the  Debian
       GNU/Linux system.

Debian                                     Nov 14 2002                               MAKE-KPKG(1)

rootr.net - man pages