aboutsummarylogtreecommitdiffstats
path: root/PKGBUILD
blob: 6d73598c956f0c920051f1b600e0f5c624c071e9 (plain)
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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
# Maintainer: micros24 <jasperjano.ph at protonmail dot com>
# Contributor: Joan Figueras <ffigue at gmail dot com>
# Contributor: Torge Matthies <openglfreak at googlemail dot com>
# Contributor: Jan Alexander Steffens (heftig) <jan.steffens@gmail.com>

##
## The following variables can be customized at build time. Use env or export to change at your wish
##
##   Example: env _microarchitecture=98 _use_numa=n _use_tracers=n makepkg -sc
##
## Look inside 'choose-gcc-optimization.sh' to choose your microarchitecture
## Valid numbers between: 0 to 99
## Default is: 0 => generic
## Good option if your package is for one machine: 98 (Intel native) or 99 (AMD native)
if [ -z ${_microarchitecture+x} ]; then
  _microarchitecture=0
fi

## Disable NUMA since most users do not have multiple processors. Breaks CUDA/NvEnc.
## Archlinux and Xanmod enable it by default.
## Set variable "_use_numa" to: n to disable (possibly increase performance)
##                             y to enable  (stock default)
if [ -z ${_use_numa+x} ]; then
  _use_numa=n
fi

## Disable kernel debugging
## Enabling debugging increases kernel overhead by a tiny amount
## No debugging messages will be present when trying to fix kernel stuff
if [ -z ${_disable_debug+x} ]; then
  _disable_debug=y
fi

## Since upstream disabled CONFIG_STACK_TRACER (limits debugging and analyzing of the kernel)
## you can enable them setting this option. Caution, because they have an impact in performance.
## Stock Archlinux has this enabled. 
## Set variable "_use_tracers" to: n to disable (possibly increase performance, XanMod default)
##                                y to enable  (Archlinux default)
if [ -z ${_use_tracers+x} ]; then
  _use_tracers=y
fi

# Unique compiler supported upstream is GCC
## Choose between GCC and CLANG config (default is GCC)
## Use the environment variable "_compiler=clang"
if [ "${_compiler}" = "clang" ]; then
  _compiler_flags="CC=clang HOSTCC=clang LLVM=1 LLVM_IAS=1"
fi

# Choose between the 4 main configs for stable branch. Default x86-64-v1 which use CONFIG_GENERIC_CPU2:
# Possible values: config_x86-64-v1 (default) / config_x86-64-v2 / config_x86-64-v3 / config_x86-64-v4
# This will be overwritten by selecting any option in microarchitecture script
# Source files: https://github.com/xanmod/linux/tree/5.17/CONFIGS/xanmod/gcc
if [ -z ${_config+x} ]; then
  _config=config_x86-64-v1
fi

# Compress modules with ZSTD (to save disk space)
if [ -z ${_compress_modules+x} ]; then
  _compress_modules=n
fi

# Compile ONLY used modules to VASTLY reduce the number of modules built
# and the build time.
#
# To keep track of which modules are needed for your specific system/hardware,
# give module_db script a try: https://aur.archlinux.org/packages/modprobed-db
# This PKGBUILD read the database kept if it exists
#
# More at this wiki page ---> https://wiki.archlinux.org/index.php/Modprobed-db
if [ -z ${_localmodcfg} ]; then
  _localmodcfg=n
fi

# Set the hertz of the tickrate (1000, 500, 300, 100)
if [ -z ${_tickrate_HZ+x} ]; then
  _tickrate_HZ=500
fi

# Set the tickrate handling between (tickless, idle, constant)
if [ -z ${_tickrate+x} ]; then
  _tickrate=tickless
fi

# Set the preemption model (preemptible, voluntary, server)
if [ -z ${_preemptmodel+x} ]; then
  _preemptmodel=preemptible
fi

# Use O3 (y, n)
if [ -z ${_use_O3+x} ]; then
  _use_O3=y
fi

# Tweak kernel options prior to a build via nconfig
if [ -z ${_makenconfig} ]; then
  _makenconfig=n
fi

### IMPORTANT: Do no edit below this line unless you know what you're doing
pkgbase=linux-xanmod-bore
_major=6.7
pkgver=${_major}.6
_branch=6.x
xanmod=1
_revision=
_sf_branch=main
pkgrel=${xanmod}
pkgdesc='Linux Xanmod (Stable) with BORE CPU scheduler and tickrate customizations'
url="http://www.xanmod.org/"
arch=('x86_64')
license=(GPL2)
makedepends=(
  bc
  cpio
  gettext
  libelf
  pahole
  perl
  python
  tar
  xz
)
if [ "${_compiler}" = "clang" ]; then
  makedepends+=(clang llvm lld)
