A fully Go userland with Linux bootloaders! u-root can create a one-binary root file system (initramfs) containing a busybox-like set of tools written in Go.

Overview

u-root

Build Status codecov Go Report Card GoDoc Slack License

Description

u-root embodies four different projects.

  • Go versions of many standard Linux tools, such as ls, cp, or shutdown. See cmds/core for most of these.

  • A way to compile many Go programs into a single binary with busybox mode.

  • A way to create initramfs (an archive of files) to use with Linux kernels.

  • Go bootloaders that use kexec to boot Linux or multiboot kernels such as ESXi, Xen, or tboot. They are meant to be used with LinuxBoot. With that, parsers for GRUB config files or syslinux config files are to make transition to LinuxBoot easier.

⚠️ Go Modules are Broken ⚠️

u-root itself builds fine with modules. When adding commands to your busybox which are outside u-root, make sure to export GO111MODULE=off both when geting the command (so that the command is found under $GOPATH/src and when running the u-root command (so that you can run the u-root command from any directory).

For example:

GO111MODULE=off go get github.com/nsf/godit
GO111MODULE=off u-root all github.com/nsf/godit

Usage

Make sure your Go version is >=1.15. Make sure your GOPATH is set up correctly.

Download and install u-root:

go get github.com/u-root/u-root

You can now use the u-root command to build an initramfs. Here are some examples:

# Build an initramfs of all the Go cmds in ./cmds/core/... (default)
u-root

# Generate an archive with bootloaders
#
# core and boot are templates that expand to sets of commands
u-root core boot

# Generate an archive with only these given commands
u-root cmds/core/{init,ls,ip,dhclient,wget,cat,elvish}

# Generate an archive with all of the core tools with some exceptions
u-root core -cmds/core/{ls,losetup}

# Generate an archive with a tool outside of u-root
u-root cmds/core/{init,ls,elvish} github.com/u-root/cpu/cmds/cpud

The default set of packages included is all packages in github.com/u-root/u-root/cmds/core/....

In addition to using paths to specify Go source packages to include, you may also use Go package import paths (e.g. golang.org/x/tools/imports) to include commands. Only the main package and its dependencies in those source directories will be included. For example:

You can build the initramfs built by u-root into the kernel via the CONFIG_INITRAMFS_SOURCE config variable or you can load it separately via an option in for example Grub or the QEMU command line or coreboot config variable.

Extra Files

You may also include additional files in the initramfs using the -files flag. If you add binaries with -files are listed, their ldd dependencies will be included as well. As example for Debian, you want to add two kernel modules for testing, executing your currently booted kernel:

NOTE: these files will be placed in the $HOME dir in the initramfs.

u-root -files "$HOME/hello.ko $HOME/hello2.ko"
qemu-system-x86_64 -kernel /boot/vmlinuz-$(uname -r) -initrd /tmp/initramfs.linux_amd64.cpio

To specify the location in the initramfs, use : . For example:

u-root -files "root-fs/usr/bin/runc:usr/bin/run"

Init and Uinit

u-root has a very simple (exchangable) init system controlled by the -initcmd and -uinitcmd command-line flags.

  • -initcmd determines what /init is symlinked to. -initcmd may be a u-root command name or a symlink target.
  • -uinitcmd is run by the default u-root init after some basic file system setup. There is no default, users should optionally supply their own. -uinitcmd may be a u-root command name with arguments or a symlink target with arguments.
  • After running a uinit (if there is one), init will start a shell determined by the -defaultsh argument.

We expect most users to keep their -initcmd as init, but to supply their own uinit for additional initialization or to immediately load another operating system.

All three command-line args accept both a u-root command name or a target symlink path. Only -uinitcmd accepts command-line arguments, however. For example,

../bbin/echo # lrwxrwxrwx 0 root root 9 Dec 31 1969 init -> bbin/init qemu-system-x86_64 -kernel $KERNEL -initrd /tmp/initramfs.linux_amd64.cpio -nographic -append "console=ttyS0" # ... # [ 0.848021] Freeing unused kernel memory: 896K # 2020/05/01 04:04:39 Welcome to u-root! # _ # _ _ _ __ ___ ___ | |_ # | | | |____| '__/ _ \ / _ \| __| # | |_| |____| | | (_) | (_) | |_ # \__,_| |_| \___/ \___/ \__| # # Go Gopher # ~/> ">
u-root -uinitcmd="echo Go Gopher" ./cmds/core/{init,echo,elvish}

cpio -ivt < /tmp/initramfs.linux_amd64.cpio
# ...
# lrwxrwxrwx   0 root     root           12 Dec 31  1969 bin/uinit -> ../bbin/echo
# lrwxrwxrwx   0 root     root            9 Dec 31  1969 init -> bbin/init

qemu-system-x86_64 -kernel $KERNEL -initrd /tmp/initramfs.linux_amd64.cpio -nographic -append "console=ttyS0"
# ...
# [    0.848021] Freeing unused kernel memory: 896K
# 2020/05/01 04:04:39 Welcome to u-root!
#                              _
#   _   _      _ __ ___   ___ | |_
#  | | | |____| '__/ _ \ / _ \| __|
#  | |_| |____| | | (_) | (_) | |_
#   \__,_|    |_|  \___/ \___/ \__|
#
# Go Gopher
# ~/>

Passing command line arguments like above is equivalent to passing the arguments to uinit via a flags file in /etc/uinit.flags, see Extra Files.

Additionally, you can pass arguments to uinit via the uroot.uinitargs kernel parameters, for example:

../bbin/echo # lrwxrwxrwx 0 root root 9 Dec 31 1969 init -> bbin/init qemu-system-x86_64 -kernel $KERNEL -initrd /tmp/initramfs.linux_amd64.cpio -nographic -append "console=ttyS0 uroot.uinitargs=Go" # ... # [ 0.848021] Freeing unused kernel memory: 896K # 2020/05/01 04:04:39 Welcome to u-root! # _ # _ _ _ __ ___ ___ | |_ # | | | |____| '__/ _ \ / _ \| __| # | |_| |____| | | (_) | (_) | |_ # \__,_| |_| \___/ \___/ \__| # # Go Gopher # ~/> ">
u-root -uinitcmd="echo Gopher" ./cmds/core/{init,echo,elvish}

cpio -ivt < /tmp/initramfs.linux_amd64.cpio
# ...
# lrwxrwxrwx   0 root     root           12 Dec 31  1969 bin/uinit -> ../bbin/echo
# lrwxrwxrwx   0 root     root            9 Dec 31  1969 init -> bbin/init

qemu-system-x86_64 -kernel $KERNEL -initrd /tmp/initramfs.linux_amd64.cpio -nographic -append "console=ttyS0 uroot.uinitargs=Go"
# ...
# [    0.848021] Freeing unused kernel memory: 896K
# 2020/05/01 04:04:39 Welcome to u-root!
#                              _
#   _   _      _ __ ___   ___ | |_
#  | | | |____| '__/ _ \ / _ \| __|
#  | |_| |____| | | (_) | (_) | |_
#   \__,_|    |_|  \___/ \___/ \__|
#
# Go Gopher
# ~/>

Note the order of the passed arguments in the above example.

The command you name must be present in the command set. The following will not work:

u-root -uinitcmd="echo Go Gopher" ./cmds/core/{init,elvish}
# 2020/04/30 21:05:57 could not create symlink from "bin/uinit" to "echo": command or path "echo" not included in u-root build: specify -uinitcmd="" to ignore this error and build without a uinit

You can also refer to non-u-root-commands; they will be added as symlinks. We don't presume to know whether your symlink target is correct or not.

This will build, but not work unless you add a /bin/foobar to the initramfs.

u-root -uinitcmd="/bin/foobar Go Gopher" ./cmds/core/{init,elvish}

This will boot the same as the above.

u-root -uinitcmd="/bin/foobar Go Gopher" -files /bin/echo:bin/foobar ./cmds/core/{init,elvish}

This will bypass the regular u-root init and just launch a shell:

">
u-root -initcmd=elvish ./cmds/core/{elvish,ls}

cpio -ivt < /tmp/initramfs.linux_amd64.cpio
# ...
# lrwxrwxrwx   0 root     root            9 Dec 31  1969 init -> bbin/elvish

qemu-system-x86_64 -kernel $KERNEL -initrd /tmp/initramfs.linux_amd64.cpio -nographic -append "console=ttyS0"
# ...
# [    0.848021] Freeing unused kernel memory: 896K
# failed to put myself in foreground: ioctl: inappropriate ioctl for device
# ~/>

(It fails to do that because some initialization is missing when the shell is started without a proper init.)

Cross Compilation (targeting different architectures and OSes)

Cross-OS and -architecture compilation comes for free with Go. In fact, every PR to the u-root repo is built against the following architectures: amd64, x86 (i.e. 32bit), mipsle, armv7, arm64, and ppc64le.

Further, we run integration tests on linux/amd64, freebsd/amd64 and linux/arm64, using several CI systems. If you need to add another CI system, processor or OS, please let us know.

To cross compile for an ARM, on Linux:

GOARCH=arm u-root

If you are on OSX, and wish to build for Linux on AMD64:

GOOS=linux GOARCH=amd64 u-root

Testing in QEMU

A good way to test the initramfs generated by u-root is with qemu:

qemu-system-x86_64 -nographic -kernel path/to/kernel -initrd /tmp/initramfs.linux_amd64.cpio

Note that you do not have to build a special kernel on your own, it is sufficient to use an existing one. Usually you can find one in /boot.

If you quickly need to obtain a kernel, for example, when you are on a non-Linux system, you can assemble a URL to download one through Arch Linux's iPXE menu file. It would download from ${mirrorurl}iso/${release}/arch/boot/x86_64/vmlinuz, so just search for a mirror URL you prefer and a release version, for example, http://mirror.rackspace.com/archlinux/iso/2019.10.01/arch/boot/x86_64/vmlinuz.

Framebuffer

For framebuffer support, append a VESA mode via the vga kernel parameter:

qemu-system-x86_64 \
  -kernel path/to/kernel \
  -initrd /tmp/initramfs.linux_amd64.cpio \
  -append "vga=786"

For a list of modes, refer to the Linux kernel documentation.

Entropy / Random Number Generator

Some utilities, e.g., dhclient, require entropy to be present. For a speedy virtualized random number generator, the kernel should have the following:

CONFIG_VIRTIO_PCI=y
CONFIG_HW_RANDOM_VIRTIO=y
CONFIG_CRYPTO_DEV_VIRTIO=y

Then you can run your kernel in QEMU with a virtio-rng-pci device:

qemu-system-x86_64 \
    -device virtio-rng-pci \
    -kernel vmlinuz \
    -initrd /tmp/initramfs.linux_amd64.cpio

In addition, you can pass your host's RNG:

qemu-system-x86_64 \
    -object rng-random,filename=/dev/urandom,id=rng0 \
    -device virtio-rng-pci,rng=rng0 \
    -kernel vmlinuz \
    -initrd /tmp/initramfs.linux_amd64.cpio

SystemBoot

SystemBoot is a set of bootloaders written in Go. It is meant to be a distribution for LinuxBoot to create a system firmware + bootloader. All of these use kexec to boot. The commands are in cmds/boot.

  • pxeboot: a network boot client that uses DHCP and HTTP or TFTP to get a boot configuration which can be parsed as PXELinux or iPXE configuration files to get a boot program.

  • boot: finds all bootable kernels on local disk, shows a menu, and boots them. Supports (basic) GRUB, (basic) syslinux, (non-EFI) BootLoaderSpec, and ESXi configurations.

  • fbnetboot: a network boot client that uses DHCP and HTTP to get a boot program based on Linux, and boots it. To be merged with pxeboot.

  • localboot: a tool that finds bootable kernel configurations on the local disks and boots them.

  • systemboot: a wrapper around fbnetboot and localboot that just mimicks a BIOS/UEFI BDS behaviour, by looping between network booting and local booting. Use -uinitcmd argument to the u-root build tool to make it the boot program.

This project started as a loose collection of programs in u-root by various LinuxBoot contributors, as well as a personal experiment by Andrea Barberio that has since been merged in. It is now an effort of a broader community and graduated to a real project for system firmwares.

More detailed information about the build process for a full LinuxBoot firmware image using u-root/systemboot and coreboot can be found in the LinuxBoot book chapter about LinuxBoot using coreboot, u-root and systemboot.

You can build systemboot like this:

u-root -build=bb -uinitcmd=systemboot core github.com/u-root/u-root/cmds/boot/{systemboot,localboot,fbnetboot}

Compression

You can compress the initramfs. However, for xz compression, the kernel has some restrictions on the compression options and it is suggested to align the file to 512 byte boundaries:

xz --check=crc32 -9 --lzma2=dict=1MiB \
   --stdout /tmp/initramfs.linux_amd64.cpio \
   | dd conv=sync bs=512 \
   of=/tmp/initramfs.linux_amd64.cpio.xz

Getting Packages of TinyCore

Using the tcz command included in u-root, you can install tinycore linux packages for things you want.

You can use QEMU NAT to allow you to fetch packages. Let's suppose, for example, you want bash. Once u-root is running, you can do this:

% tcz bash

The tcz command computes and fetches all dependencies. If you can't get to tinycorelinux.net, or you want package fetching to be faster, you can run your own server for tinycore packages.

You can do this to get a local server using the u-root srvfiles command:

% srvfiles -p 80 -d path-to-local-tinycore-packages

Of course you have to fetch all those packages first somehow :-)

