                         Building Kernel Modules

Introduction

  The easiest way to get AFS modules is to install prebuilt modules.  For
  example, if you are running kernel 2.6.26-2-686, you might try:

      apt-get install openafs-modules-2.6.26-2-686

  Pre-built modules are not provided with Debian (building and maintaining
  them in Debian proper poses too many problems), but many organizations
  that use OpenAFS build their own and provide them locally.

  If this doesn't work, you will need to build your own modules.  There
  are three methods for doing this.

  When following any of these methods, be aware that the Debian package
  creates a module named openafs, not libafs as is used by upstream.  It
  also prefers not to add the .mp extension for modules built for SMP
  kernels; the indication of whether the module is for an SMP kernel
  should go into the package name via something like --append_to_version,
  not into the file name of the module.

DKMS

  DKMS is relatively new and untested compared to the other mechanisms for
  building kernel modules, but if it works for you, it's the easiest.
  DKMS stands for Dynamic Kernel Module Support.  It provides
  infrastructure that will automatically rebuild kernel modules when the
  source package or the kernel has been upgraded.

  To build OpenAFS kernel modules via DKMS, just install the
  openafs-modules-dkms package.  This depends on DKMS and will install it
  as well.  The OpenAFS kernel modules should then be built automatically
  and will be installed under updates/dkms in the module tree for your
  kernel.

module-assistant

  This method is the best method for manually building kernel modules for
  kernels that come with Debian, since module-assistant knows how to get
  the right header files to build modules for your currently running
  kernel.  Generally, all you should have to do is:

      apt-get install module-assistant
      module-assistant auto-install openafs

  This combines all of the following steps, taking the defaults.  If you
  want to do it more step-by-step, first prepare the kernel headers and
  install openafs-modules-source with:

      apt-get install module-assistant
      module-assistant prepare openafs-modules

  If you want to build modules for a different kernel than your currently
  running one, pass the -l flag to module-assistant.  See the man page.
  module-assistant may be able to find the right packages itself or it may
  tell you to install particular packages.  Once you've finished with
  that, build the module with:

      module-assistant auto-build openafs-modules

  You may prefer to pass module-assistant the -t flag to get more
  conventional output.  If everything works correctly, the openafs-modules
  deb should be created in /usr/src.  You can use dpkg -i to install it.

  module-assistant will take care of naming the openafs-modules package
  correctly so that it matches the name of the kernel-image package and
  installs its modules into the correct directory.

make-kpkg

  This method may work better than module-assistant if you're also
  building your own kernel rather than using the pre-packaged Debian one.

  Install a kernel source package and untar it in /usr/src.  Then, install
  openafs-modules-source.

      apt-get install openafs-modules-source

  Next, unpack openafs-modules-source:

      cd /usr/src
      tar xzf openafs.tar.gz

  Now, change into your kernel source tree.  You should then create a
  .config file; the easiest way to do this is to run make menuconfig or to
  copy in a kernel configuration from the same version of the kernel.
  Debian kernel packages store a copy of their kernel configuration in
  /boot/config.version_number.

  The kernel configuration needs to be identical to the configuration that
  produced the kernel that you're using.  Ideally, you would build the
  kernel image you're going to use with make-kpkg kernel_image and install
  that along with the module image, although as long as the configuration
  is identical, you may be able to get away with using a pre-built kernel.
  (A better approach, if you're using pre-built kernels, may be to use
  module-assistant as described above.)

  Finally, build the modules:

      make-kpkg modules_image

  You may need to use the --append_to_version switch to add version
  suffixes like -686 or -smp to match your kernel and install the OpenAFS
  module into a directory like /lib/modules/version-686.  Be aware that
  the Debian OpenAFS packages build either a regular module or an SMP
  module, not both, so the generated package will only work with a kernel
  with the same SMP configuration.

  An openafs-modules deb should be created in /usr/src.  Use dpkg -i to
  install this package.