fi
options=('!strip')
_srcname="linux-${pkgver}-xanmod${xanmod}"
source=("https://cdn.kernel.org/pub/linux/kernel/v${_branch}/linux-${_major}.tar."{xz,sign}
        "patch-${pkgver}-xanmod${xanmod}${_revision}.xz::https://sourceforge.net/projects/xanmod/files/releases/${_sf_branch}/${pkgver}-xanmod${xanmod}${_revision}/patch-${pkgver}-xanmod${xanmod}.xz"
        choose-gcc-optimization.sh
        "https://raw.githubusercontent.com/micros24/linux-xanmod-bore/${_major}/0001-bore.patch"
        "https://raw.githubusercontent.com/micros24/linux-xanmod-bore/${_major}/0002-glitched-cfs.patch"
        "https://raw.githubusercontent.com/micros24/linux-xanmod-bore/${_major}/0003-glitched-eevdf-additions.patch"
        "https://raw.githubusercontent.com/micros24/linux-xanmod-bore/${_major}/0004-o3-optimization.patch"
)
validpgpkeys=(
    'ABAF11C65A2970B130ABE3C479BE3E4300411886' # Linux Torvalds
    '647F28654894E3BD457199BE38DBBDC86092693E' # Greg Kroah-Hartman
)

# Archlinux patches
_commit="ec9e9a4219fe221dec93fa16fddbe44a34933d8d"
_patches=()
for _patch in ${_patches[@]}; do
    source+=("${_patch}::https://raw.githubusercontent.com/archlinux/svntogit-packages/${_commit}/trunk/${_patch}")
done
sha256sums=('ef31144a2576d080d8c31698e83ec9f66bf97c677fa2aaf0d5bbb9f3345b1069' # kernel
            'SKIP'                                                             # kernel signature
            'd1b5a00c1babc53d40ea85dbba281fa9f05669b36117e1d937fc849f64336743' # xanmod patch
            '5c84bfe7c1971354cff3f6b3f52bf33e7bbeec22f85d5e7bfde383b54c679d30' # choose-gcc-optimization.sh
            'f8e21f14bdf2f90f37ab03e9b67cee83b999547bbfc9e0c67d1942c4dc3e40fb' # 0001-bore.patch
            '02be008f054a44322a74f0615e8a0d3ad7d6c5bc80182472a9cefbded959ce61' # 0002-glitched-cfs.patch
            '73d4dfd63744a7a510354a66255067ae9aebc4a5c538df32eab852cf7691c835' # 0003-glitched-eevdf-additions.patch
            'f4384ffedc2f3585229a669b127f1759db92125e3d0068be9040df5952f56466' # 0004-o3-optimization.patch
)

export KBUILD_BUILD_HOST=${KBUILD_BUILD_HOST:-archlinux}
export KBUILD_BUILD_USER=${KBUILD_BUILD_USER:-makepkg}
export KBUILD_BUILD_TIMESTAMP=${KBUILD_BUILD_TIMESTAMP:-$(date -Ru${SOURCE_DATE_EPOCH:+d @$SOURCE_DATE_EPOCH})}

