Programming in Go
All Systems Go

© Lead Image © nomadsoul1, 123RF.com
The Go programming language combines type safety with manageable syntax and an extensive library. We take you through a programming example.
The Go programming language recently celebrated its fourth birthday and increasing popularity. The language has very few limits when it comes to coding Unix daemons, networking code, parallelized programs, and the like, although it is probably less well-suited for an operating system kernel. The Docker container virtualization project and Ubuntu Juju tool are two examples of projects written in Go.
Designed as an heir to the C programming language [1], Go offers many of its predecessor's strengths, while simplifying syntax and supporting secure programming (e.g., through strong type casting). The Unsafe module makes Go resemble C more closely, although it does compromise security, as the module name suggests.
The standard Go library [2] is extensive, offering many useful system programming modules for data compression, cryptography, binary file formats (ELF, Mach-O), and so forth. In this article, I will create a simple tool written in Go that has a function similar to the ps
process status tool in Linux.
Go Projects
Go projects have a somewhat peculiar directory structure. To compile source code files, you must follow a certain procedure, so that the go
build and project tool work properly.
The GOPATH
environment variable specifies the directory in which all Go projects reside. Below that are dist
, bin
, and src
, the latter of which contains the source code under a directory that uniquely identifies a package or project. In principle, this can be any string but is typically your domain name, followed by a project name (e.g., linux-magazine.com/<project>
; Figure 1). The go
tool also loads projects off the Internet (e.g., from GitHub), which then end up in $GOPATH/src/github.com/<project>
.

In my example, the projects reside in $HOME/gocode
. The environment variable is set like this:
export GOPATH=$HOME/gocode
The following call sets the project directory for the tool I will be programming, lap
(i.e., list all processes):
mkdir -p src/linux-magazine.com/lap
If you now store a small "Hello World" file here [1], you can compile the project as follows:
go build linux-magazine.com/lap
If you take a look at the GOPATH/bin
directory, you will discover no files there. The go
tool only copies the binary to this location if you use the install
command; it thus makes sense to do this straight away, instead of detouring via build
. Program libraries end up in GOPATH/pkg
. The object files can be removed by issuing go clean package
; with an additional switch, go clean-f
also removes the binaries.
The idea behind lap
is quite simple. In the /proc
filesystem on Linux, a globally visible directory for each running process uses the process ID as the name. Below this are a number of virtual files with information about this process, including the stat
and status
files, which contain, for example, the parent process ID, the owner, the start time, and so on.
Processing Files
The first task is therefore to list the files in /proc
and filter out the ones with the process information. It can be done quite easily with the filepath.Glob
function, which returns all the file names that match a certain pattern in an array. The following approach takes a little detour to demonstrate a few aspects of loops and string processing in Go:
entries, err := ioutil.ReadDir(procDir) for index, proc := range entries { // do something with proc }
The directory contents are returned by a call to the ReadDir
function from the ioutil
package. To go through all the entries, use the for
loop with a range expression that lets you iterate over arrays, slices, strings, maps, and channels. With only one control variable, range
assigns this to the array index. Go automatically assigns a second variable to the content of the corresponding array element.
The Go compiler only accepts this if you actually do something with the index
variable. If you don't, you can use the Go wildcard for variables, _
. A proc
in this example is of the os.FileInfo
type; it implements an interface that includes the call to Name()
for reading the file name.
Unicode Support
Finding out whether the first character is a number is a little more difficult because Go uses UTF-8 for character encoding – which is actually a good thing. Because UTF-8 is a format that uses between 1 and 4 bytes for a character, it is not clear from the outset how many bytes the first character includes. Typically, Go programmers work their way through a byte array bit by bit and then make decisions on when a new UTF-8 character starts. With a type cast, Go does this automatically in one fell swoop. This results in an array of "runes" – as single UTF-8 characters are called in Go – of which you read the first character with an array index. This in turn can be done with a simple call to the unicode.IsDigit()
function, which expects a rune as an argument:
if unicode.IsDigit([]rune(proc.Name())[0]) {...
Incidentally, the small example program that can be seen in Figure 2 proves that this is not just true of Arabic numerals in the Unicode world but also works for any other numeric systems.

The next task is to open the virtual files in procfs and process their content. Conveniently, the ioutil
library again offers a function (ReadFile
) that fully reads a file and stores the contents in a byte array:
stat, err := ioutil.ReadFile(filename)
As you can see, the function returns two values: the content of the file and an error code. This is typical of Go functions and certainly more structured than, for example, returning a null pointer for the content in the case of an error. If you assign the error code to a variable, you also need to process the variable; otherwise, the compiler will in turn generate an error message and refuse to compile the file. If you want to ignore the return value, you can again assign the error code to the wildcard, _
. To process the fault, you would typically test whether the err
variable is equal to nil
. If so, no error has occurred.
The /proc/PID/stat
file contains only one line in a fixed format, with the individual fields separated by spaces. Unfortunately, the format is not documented anywhere in a useful way, not even in the Linux kernel documentation of procfs [2].
Ultimately, your only resource, if you want to know exactly what is going on, is to take a look at the Linux source code. The PID comes first no matter what (and this is the same as the directory name), then in brackets you have the process name, the process status, and the parent PID.
Buy this article as PDF
(incl. VAT)
Buy Linux Magazine
Direct Download
Read full article as PDF:
Price $2.95
Subscribe to our Linux Newsletters
Find Linux and Open Source Jobs
Subscribe to our ADMIN Newsletters
Find SysAdmin Jobs
News
-
KDE Plasma 5.27 Beta is Ready for Testing
The latest beta iteration of the KDE Plasma desktop is now available and includes some important additions and fixes.
-
Netrunner OS 23 Is Now Available
The latest version of this Linux distribution is now based on Debian Bullseye and is ready for installation and finally hits the KDE 5.20 branch of the desktop.
-
New Linux Distribution Built for Gamers
With a Gnome desktop that offers different layouts and a custom kernel, PikaOS is a great option for gamers of all types.
-
System76 Beefs Up Popular Pangolin Laptop
The darling of open-source-powered laptops and desktops will soon drop a new AMD Ryzen 7-powered version of their popular Pangolin laptop.
-
Nobara Project Is a Modified Version of Fedora with User-Friendly Fixes
If you're looking for a version of Fedora that includes third-party and proprietary packages, look no further than the Nobara Project.
-
Gnome 44 Now Has a Release Date
Gnome 44 will be officially released on March 22, 2023.
-
Nitrux 2.6 Available with Kernel 6.1 and a Major Change
The developers of Nitrux have officially released version 2.6 of their Linux distribution with plenty of new features to excite users.
-
Vanilla OS Initial Release Is Now Available
A stock GNOME experience with on-demand immutability finally sees its first production release.
-
Critical Linux Vulnerability Found to Impact SMB Servers
A Linux vulnerability with a CVSS score of 10 has been found to affect SMB servers and can lead to remote code execution.
-
Linux Mint 21.1 Now Available with Plenty of Look and Feel Changes
Vera has arrived and although it is still using kernel 5.15, there are plenty of improvements sure to please everyone.