Build an Embeddable U-root

You can build this environment into a kernel as an initramfs, and further embed that into firmware as a coreboot payload.

In the kernel and coreboot case, you need to configure ethernet. We have a dhclient command that works for both ipv4 and ipv6. Since v6 does not yet work that well for most people, a typical invocation looks like this:

% dhclient -ipv4 -ipv6=false

Or, on newer linux kernels (> 4.x) boot with ip=dhcp in the command line, assuming your kernel is configured to work that way.

Build Modes

u-root can create an initramfs in two different modes, specified by -build:

  • bb mode: One busybox-like binary comprising all the Go tools you ask to include. See here for how it works.

    In this mode, u-root copies and rewrites the source of the tools you asked to include to be able to compile everything into one busybox-like binary.

  • binary mode: each specified binary is compiled separately and all binaries are added to the initramfs.

Updating Dependencies

go get -u
go mod tidy
go mod vendor

Hardware

If you want to see u-root on real hardware, this board is a good start.

Contributions

For information about contributing, including how we sign off commits, please see CONTRIBUTING.md.

Improving existing commands (e.g., additional currently unsupported flags) is very welcome. In this case it is not even required to build an initramfs, just enter the cmds/ directory and start coding. A list of commands that are on the roadmap can be found here.

Issues
  • Update circleci docker image

    Update circleci docker image

    The big change is the switch to Go 1.15 and QEMU 6.0.0.

    Signed-off-by: Ryan O'Leary [email protected]

    automerge Awaiting author 
    opened by rjoleary 28
  • Enable dead code elimination to reduce binary size

    Enable dead code elimination to reduce binary size

    Go's dead code elimination algorithm is described and implemented here. TLDR is: elimination of unused public methods at link time will be inhibited if reflection function calling are used anywhere.

    quick and dirty experiment shows that if DCE remains enabled, the uncompressed CPIO image size of just core goes down by ~2.3M: 15165376 -> 12707776, a 16% reduction. with all exp commands, it's about the same: 19130524 - 16562332, about 14%

    current uses of reflection in u-root are:

    1. elvish, to invoke built-in functions (here).
    2. dmidecode, to parse structs (addressed by #1476)
    3. text/template - uses reflection in struct attribute access, used in go/doc package, which is imported by go/build package.

    (3) is the toughest to address, it's all in go core libraries. but the payoff is significant, might be worth exploring.

    opened by rojer 25
  • block: fix FilterGUID

    block: fix FilterGUID

    Hey @insomniacslk @tfg13 @pmazzini do y'all use this logic? Because it is broken as far as I can tell. Take a look at this small change emphasizing what this actually does.

    Since the only usage of this doesn't do what the code seems to think it does -- can I get rid of this function and fix it so it returns the partition?

    automerge 
    opened by hugelgupf 23
  • WIP: boot: refactor into package and support multiboot

    WIP: boot: refactor into package and support multiboot

    The current commits make no changes to the existing boot cmd yet, just setting up the framework for parsing and testing.

    opened by flammit 19
  • Source mode possibly broken

    Source mode possibly broken

    I'm playing around with u-root as a replacement for Dracut in rapido (https://github.com/rapido-linux/rapido)

    I currently encounter the following error on boot:

    /usr/bin/qemu-kvm -smp cpus=2 -m 512 -kernel <bzImage> -initrd ./initrds/myinitrd -append 'ip=192.168.1.1:::255.255.255.0:rapido1 rd.systemd.unit=emergency rd.shell=1 console=ttyS0 rd.lvm=0 rd.luks=0' -pidfile ./initrds/rapido_vm1.pid -device e1000,netdev=nw1,mac=<mac> -netdev tap,id=nw1,script=no,downscript=no,ifname=tap0 -nographic
    ...
    package github.com/u-root/u-root/cmds/installcommand
            imports runtime: open /go/src/runtime/asm_ppc64x.h: no such file or directory
    2018/07/27 16:25:30 exit status 1
    2018/07/27 16:25:30 init: No suitable executable found in [/inito /bbin/uinit /buildbin/uinit /bbin/sh /bbin/rush /buildbin/sh /buildbin/rush]
    2018/07/27 16:25:30 init: Waiting for orphaned children
    2018/07/27 16:25:30 init: All commands exited
    2018/07/27 16:25:30 init: Syncing filesystems
    2018/07/27 16:25:30 init: Exiting...
    

    The image was generated by current master (569a17126131f2f320dd70ec9151a262e9e25846) on openSUSE Leap 42.3 with go 1.9.7 via:

    u-root (master)> ./u-root -format=cpio -build=source -o myinitrd ./cmds/{ls,ip,dhclient,cat,init,rush,installcommand}
    2018/07/27 18:24:26 Disabling CGO for u-root...
    2018/07/27 18:24:26 Build environment: GOARCH=amd64 GOOS=linux GOROOT=/usr/lib64/go/1.9 GOPATH=/home/ddiss/go:/usr/share/go/1.9/contrib CGO_ENABLED=0
    2018/07/27 18:24:26 Filename is initramfs.cpio
    2018/07/27 18:24:26 Collecting package files and dependencies...
    2018/07/27 18:24:28 Building go toolchain...
    2018/07/27 18:24:58 Successfully wrote initramfs.
    

    I'm not very familiar with Go, so would appreciate if someone could point me in the right direction here.

    Bug 
    opened by ddiss 18
  • DHCPv6 for dhclient from mdlayher/dhcp6.

    DHCPv6 for dhclient from mdlayher/dhcp6.

    It's not general enough to really be accepted into mdlayher/dhcp6. Let's just have it here for now.

    netboot 
    opened by hugelgupf 18
  • flag combos (rm -rf) do not work with Go flags package

    flag combos (rm -rf) do not work with Go flags package

    You have to split up flags ex: ls -l -R, not ls -lR

    Feature Request Help Wanted 
    opened by Ananya-Joshi 18
  • Added pkg/mei

    Added pkg/mei

    Package mei adds a wrapper to MEI, the Intel ME Interface. See https://www.kernel.org/doc/Documentation/misc-devices/mei/mei.txt . This is a partial implementation that exposes an MEI client and an MKHI client on top of it.

    Signed-off-by: Andrea Barberio [email protected]

    opened by insomniacslk 17
  • No network interface / kernel modules

    No network interface / kernel modules

    I booted up u-root bb build with qemu, but there is no network interface (only unconfigured "lo") and no network drivers.

    Is there some more documentation how to get a working network interface up with dhcp? Maybe additional modules are needed ("/lib/" is empty)?

    opened by pwFoo 16
  • refactor: move from io/ioutil to io and os packages

    refactor: move from io/ioutil to io and os packages

    This PR introduces three small changes:

    1. Formats the code by running gofumpt -w . and go mod tidy.

    2. The io/ioutil package has been deprecated in Go 1.16 (See https://golang.org/doc/go1.16#ioutil). This PR replaces the existing io/ioutil functions with their new definitions in io and os packages.

    3. uses testing#T.TempDir (https://pkg.go.dev/testing#T.TempDir) to create temporary directory in tests instead of ioutil.TempDir.

    opened by Juneezee 1
  • Cover/pkg/memio

    Cover/pkg/memio

    null

    coverage 
    opened by depate 1
  • Add coverage reporting from VM tests

    Add coverage reporting from VM tests

    This pull request is a rebase of https://github.com/u-root/u-root/pull/1958 and reopened here because of CI reasons

    coverage 
    opened by MDr164 1
  • Migrate to main branch

    Migrate to main branch

    We have built up enough consensus on the slack channel.

    Instructions: https://github.com/github/renaming

    Feature Request 
    opened by rjoleary 0
  • Remove usage of testify package

    Remove usage of testify package

    The testify package is only used in 6 places. We do not need this dependency.

    Feature Request 
    opened by rjoleary 0
  • Fix zipslips for cpio and tar

    Fix zipslips for cpio and tar

    A zipslip is when a archive contains a path which escapes the extract directory. This can be done with absolute paths / or with parent directories ... It is a security problem.

    For this change, we also need a tar -C implementation to make it easy to convert from absolute to relative addresses. Some of the u-root tests which make use of tar files now need to use relative addresses.

    Signed-off-by: Ryan O'Leary [email protected]

    opened by rjoleary 1
  • Coverage pkg/rtc

    Coverage pkg/rtc

    Reopen because of CI issues on https://github.com/u-root/u-root/pull/2163

    coverage 
    opened by MDr164 1
  • cover/cmds/core/cat

    cover/cmds/core/cat

    Restructure main Add test for empty arguments Add test for file not exist Add test for io copy fail

    Signed-off-by: Christopher Meis [email protected]

    Awaiting reviewer coverage 
    opened by ChriMarMe 2
  • pkg/ipmi: Restructure, rework and test coverage

    pkg/ipmi: Restructure, rework and test coverage

    null

    Awaiting reviewer coverage 
    opened by ChriMarMe 5
  • Fix TestDeadProcess in pkg/lockfile/lockfile_test.go

    Fix TestDeadProcess in pkg/lockfile/lockfile_test.go

    86757f376561db47a5d242b9dc70b5a88147af86 turns TestDeadProcess off, as it failed in circleci for no clear reason. Needs to get turned back on.

    Bug Help Wanted Good First Issue 
    opened by rminnich 1
Owner
Golang systems software
null
Automatically set GOMAXPROCS to match Linux container CPU quota.

automaxprocs Automatically set GOMAXPROCS to match Linux container CPU quota. Installation go get -u go.uber.org/automaxprocs Quick Start import _ "go

Uber Go 1.7k Dec 2, 2021
Like tools/cmd/stringer with bitmask features

Bitmasker Bitmasker is a tool used to automate the creation of helper methods when dealing with bitmask-type constant flags. Given the name of an unsi

Go Curses 0 Nov 24, 2021
Elf binary infector written in Golang

Elf binary infector written in Golang. It can be used for infecting executables of type ET_DYN and ET_EXEC with a payload of your creation. Utilizing the classic elf text segment padding algorithm by Silvio Cesar, your payload (parasite) will run before native functionality of the binary effectively backooring the binary.

null 124 Dec 1, 2021
Julia Set Generator Written In Golang

Julia Set Generator Written In Golang This is a simple (naive) Julia Set generator written in Golang. The project utilizes concurrent workers to speed

null 1 Nov 5, 2021
dqlx is a fully featured DGraph Schema and Query Builder for Go.

dqlx is a fully featured DGraph Schema and Query Builder for Go. It aims to simplify the interaction with the awesome Dgraph database allowing you to fluently compose any queries and mutations of any complexity. It also comes with a rich Schema builder to easily develop and maintain your Dgraph schema.

Fabrizio 29 Nov 25, 2021
Fully featured, spec-compliant HTML5 server-sent events library

go-sse Lightweight, fully spec-compliant HTML5 server-sent events library. Table of contents go-sse Table of contents Installation and usage Implement

Teodor Maxim 155 Nov 17, 2021
A utility library to do files/io/bytes processing/parsing in file-system or network.

goreader A utility library to do files/io/bytes processing/parsing in file-system or network. These features are really common to be implemented for a

VOrishirne 4 Nov 1, 2021
get windows system call number dynamically, it doesn't need the system call table.

GetSyscallID get windows system call number dynamically, it doesn't need the system call table. Try download go get github.com/akkuman/getsyscallid/cm

null 5 Oct 28, 2021
Cogger is a standalone binary and a golang library that reads an internally tiled geotiff

Cogger is a standalone binary and a golang library that reads an internally tiled geotiff (optionally with overviews and masks) and rewrites it

Airbus DS GEO S.A. 37 Nov 15, 2021
This library provides an ASTERIX Frame(binary data) decoding/parsing(json,xml) capabilities for Go.

GoAsterix This library provides an ASTERIX Frame(binary data) decoding/parsing(json,xml) capabilities for Go. ASTERIX ASTERIX (All Purpose Structured

MMK 1 Dec 1, 2021
safe and easy casting from one type to another in Go

cast Easy and safe casting from one type to another in Go Don’t Panic! ... Cast What is Cast? Cast is a library to convert between different go types

Steve Francia 1.9k Nov 29, 2021
The one-stop shop for most common Go functions

Pandati The one stop shop for most common Go functions Table of contents Pandati The one stop shop for most common Go functions Table of contents Purp

Lukasz Raczylo 2 Sep 23, 2021
Go implementation Welford’s method for one-pass variance computation

Welford - Online method of calculating variance and standard deviation Go implementation Welford’s method for one-pass variance computation with D. H.

Axiom, Inc. 4 Nov 6, 2021
A set of instrumentation features for collecting relevant tracing data as well as secure an application

Go Agent goagent provides a set of instrumentation features for collecting relevant tracing data as well as secure an application by blocking requests

null 0 Dec 3, 2021
redis-util business-friendly encapsulation of redis operations, such as the common cache set get operation

redis-util 方便业务使用的redis操作封装,比如常见的缓存set get操作, 一行代码搞定,不像开源库需要写好多行 使用方法

connor 1 Oct 22, 2021
Simple utility to get/set the PWM duty cycle and to measure the RPM for a fan connected to the 4-pin header on the CM4IO.

cm4iofan Simple utility to get/set the PWM duty cycle and to measure the RPM for a fan connected to the 4-pin header on the CM4IO. Requirements Enable

Thomas Maier 3 Nov 28, 2021
Perforator is a tool for recording performance metrics over subregions of a program using the Linux "perf" interface.

Perforator Perforator is a tool for recording performance metrics over subregions of a program (e.g., functions) using the Linux "perf" interface.

Zachary Yedidia 24 Oct 30, 2021
Package ethtool allows control of the Linux ethtool generic netlink interface.

ethtool Package ethtool allows control of the Linux ethtool generic netlink interface.

Matt Layher 30 Nov 21, 2021
A Go library for the Linux Landlock sandboxing feature

Go Landlock library The Go Landlock library restricts the current processes' ability to use files, using Linux 5.13's Landlock feature. (Package docum

Landlock LSM 33 Nov 17, 2021