scripts/kmodtool

   1 #!/bin/bash
   2
   3 # kmodtool - Helper script for building kernel module RPMs
   4 # Copyright (c) 2003-2012 Ville Skyttä <ville.skytta@iki.fi>,
   5 #                         Thorsten Leemhuis <fedora@leemhuis.info>
   6 #                         Nicolas Chauvet <kwizart@gmail.com>
   7 #
   8 # Permission is hereby granted, free of charge, to any person obtaining
   9 # a copy of this software and associated documentation files (the
  10 # "Software"), to deal in the Software without restriction, including
  11 # without limitation the rights to use, copy, modify, merge, publish,
  12 # distribute, sublicense, and/or sell copies of the Software, and to
  13 # permit persons to whom the Software is furnished to do so, subject to
  14 # the following conditions:
  15 #
  16 # The above copyright notice and this permission notice shall be
  17 # included in all copies or substantial portions of the Software.
  18 #
  19 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  20 # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  21 # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  22 # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  23 # LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  24 # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  25 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  26
  27 shopt -s extglob
  28
  29 myprog="kmodtool-${repo}"
  30 myver="0.12.1"
  31
  32 kmodname=
  33 build_kernels="current"
  34 kernels_known_variants=
  35 kernel_versions=
  36 kernel_versions_to_build_for=
  37 prefix=
  38 filterfile=
  39 target=
  40
  41 error_out()
  42 {
  43         local errorlevel=${1}
  44         shift
  45         echo "Error: $@" >&2
  46         # the next line is not multi-line safe -- not needed *yet*
  47         echo "%global kmodtool_check echo \"kmodtool error: $@\"; exit ${errorlevel};"
  48         exit ${errorlevel}
  49 }
  50
  51 print_rpmtemplate_header()
  52 {
  53         echo
  54         echo '%global kmodinstdir_prefix  '${prefix}/lib/modules/
  55         echo '%global kmodinstdir_postfix '/extra/${kmodname}/
  56         echo '%global kernel_versions     '${kernel_versions}
  57         echo
  58 }
  59
  60 print_akmodtemplate ()
  61 {
  62         echo
  63         cat <<EOF
  64
  65 %global akmod_install mkdir -p \$RPM_BUILD_ROOT/%{_usrsrc}/akmods/; \\\
  66 rpmbuild --define "_sourcedir %{_sourcedir}" \\\
  67 --define "_srcrpmdir \$RPM_BUILD_ROOT/%{_usrsrc}/akmods/" \\\
  68 -bs --nodeps %{_specdir}/%{name}.spec ; \\\
  69 ln -s \$(ls \$RPM_BUILD_ROOT/%{_usrsrc}/akmods/) \$RPM_BUILD_ROOT/%{_usrsrc}/akmods/${kmodname}-kmod.latest
  70
  71 %package -n akmod-${kmodname}
  72 Summary:        Akmod package for ${kmodname} kernel module(s)
  73 Group:          System Environment/Kernel
  74 Requires:   kmodtool
  75 Requires:       akmods
  76 %{?AkmodsBuildRequires:Requires: %{AkmodsBuildRequires}}
  77 # same requires and provides as a kmods package would have
  78 Requires:       ${kmodname}-kmod-common >= %{?epoch:%{epoch}:}%{version}
  79 Provides:       ${kmodname}-kmod = %{?epoch:%{epoch}:}%{version}-%{release}
  80 EOF
  81
  82         if [[ ${obsolete_name} ]]; then
  83                 echo "Provides:   akmod-${obsolete_name} = ${obsolete_version}"
  84                 echo "Obsoletes:  akmod-${obsolete_name} < ${obsolete_version}"
  85         fi
  86
  87         cat <<EOF
  88
  89 %description -n akmod-${kmodname}
  90 This package provides the akmod package for the ${kmodname} kernel modules.
  91
  92 %posttrans -n akmod-${kmodname}
  93 nohup ${prefix}/sbin/akmods --from-akmod-posttrans --akmod ${kmodname} &> /dev/null &
  94
  95 %files -n akmod-${kmodname}
  96 %defattr(-,root,root,-)
  97 %{_usrsrc}/akmods/*
  98
  99 EOF
 100 }
 101
 102 print_akmodmeta ()
 103 {
 104                 cat <<EOF
 105 %package      -n kmod-${kmodname}
 106 Summary:         Metapackage which tracks in ${kmodname} kernel module for newest kernel${dashvariant}
 107 Group:           System Environment/Kernel
 108
 109 Provides:        ${kmodname}-kmod = %{?epoch:%{epoch}:}%{version}-%{release}
 110 Provides:        kmod-${kmodname}-xen = %{?epoch:%{epoch}:}%{version}-%{release}
 111 Provides:        kmod-${kmodname}-smp = %{?epoch:%{epoch}:}%{version}-%{release}
 112 Provides:        kmod-${kmodname}-PAE = %{?epoch:%{epoch}:}%{version}-%{release}
 113 Requires:        akmod-${kmodname} = %{?epoch:%{epoch}:}%{version}-%{release}
 114 EOF
 115
 116         if [[ ${obsolete_name} ]]; then
 117                 echo "Provides:        kmod-${obsolete_name} = ${obsolete_version}"
 118                 echo "Obsoletes:       kmod-${obsolete_name} < ${obsolete_version}"
 119         fi
 120 cat <<EOF
 121
 122 %description  -n kmod-${kmodname}${dashvariant}
 123 This is a meta-package without payload which sole purpose is to require the
 124 ${kmodname} kernel module(s) for the newest kernel${dashvariant},
 125 to make sure you get it together with a new kernel.
 126
 127 %files        -n kmod-${kmodname}${dashvariant}
 128 %defattr(644,root,root,755)
 129 EOF
 130 }
 131
 132 print_rpmtemplate_per_kmodpkg ()
 133 {
 134         if [[ "${1}" == "--custom" ]]; then
 135                 shift
 136                 local customkernel=true
 137         elif [[ "${1}" == "--redhat" ]]; then
 138                 # this is needed for akmods
 139                 shift
 140                 local redhatkernel=true
 141         fi
 142
 143         local kernel_uname_r=${1}
 144         local kernel_variant="${2:+-${2}}"
 145
 146     # first part
 147         cat <<EOF
 148 %package       -n kmod-${kmodname}-${kernel_uname_r}
 149 Summary:          ${kmodname} kernel module(s) for ${kernel_uname_r}
 150 Group:            System Environment/Kernel
 151 Provides:         kernel-modules-for-kernel = ${kernel_uname_r}
 152 Provides:         kmod-${kmodname}-uname-r = ${kernel_uname_r}
 153 Provides:         ${kmodname}-kmod = %{?epoch:%{epoch}:}%{version}-%{release}
 154 Requires:         ${kmodname}-kmod-common >= %{?epoch:%{epoch}:}%{version}
 155 Requires(post):   ${prefix}/sbin/depmod
 156 Requires(postun): ${prefix}/sbin/depmod
 157 %{?KmodsRequires:Requires: %{KmodsRequires}-uname-r = ${kernel_uname_r}}
 158 %{?KmodsBuildRequires:BuildRequires: %{KmodsBuildRequires}-uname-r = ${kernel_uname_r}}
 159 %{?KmodsBuildRequires:BuildRequires: %{KmodsBuildRequires}}
 160 EOF
 161
 162         if [[ ${obsolete_name} ]]; then
 163                 echo "Provides:        kmod-${obsolete_name}-${kernel_uname_r} = ${obsolete_version}"
 164                 echo "Obsoletes:       kmod-${obsolete_name}-${kernel_uname_r} < ${obsolete_version}"
 165         fi
 166
 167         # second part
 168         if [[ ! "${customkernel}" ]]; then
 169              cat <<EOF
 170 Requires:         kernel-uname-r = ${kernel_uname_r}
 171 BuildRequires:    kernel-devel-uname-r = ${kernel_uname_r}
 172 %post          -n kmod-${kmodname}-${kernel_uname_r}
 173 ${prefix}/sbin/depmod -aeF /boot/System.map-${kernel_uname_r} ${kernel_uname_r} > /dev/null || :
 174 %postun        -n kmod-${kmodname}-${kernel_uname_r}
 175 ${prefix}/sbin/depmod  -aF /boot/System.map-${kernel_uname_r} ${kernel_uname_r} &> /dev/null || :
 176
 177 EOF
 178         else
 179           cat <<EOF
 180 %post          -n kmod-${kmodname}-${kernel_uname_r}
 181 [[ "$(uname -r)" == "${kernel_uname_r}"  ]] && ${prefix}/sbin/depmod -a > /dev/null || :
 182 %postun        -n kmod-${kmodname}-${kernel_uname_r}
 183 [[ "$(uname -r)" == "${kernel_uname_r}"  ]] && ${prefix}/sbin/depmod -a > /dev/null || :
 184
 185 EOF
 186         fi
 187
 188   # third part
 189         cat <<EOF
 190 %description  -n kmod-${kmodname}-${kernel_uname_r}
 191 This package provides the ${kmodname} kernel modules built for the Linux
 192 kernel ${kernel_uname_r} for the %{_target_cpu} family of processors.
 193 %files        -n kmod-${kmodname}-${kernel_uname_r}
 194 %defattr(644,root,root,755)
 195 %dir $prefix/lib/modules/${kernel_uname_r}/extra
 196 ${prefix}/lib/modules/${kernel_uname_r}/extra/${kmodname}/
 197
 198
 199 EOF
 200 }
 201
 202 print_rpmtemplate_kmoddevelpkg ()
 203 {
 204         cat <<EOF
 205 %package       -n kmod-${kmodname}-devel
 206 Summary:          ${kmodname} kernel module(s) devel common
 207 Group:            System Environment/Kernel
 208 Provides:         ${kmodname}-devel-kmod-common = %{?epoch:%{epoch}:}%{version}-%{release}
 209
 210 %description  -n kmod-${kmodname}-devel
 211 This package provides the common header files to build kernel modules
 212 which depend on the ${kmodname} kernel module.
 213 %files        -n kmod-${kmodname}-devel
 214 %defattr(644,root,root,755)
 215 %{_usrsrc}/${kmodname}-%{version}
 216 EOF
 217
 218         for kernel in ${1}; do
 219                 local kernel_uname_r=${kernel}
 220                 echo "%exclude %{_usrsrc}/${kmodname}-%{version}/${kernel_uname_r}"
 221         done
 222
 223         echo
 224         echo
 225 }
 226
 227 print_rpmtemplate_per_kmoddevelpkg ()
 228 {
 229         if [[ "${1}" == "--custom" ]]; then
 230                 shift
 231                 local customkernel=true
 232         elif [[ "${1}" == "--redhat" ]]; then
 233                 # this is needed for akmods
 234                 shift
 235                 local redhatkernel=true
 236         fi
 237
 238         local kernel_uname_r=${1}
 239         local kernel_variant="${2:+-${2}}"
 240
 241         cat <<EOF
 242 %package       -n kmod-${kmodname}-devel-${kernel_uname_r}
 243 Summary:          ${kmodname} kernel module(s) devel for ${kernel_uname_r}
 244 Group:            System Environment/Kernel
 245 Requires:         ${kmodname}-devel-kmod-common = %{?epoch:%{epoch}:}%{version}-%{release}
 246 Provides:         ${kmodname}-devel-kmod = %{?epoch:%{epoch}:}%{version}-%{release}
 247 Provides:         ${kmodname}-devel-kmod-uname-r = ${kernel_uname_r}
 248 EOF
 249
 250         # second part
 251         if [[ ! "${customkernel}" ]]; then
 252                 cat <<EOF
 253 Requires:         kernel-uname-r = ${kernel_uname_r}
 254 BuildRequires:    kernel-devel-uname-r = ${kernel_uname_r}
 255 EOF
 256         fi
 257
 258         cat <<EOF
 259 %description  -n kmod-${kmodname}-devel-${kernel_uname_r}
 260 This package provides objects and symbols required to build kernel modules
 261 which depend on the ${kmodname} kernel modules built for the Linux
 262 kernel ${kernel_uname_r} for the %{_target_cpu} family of processors.
 263 %files        -n kmod-${kmodname}-devel-${kernel_uname_r}
 264 %defattr(644,root,root,755)
 265 %{_usrsrc}/${kmodname}-%{version}/${kernel_uname_r}
 266
 267
 268 EOF
 269 }
 270
 271 print_rpmtemplate_kmodmetapkg ()
 272 {
 273                 local kernel_uname_r=${1}
 274                 local kernel_variant="${2:+-${2}}"
 275
 276                 cat <<EOF
 277 %package      -n kmod-${kmodname}${kernel_variant}
 278 Summary:         Metapackage which tracks in ${kmodname} kernel module for newest kernel${kernel_variant}
 279 Group:           System Environment/Kernel
 280
 281 Provides:        ${kmodname}-kmod = %{?epoch:%{epoch}:}%{version}-%{release}
 282 Requires:        kmod-${kmodname}-${kernel_uname_r} >= %{?epoch:%{epoch}:}%{version}-%{release}
 283 EOF
 284
 285                 if [[ ${obsolete_name} ]]; then
 286                         echo "Provides:        kmod-${obsolete_name}${kernel_variant} = ${obsolete_version}"
 287                         echo "Obsoletes:       kmod-${obsolete_name}${kernel_variant} < ${obsolete_version}"
 288                 fi
 289
 290                 cat <<EOF
 291
 292 %description  -n kmod-${kmodname}${kernel_variant}
 293 This is a meta-package without payload which sole purpose is to require the
 294 ${kmodname} kernel module(s) for the newest kernel${kernel_variant}.
 295 to make sure you get it together with a new kernel.
 296
 297 %files        -n kmod-${kmodname}${kernel_variant}
 298 %defattr(644,root,root,755)
 299
 300
 301 EOF
 302 }
 303
 304 print_customrpmtemplate ()
 305 {
 306         for kernel in ${1}
 307         do
 308                 if      [[ -e "/usr/src/kernels/${kernel}" ]] ; then
 309                         # this looks like a Fedora/RH kernel -- print a normal template (which includes the proper BR) and be happy :)
 310                         kernel_versions="${kernel_versions}${kernel}___%{_usrsrc}/kernels/${kernel} "
 311
 312                         # parse kernel versions string and print template
 313                         local kernel_verrelarch=${kernel%%${kernels_known_variants}}
 314                         print_rpmtemplate_per_kmodpkg --redhat ${kernel} ${kernel##${kernel_verrelarch}}
 315
 316                         # create development package
 317                         if [[ "${devel}" ]]; then
 318                                 print_rpmtemplate_per_kmoddevelpkg --redhat ${kernel} ${kernel##${kernel_verrelarch}}
 319                         fi
 320                 elif [[ -e ${prefix}/lib/modules/"${kernel}"/build/Makefile ]] ; then
 321                         # likely a user-build-kernel with available buildfiles
 322                         # fixme: we should check if uname from Makefile is the same as ${kernel}
 323
 324                         kernel_versions="${kernel_versions}${kernel}___${prefix}/lib/modules/${kernel}/build/ "
 325                         print_rpmtemplate_per_kmodpkg --custom "${kernel}"
 326
 327                         # create development package
 328                         if [[ "${devel}" ]]; then
 329                                 print_rpmtemplate_per_kmoddevelpkg --custom "${kernel}"
 330                         fi
 331                 else
 332                         error_out 2 "Don't know how to handle ${kernel} -- ${prefix}/lib/modules/${kernel}/build/Makefile not found"
 333                 fi
 334         done
 335
 336         # create common development package
 337         if [[ "${devel}" ]]; then
 338                 print_rpmtemplate_kmoddevelpkg "${1}"
 339         fi
 340
 341         # well, it's no header anymore, but who cares ;-)
 342         print_rpmtemplate_header
 343 }
 344
 345
 346 print_rpmtemplate ()
 347 {
 348         # create kernel_versions var
 349         for kernel_version in ${kernel_versions_to_build_for}
 350         do
 351                 kernel_versions="${kernel_versions}${kernel_version}___%{_usrsrc}/kernels/${kernel_version} "
 352         done
 353
 354         # and print it and some other required stuff as macro
 355         print_rpmtemplate_header
 356
 357         # now print the packages itselfs
 358         for kernel in ${kernel_versions_to_build_for} ; do
 359
 360                 local kernel_verrelarch=${kernel%%${kernels_known_variants}}
 361
 362                 # create metapackage
 363                 print_rpmtemplate_kmodmetapkg ${kernel} ${kernel##${kernel_verrelarch}}
 364
 365                 # create package
 366                 print_rpmtemplate_per_kmodpkg ${kernel} ${kernel##${kernel_verrelarch}}
 367
 368                 # create development package
 369                 if [[ "${devel}" ]]; then
 370                         print_rpmtemplate_per_kmoddevelpkg ${kernel} ${kernel##${kernel_verrelarch}}
 371                 fi
 372         done
 373
 374         # create common development package
 375         if [[ "${devel}" ]]; then
 376                 print_rpmtemplate_kmoddevelpkg "${1}"
 377         fi
 378 }
 379
 380 myprog_help ()
 381 {
 382         echo "Usage: $(basename ${0}) [OPTIONS]"
 383         echo $'\n'"Creates a template to be used during kmod building"
 384         echo $'\n'"Available options:"
 385         # FIXME echo " --datadir <dir>     -- look for our shared files in <dir>"
 386         echo " --filterfile <file>  -- filter the results with grep --file <file>"
 387         echo " --for-kernels <list> -- created templates only for these kernels"
 388         echo " --kmodname <file>    -- name of the kmod (required)"
 389         echo " --devel              -- make kmod-devel package"
 390         echo " --noakmod            -- no akmod package"
 391         echo " --repo <name>        -- use buildsys-build-<name>-kerneldevpkgs"
 392         echo " --target <arch>      -- target-arch (required)"
 393 }
 394
 395 while [ "${1}" ] ; do
 396         case "${1}" in
 397                 --filterfile)
 398                         shift
 399                         if [[ ! "${1}" ]] ; then
 400                                 error_out 2 "Please provide path to a filter-file together with --filterfile" >&2
 401                         elif [[ ! -e "${1}" ]]; then
 402                                 error_out 2 "Filterfile ${1} not found" >&2
 403                         fi
 404                         filterfile="${1}"
 405                         shift
 406                         ;;
 407                 --kmodname)
 408                         shift
 409                         if [[ ! "${1}" ]] ; then
 410                                 error_out 2 "Please provide the name of the kmod together with --kmodname" >&2
 411                     fi
 412                         # strip pending -kmod
 413                         kmodname="${1%%-kmod}"
 414                         shift
 415                         ;;
 416                 --devel)
 417                         shift
 418                         devel="true"
 419                         ;;
 420                 --prefix)
 421                         shift
 422                         if [[ ! "${1}" ]] ; then
 423                                 error_out 2 "Please provide a prefix with --prefix" >&2
 424                     fi
 425                         prefix="${1}"
 426                         shift
 427                         ;;
 428                 --repo)
 429                         shift
 430                         if [[ ! "${1}" ]] ; then
 431                                 error_out 2 "Please provide the name of the repo together with --repo" >&2
 432                     fi
 433                         repo=${1}
 434                         shift
 435                         ;;
 436                 --for-kernels)
 437                         shift
 438                         if [[ ! "${1}" ]] ; then
 439                                 error_out 2 "Please provide the name of the kmod together with --kmodname" >&2
 440                         fi
 441                         for_kernels="${1}"
 442                         shift
 443                         ;;
 444                 --noakmod)
 445                         shift
 446                         noakmod="true"
 447                         ;;
 448                 --obsolete-name)
 449                         shift
 450                         if [[ ! "${1}" ]] ; then
 451                                 error_out 2 "Please provide the name of the kmod to obsolte together with --obsolete-name" >&2
 452                         fi
 453                         obsolete_name="${1}"
 454                         shift
 455                         ;;
 456                 --obsolete-version)
 457                         shift
 458                         if [[ ! "${1}" ]] ; then
 459                                 error_out 2 "Please provide the version of the kmod to obsolte together with --obsolete-version" >&2
 460                         fi
 461                         obsolete_version="${1}"
 462                         shift
 463                         ;;
 464                 --target)
 465                         shift
 466                         target="${1}"
 467                         shift
 468                         ;;
 469                 --akmod)
 470                         shift
 471                         build_kernels="akmod"
 472                         ;;
 473                 --newest)
 474                         shift
 475                         build_kernels="newest"
 476                         ;;
 477                 --current)
 478                         shift
 479                         build_kernels="current"
 480                         ;;
 481                 --help)
 482                         myprog_help
 483                         exit 0
 484                         ;;
 485                 --version)
 486                         echo "${myprog} ${myver}"
 487                         exit 0
 488                         ;;
 489                 *)
 490                         echo "Error: Unknown option '${1}'." >&2
 491                         usage >&2
 492                         exit 2
 493                         ;;
 494         esac
 495 done
 496
 497 if [[ -e ./kmodtool-kernel-variants ]]; then
 498         kernels_known_variants="$(cat ./kmodtool-kernel-variants)"
 499 elif [[ -e /usr/share/kmodtool/kernel-variants ]] ; then
 500         kernels_known_variants="$(cat /usr/share/kmodtool/kernel-variants)"
 501 else
 502         kernels_known_variants="@(smp?(-debug)|PAE?(-debug)|debug|kdump|xen|kirkwood|highbank|imx|omap|tegra)"
 503 fi
 504
 505 # general sanity checks
 506 if [[ ! "${target}" ]]; then
 507                 error_out 2 "please pass target arch with --target"
 508 elif [[ ! "${kmodname}" ]]; then
 509                 error_out 2 "please pass kmodname with --kmodname"
 510 elif [[ ! "${kernels_known_variants}" ]] ; then
 511                 error_out 2 "could not determine known variants"
 512 elif ( [[ "${obsolete_name}" ]] && [[ ! "${obsolete_version}" ]] ) ||  ( [[ ! "${obsolete_name}" ]] && [[ "${obsolete_version}" ]] ) ; then
 513                 error_out 2 "you need to provide both --obsolete-name and --obsolete-version"
 514 fi
 515
 516 # go
 517 if [[ "${for_kernels}" ]]; then
 518         # this is easy:
 519         print_customrpmtemplate "${for_kernels}"
 520 elif [[ "${build_kernels}" == "akmod" ]]; then
 521         # do only a akmod package
 522         print_akmodtemplate
 523         print_akmodmeta
 524 else
 525         # seems we are on out own to decide for which kernels to build
 526
 527         # we need more sanity checks in this case
 528         if [[ ! "${repo}" ]]; then
 529                 error_out 2 "please provide repo name with --repo"
 530         elif ! $(which buildsys-build-${repo}-kerneldevpkgs &> /dev/null) ; then
 531                 error_out 2 "buildsys-build-${repo}-kerneldevpkgs not found"
 532         fi
 533
 534         # call buildsys-build-${repo}-kerneldevpkgs to get the list of kernels
 535         cmdoptions="--target ${target}"
 536
 537         # filterfile to filter list of kernels?
 538         if [[ "${filterfile}" ]] ; then
 539                  cmdoptions="${cmdoptions} --filterfile ${filterfile}"
 540         fi
 541
 542         kernel_versions_to_build_for="$(buildsys-build-${repo}-kerneldevpkgs --${build_kernels} ${cmdoptions})"
 543         returncode=$?
 544         if (( ${returncode} != 0 )); then
 545                 error_out 2 "buildsys-build-${repo}-kerneldevpkgs failed: $(buildsys-build-${repo}-kerneldevpkgs --${build_kernels} ${cmdoptions})"
 546         fi
 547
 548         if [[ "${build_kernels}" == "current" ]] && [[ ! "${noakmod}" ]]; then
 549                 print_akmodtemplate
 550         fi
 551
 552         print_rpmtemplate
 553 fi