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 pre-
       viously configured (unless you are using the  configure  target).  Nor-
       mally,  if  kernel-package  does not find a .config file in the current
       directory, it tries very hard to get an appropriate one (usually a con-
       fig  file  already  tailored for Debian kernels for that architecture),
       and then calls make oldconfig to let the user answer any new questions.
       Typically,  you  run  this  command as root, or under fakeroot, or tell
       make-kpkg how to become root, like so:

            make-kpkg --rootcmd fakeroot kernel_image

       The Debian package file is created in the parent directory of the  ker-
       nel 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 variable MAKEFLAGS.  To observe,

         % 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

       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 characters ~ + . (tilde, full
              stop and plus) and must contain a digit.  (Look  at  the  Policy
              manual  for  details).  Optionally, you may prepend the revision
              with a digit followed by a colon (:). The default is  10.00.Cus-
              tom 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.  Hint: You
              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 ver-
              sion  numbers  set  in the Makefile or in the localversion file.
              This option overrides the  environment  variable  APPEND_TO_VER-

       --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 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  MOD-
              ULE_LOC, are compiled when the modules_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 an other architecture in
              a multi-arch set (like i386/amd64).

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

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


              This  option  uses an extended name for the kernel image package

       --config target
              Change  the  type  of configure done from the default oldconfig.
              target must be one of oldconfig,  config,  menuconfig,  gconfig,
              xconfig, randconfig, defconfig, allmodconfig, allyesconfig, all-
              noconfig,  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

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

              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  main-
              tainer  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 kernel-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 example 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 environ-

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

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

       --rootcmd foo
              The command that provides a means of gaining super  user  access
              (for example, `sudo' or `fakeroot') as needed by dpkg-buildpack-
              age's -r option. This option does not work for three of the tar-
              gets,  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  distribu-
              tion.  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.

              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 kernel_source, kernel_manual and  kernel_doc.   How-
              ever,  this  also requires make-kpkg to be run as root (or fake-
              root), since --rootcmd will not work.

              This target produces the arch dependent packages by running  the
              targets  kernel_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 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 vari-
              ables 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  any-
              thing other than the sources that are being packaged.

              This  target  produces a Debian package containing the debugging
              symbols for the modules contained  in  the  corresponding  image
              package.  The  basic idea here is to keep the space in /lib/mod-
              ules/<kver> under control, since this could be on a root  parti-
              tion with space restrictions.

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

              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 directories where packages, or the local admin, may
              drop in  script  files.  The  directories  are  /etc/kernel/pre-
              inst.d/,      /etc/kernel/postinst.d/,     /etc/kernel/prerm.d/,
              /etc/kernel/postrm.d/,         /etc/kernel/preinst.d/<VERSION>/,
              /etc/kernel/postinst.d/<VERSION>/,     /etc/kernel/prerm.d/<VER-
              SION>/, and /etc/kernel/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  version
              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  KER-
              NEL_PACKAGE_VERSION  shall  be  set  to  the version of the ker-
              nel-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 disappear.

              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  dele-
              tion,  the package checks the version of the kernel running, and
              refuses to delete a running kernel.  grub rates a  special  men-
              tion  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.

              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  ker-
              nel  packages.  This option is used by maintainers uploading the
              package to the Debian archives.

              This target allows you to  configure  all  packages  under  MOD-
              ULE_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  direc-

              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 instal-
              lation 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_ tar-
              gets.  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 tar-
              get. You may use this target to have the  sources  patched,  and
              then  manually run the configuration step to update the configu-
              ration 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/ker-
              nel-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.

       also looks for a per user configuration file ~/.kernel-pkg.conf.  Fail-
       ing that, it  looks  for  site-wide  defaults  in  the  file  /etc/ker-
       nel-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  maintaining  the  kernel  packages  on the site, but the /etc/ker-
       nel-pkg.conf (or ~/.kernel-pkg.conf) file is actually a Makefile  snip-
       pet,  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),   ker-
       nel-img.conf(5),      kernel-pkg.conf(5),       The Programmers manual,
       The GNU Make manual,   and   the   extensive   documentation   in   the
       /usr/share/doc/kernel-package directory

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

Debian                            Nov 14 2002                     MAKE-KPKG(1)
Man Pages Copyright Respective Owners. Site Copyright (C) 1994 - 2019 Hurricane Electric. All Rights Reserved.