1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
|
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 has some caveats, but it's the easiest method of building modules.
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, install the linux-headers
package corresponding to the version of the kernel that you have
installed and then 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.
Please note that DKMS will only build modules for kernels that have the
Linux headers installed. When you upgrade your kernel, you need to
install the new linux-headers package at the same time, or you'll end up
without an OpenAFS module for the new kernel. If you're using the
tracking packages for the kernel (linux-image-2.6-686 or the like), also
install the tracking package for the kernel headers
(linux-headers-2.6-686 in that example).
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.
If you have ever previously built a module with module-assistant, always
run:
module-assistant clean openafs
before building a new module. module-assistant doesn't always properly
clean up after itself, and the mix of files from old and new versions of
OpenAFS can cause serious problems with the resulting module.
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.
|