prepare() {
  cd linux-${_major}

  # Apply Xanmod patch
  patch -Np1 -i ../patch-${pkgver}-xanmod${xanmod}${_revision}

  echo "Setting version..."
  echo "-$pkgrel" > localversion.10-pkgrel
  echo "${pkgbase#linux-xanmod}" > localversion.20-pkgname

  # Archlinux patches
  local src
  for src in "${source[@]}"; do
    src="${src%%::*}"
    src="${src##*/}"
    [[ $src = *.patch ]] || continue
    echo "Applying patch $src..."
    patch -Np1 < "../$src"
  done

  # Applying configuration
  cp -vf CONFIGS/xanmod/gcc/${_config} .config

  # enable LTO_CLANG_FULL
  echo "Enabling LTO_CLANG_FULL..."
  if [ "${_compiler}" = "clang" ]; then
    scripts/config --disable LTO_CLANG_THIN \
                   --disable LTO_NONE \
                   --enable LTO \
                   --enable LTO_CLANG \
                   --enable ARCH_SUPPORTS_LTO_CLANG \
                   --enable ARCH_SUPPORTS_LTO_CLANG_THIN \
                   --enable HAS_LTO_CLANG \
                   --enable LTO_CLANG_FULL

  fi

  # Disable features not needed for desktop use
  scripts/config --disable X86_EXTENDED_PLATFORM \
                 --disable BLK_DEBUG_FS \
                 --disable MEMORY_HOTPLUG

  # Setting HZ tick rate
  echo "Setting Tickrate HZ..."
  if [ "$_tickrate_HZ" = "1000" ]; then
    scripts/config --disable HZ_250 \
                   --enable HZ_1000
  elif [ "$_tickrate_HZ" = "500" ]; then
    scripts/config --disable HZ_250 \
                   --enable HZ_500
  elif [ "$_tickrate_HZ" = "250" ]; then
    scripts/config --disable HZ_250 \
                   --enable HZ_300
  elif [ "$_tickrate_HZ" = "100" ]; then
    scripts/config --disable HZ_250 \
                   --enable HZ_100
  fi

  # Selecting tick type
  echo "Setting tick type..."
  if [ "$_tickrate" = "tickless" ]; then
    scripts/config --disable HZ_PERIODIC \
                   --disable NO_HZ_IDLE \
                   --disable CONTEXT_TRACKING_FORCE \
                   --enable NO_HZ_FULL_NODEF \
                   --enable NO_HZ_FULL \
                   --enable NO_HZ \
                   --enable NO_HZ_COMMON \
                   --enable CONTEXT_TRACKING
  elif [ "$_tickrate" = "idle" ]; then
    scripts/config --disable HZ_PERIODIC \
                   --disable NO_HZ_FULL \
                   --enable NO_HZ_IDLE \
                   --enable NO_HZ \
                   --enable NO_HZ_COMMON
  elif [ "$_tickrate" = "constant" ]; then
    scripts/config --disable NO_HZ_IDLE \
                   --disable NO_HZ_FULL \
                   --disable NO_HZ \
                   --disable NO_HZ_COMMON \
                   --enable HZ_PERIODIC
  fi

  # Selecting Preemption model
  echo "Setting preemption model..."
  if [ "$_preemptmodel" = "preemptible" ]; then
    scripts/config --disable PREEMPT_NONE \
                   --disable PREEMPT_VOLUNTARY \
                   --enable PREEMPT_BUILD \
                   --enable PREEMPT \
                   --enable PREEMPT_COUNT \
                   --enable PREEMPTION \
                   --enable PREEMPT_DYNAMIC
  elif [ "$_preemptmodel" = "voluntary" ]; then
    scripts/config --disable PREEMPT_NONE \
                   --disable PREEMPT \
                   --disable PREEMPT_DYNAMIC \
                   --enable PREEMPT_BUILD \
                   --enable PREEMPT_VOLUNTARY \
                   --enable PREEMPT_COUNT \
                   --enable PREEMPTION
  elif [ "$_preemptmodel" = "server" ]; then
    scripts/config --disable PREEMPT_VOLUNTARY \
                   --disable PREEMPT \
                   --disable PREEMPTION \
                   --disable PREEMPT_DYNAMIC \
                   --enable PREEMPT_NONE_BUILD \
                   --enable PREEMPT_NONE
  fi

  # Setting O3
  if [ "$_use_O3" = "y" ]; then
    echo "Enabling O3..."
    scripts/config --disable CC_OPTIMIZE_FOR_PERFORMANCE \
                   --enable CC_OPTIMIZE_FOR_PERFORMANCE_O3
  fi

  # CONFIG_STACK_VALIDATION gives better stack traces. Also is enabled in all official kernel packages by Archlinux team
  scripts/config --enable STACK_VALIDATION

  # Enable IKCONFIG following Arch's philosophy
  scripts/config --enable IKCONFIG \
                 --enable IKCONFIG_PROC

  # Requested by Alexandre Frade to fix issues in python-gbinder
  scripts/config --enable ANDROID_BINDERFS
  scripts/config --enable ANDROID_BINDER_IPC

  # User set. See at the top of this file
  if [ "$_use_tracers" = "y" ]; then
    echo "Enabling CONFIG_FTRACE..."
    scripts/config --enable FTRACE \
                   --enable FUNCTION_TRACER \
                   --enable STACK_TRACER
  fi

  # Disabling NUMA
  if [ "$_use_numa" = "n" ]; then
    echo "Disabling NUMA..."
    scripts/config --disable NUMA \
                   --disable AMD_NUMA \
                   --disable X86_64_ACPI_NUMA \
                   --disable NODES_SPAN_OTHER_NODES \
                   --disable NUMA_EMU \
                   --disable USE_PERCPU_NUMA_NODE_ID \
                   --disable ACPI_NUMA \
                   --disable ARCH_SUPPORTS_NUMA_BALANCING \
                   --disable NODES_SHIFT \
                   --undefine NODES_SHIFT \
                   --disable NEED_MULTIPLE_NODES \
                   --disable NUMA_BALANCING \
                   --disable NUMA_BALANCING_DEFAULT_ENABLED
  fi

  # Disabling Debug
  if [ "$_disable_debug" = "y" ]; then
    echo "Disabling debugging..."
    scripts/config --disable DEBUG_INFO_BTF \
                   --disable DEBUG_INFO_DWARF4 \
                   --disable DEBUG_INFO_DWARF5 \
                   --disable PAHOLE_HAS_SPLIT_BTF \
                   --disable DEBUG_INFO_BTF_MODULES \
                   --disable SLUB_DEBUG \
                   --disable PM_DEBUG \
                   --disable PM_ADVANCED_DEBUG \
                   --disable PM_SLEEP_DEBUG \
                   --disable ACPI_DEBUG \
                   --disable SCHED_DEBUG \
                   --disable LATENCYTOP \
                   --disable DEBUG_PREEMPT
  fi

  # Compress modules by default (following Arch's kernel)
  if [ "$_compress_modules" = "y" ]; then
    scripts/config --enable MODULE_COMPRESS_ZSTD
  fi

  # Let's user choose microarchitecture optimization in GCC
  # Use default microarchitecture only if we have not choosen another microarchitecture
  if [ "$_microarchitecture" -ne "0" ]; then
    ../choose-gcc-optimization.sh $_microarchitecture
  fi

  # This is intended for the people that want to build this package with their own config
  # Put the file "myconfig" at the package folder (this will take preference) or "${XDG_CONFIG_HOME}/linux-xanmod/myconfig"
  # If we detect partial file with scripts/config commands, we execute as a script
  # If not, it's a full config, will be replaced
  for _myconfig in "${SRCDEST}/myconfig" "${HOME}/.config/linux-xanmod/myconfig" "${XDG_CONFIG_HOME}/linux-xanmod/myconfig" ; do
    if [ -f "${_myconfig}" ] && [ "$(wc -l <"${_myconfig}")" -gt "0" ]; then
      if grep -q 'scripts/config' "${_myconfig}"; then
        # myconfig is a partial file. Executing as a script
        echo "Applying myconfig..."
        bash -x "${_myconfig}"
      else
        # myconfig is a full config file. Replacing default .config
        echo "Using user CUSTOM config..."
        cp -f "${_myconfig}" .config
      fi
      echo
      break
    fi
  done

  ### Optionally load needed modules for the make localmodconfig
  # See https://aur.archlinux.org/packages/modprobed-db
  if [ "$_localmodcfg" = "y" ]; then
    if [ -f $HOME/.config/modprobed.db ]; then
      echo "Running Steven Rostedt's make localmodconfig now"
      make ${_compiler_flags} LSMOD=$HOME/.config/modprobed.db localmodconfig
    else
      echo "No modprobed.db data found"
      exit 1
    fi
  fi

  make ${_compiler_flags} olddefconfig

  make -s kernelrelease > version
  echo "Prepared %s version %s" "$pkgbase" "$(<version)"

  if [ "$_makenconfig" = "y" ]; then
    make ${_compiler_flags} nconfig
  fi

  # save configuration for later reuse
  cat .config > "${SRCDEST}/config.last"
}

build() {
  cd linux-${_major}
  make ${_compiler_flags} -j$(nproc) all
}

_package() {
  pkgdesc="Linux Xanmod (Stable) with BORE CPU scheduler and tickrate customizations"
  depends=(
    coreutils
    initramfs
    kmod
  )
  optdepends=(
    'wireless-regdb: to set the correct wireless channels of your country'
    'linux-firmware: firmware images needed for some devices'
  )
  provides=(
    KSMBD-MODULE
    VIRTUALBOX-GUEST-MODULES
    WIREGUARD-MODULE
    NTFS3-MODULE
  )
  replaces=(
    virtualbox-guest-modules-arch
    wireguard-arch
  )

  cd linux-${_major}
  local modulesdir="$pkgdir/usr/lib/modules/$(<version)"

  echo "Installing boot image..."
  # systemd expects to find the kernel here to allow hibernation
  # https://github.com/systemd/systemd/commit/edda44605f06a41fb86b7ab8128dcf99161d2344
  install -Dm644 "$(make -s image_name)" "$modulesdir/vmlinuz"

  # Used by mkinitcpio to name the kernel
  echo "$pkgbase" | install -Dm644 /dev/stdin "$modulesdir/pkgbase"

  echo "Installing modules..."
  ZSTD_CLEVEL=19 make INSTALL_MOD_PATH="$pkgdir/usr" INSTALL_MOD_STRIP=1 \
    DEPMOD=/doesnt/exist modules_install  # Suppress depmod

  # remove build link
  rm "$modulesdir"/build
}

_package-headers() {
  pkgdesc="Headers and scripts for building modules for the $pkgdesc kernel"
  depends=(pahole)

  cd linux-${_major}
  local builddir="$pkgdir/usr/lib/modules/$(<version)/build"

  echo "Installing build files..."
  install -Dt "$builddir" -m644 .config Makefile Module.symvers System.map \
    localversion.* version vmlinux
  install -Dt "$builddir/kernel" -m644 kernel/Makefile
  install -Dt "$builddir/arch/x86" -m644 arch/x86/Makefile
  cp -t "$builddir" -a scripts

  # required when STACK_VALIDATION is enabled
  install -Dt "$builddir/tools/objtool" tools/objtool/objtool

  # required when DEBUG_INFO_BTF_MODULES is enabled
  if [ -f "tools/bpf/resolve_btfids/resolve_btfids" ]; then install -Dt "$builddir/tools/bpf/resolve_btfids" tools/bpf/resolve_btfids/resolve_btfids ; fi

  echo "Installing headers..."
  cp -t "$builddir" -a include
  cp -t "$builddir/arch/x86" -a arch/x86/include
  install -Dt "$builddir/arch/x86/kernel" -m644 arch/x86/kernel/asm-offsets.s

  install -Dt "$builddir/drivers/md" -m644 drivers/md/*.h
  install -Dt "$builddir/net/mac80211" -m644 net/mac80211/*.h

  # https://bugs.archlinux.org/task/13146
  install -Dt "$builddir/drivers/media/i2c" -m644 drivers/media/i2c/msp3400-driver.h

  # https://bugs.archlinux.org/task/20402
  install -Dt "$builddir/drivers/media/usb/dvb-usb" -m644 drivers/media/usb/dvb-usb/*.h
  install -Dt "$builddir/drivers/media/dvb-frontends" -m644 drivers/media/dvb-frontends/*.h
  install -Dt "$builddir/drivers/media/tuners" -m644 drivers/media/tuners/*.h

  # https://bugs.archlinux.org/task/71392
  install -Dt "$builddir/drivers/iio/common/hid-sensors" -m644 drivers/iio/common/hid-sensors/*.h

  echo "Installing KConfig files..."
  find . -name 'Kconfig*' -exec install -Dm644 {} "$builddir/{}" \;

  echo "Removing unneeded architectures..."
  local arch
  for arch in "$builddir"/arch/*/; do
    [[ $arch = */x86/ ]] && continue
    echo "Removing $(basename "$arch")"
    rm -r "$arch"
  done

  echo "Removing documentation..."
  rm -r "$builddir/Documentation"

  echo "Removing broken symlinks..."
  find -L "$builddir" -type l -printf 'Removing %P\n' -delete

  echo "Removing loose objects..."
  find "$builddir" -type f -name '*.o' -printf 'Removing %P\n' -delete

  echo "Stripping build tools..."
  local file
  while read -rd '' file; do
    case "$(file -Sib "$file")" in
      application/x-sharedlib\;*)      # Libraries (.so)
        strip -v $STRIP_SHARED "$file" ;;
      application/x-archive\;*)        # Libraries (.a)
        strip -v $STRIP_STATIC "$file" ;;
      application/x-executable\;*)     # Binaries
        strip -v $STRIP_BINARIES "$file" ;;
      application/x-pie-executable\;*) # Relocatable binaries
        strip -v $STRIP_SHARED "$file" ;;
    esac
  done < <(find "$builddir" -type f -perm -u+x ! -name vmlinux -print0)

  echo "Stripping vmlinux..."
  strip -v $STRIP_STATIC "$builddir/vmlinux"

  echo "Adding symlink..."
  mkdir -p "$pkgdir/usr/src"
  ln -sr "$builddir" "$pkgdir/usr/src/$pkgbase"
}

pkgname=("${pkgbase}" "${pkgbase}-headers")
for _p in "${pkgname[@]}"; do
  eval "package_$_p() {
    $(declare -f "_package${_p#$pkgbase}")
    _package${_p#$pkgbase}
  }"
done

# vim:set ts=8 sts=2 sw=2 et: