|
- \input texinfo
- @c -*-texinfo-*-
-
- @c %**start of header
- @setfilename guix.info
- @documentencoding UTF-8
- @settitle GNU Guix Reference Manual
- @c %**end of header
-
- @include version.texi
-
- @copying
- Copyright @copyright{} 2012, 2013, 2014, 2015 Ludovic Courtès@*
- Copyright @copyright{} 2013, 2014 Andreas Enge@*
- Copyright @copyright{} 2013 Nikita Karetnikov@*
- Copyright @copyright{} 2015 Mathieu Lirzin@*
- Copyright @copyright{} 2014 Pierre-Antoine Rault@*
- Copyright @copyright{} 2015 Taylan Ulrich Bayırlı/Kammer
-
- Permission is granted to copy, distribute and/or modify this document
- under the terms of the GNU Free Documentation License, Version 1.3 or
- any later version published by the Free Software Foundation; with no
- Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A
- copy of the license is included in the section entitled ``GNU Free
- Documentation License''.
- @end copying
-
- @dircategory Package management
- @direntry
- * guix: (guix). Guix, the functional package manager.
- * guix package: (guix)Invoking guix package
- Managing packages with Guix.
- * guix build: (guix)Invoking guix build
- Building packages with Guix.
- * guix system: (guix)Invoking guix system
- Managing the operating system configuration.
- @end direntry
-
- @dircategory Software development
- @direntry
- * guix environment: (guix)Invoking guix environment
- Building development environments with Guix.
- @end direntry
-
- @titlepage
- @title GNU Guix Reference Manual
- @subtitle Using the GNU Guix Functional Package Manager
- @author Ludovic Courtès
- @author Andreas Enge
- @author Nikita Karetnikov
-
- @page
- @vskip 0pt plus 1filll
- Edition @value{EDITION} @*
- @value{UPDATED} @*
-
- @insertcopying
- @end titlepage
-
- @contents
-
- @c *********************************************************************
- @node Top
- @top GNU Guix
-
- This document describes GNU Guix version @value{VERSION}, a functional
- package management tool written for the GNU system.
-
- @menu
- * Introduction:: What is Guix about?
- * Installation:: Installing Guix.
- * Package Management:: Package installation, upgrade, etc.
- * Programming Interface:: Using Guix in Scheme.
- * Utilities:: Package management commands.
- * GNU Distribution:: Software for your friendly GNU system.
- * Contributing:: Your help needed!
-
- * Acknowledgments:: Thanks!
- * GNU Free Documentation License:: The license of this manual.
- * Concept Index:: Concepts.
- * Programming Index:: Data types, functions, and variables.
-
- @detailmenu
- --- The Detailed Node Listing ---
-
- Installation
-
- * Binary Installation:: Getting Guix running in no time!
- * Requirements:: Software needed to build and run Guix.
- * Running the Test Suite:: Testing Guix.
- * Setting Up the Daemon:: Preparing the build daemon's environment.
- * Invoking guix-daemon:: Running the build daemon.
-
- Setting Up the Daemon
-
- * Build Environment Setup:: Preparing the isolated build environment.
- * Daemon Offload Setup:: Offloading builds to remote machines.
-
- Package Management
-
- * Features:: How Guix will make your life brighter.
- * Invoking guix package:: Package installation, removal, etc.
- * Emacs Interface:: Package management from Emacs.
- * Substitutes:: Downloading pre-built binaries.
- * Packages with Multiple Outputs:: Single source package, multiple outputs.
- * Invoking guix gc:: Running the garbage collector.
- * Invoking guix pull:: Fetching the latest Guix and distribution.
- * Invoking guix archive:: Exporting and importing store files.
-
- Programming Interface
-
- * Defining Packages:: Defining new packages.
- * Build Systems:: Specifying how packages are built.
- * The Store:: Manipulating the package store.
- * Derivations:: Low-level interface to package derivations.
- * The Store Monad:: Purely functional interface to the store.
- * G-Expressions:: Manipulating build expressions.
-
- Defining Packages
-
- * package Reference:: The package data type.
- * origin Reference:: The origin data type.
-
- Utilities
-
- * Invoking guix build:: Building packages from the command line.
- * Invoking guix download:: Downloading a file and printing its hash.
- * Invoking guix hash:: Computing the cryptographic hash of a file.
- * Invoking guix import:: Importing package definitions.
- * Invoking guix refresh:: Updating package definitions.
- * Invoking guix lint:: Finding errors in package definitions.
- * Invoking guix environment:: Setting up development environments.
- * Invoking guix publish:: Sharing substitutes.
-
- GNU Distribution
-
- * System Installation:: Installing the whole operating system.
- * System Configuration:: Configuring the operating system.
- * Installing Debugging Files:: Feeding the debugger.
- * Security Updates:: Deploying security fixes quickly.
- * Package Modules:: Packages from the programmer's viewpoint.
- * Packaging Guidelines:: Growing the distribution.
- * Bootstrapping:: GNU/Linux built from scratch.
- * Porting:: Targeting another platform or kernel.
-
- System Configuration
-
- * Using the Configuration System:: Customizing your GNU system.
- * operating-system Reference:: Detail of operating-system declarations.
- * File Systems:: Configuring file system mounts.
- * Mapped Devices:: Block device extra processing.
- * User Accounts:: Specifying user accounts.
- * Locales:: Language and cultural convention settings.
- * Services:: Specifying system services.
- * Setuid Programs:: Programs running with root privileges.
- * X.509 Certificates:: Authenticating HTTPS servers.
- * Name Service Switch:: Configuring libc's name service switch.
- * Initial RAM Disk:: Linux-Libre bootstrapping.
- * GRUB Configuration:: Configuring the boot loader.
- * Invoking guix system:: Instantiating a system configuration.
- * Defining Services:: Adding new service definitions.
-
- Services
-
- * Base Services:: Essential system services.
- * Networking Services:: Network setup, SSH daemon, etc.
- * X Window:: Graphical display.
- * Desktop Services:: D-Bus and desktop services.
- * Database Services:: SQL databases.
- * Various Services:: Other services.
-
- Packaging Guidelines
-
- * Software Freedom:: What may go into the distribution.
- * Package Naming:: What's in a name?
- * Version Numbers:: When the name is not enough.
- * Python Modules:: Taming the snake.
- * Perl Modules:: Little pearls.
- * Fonts:: Fond of fonts.
-
- Contributing
-
- * Building from Git:: The latest and greatest.
- * Running Guix Before It Is Installed:: Hacker tricks.
- * The Perfect Setup:: The right tools.
- * Coding Style:: Hygiene of the contributor.
- * Submitting Patches:: Share your work.
-
- Coding Style
-
- * Programming Paradigm:: How to compose your elements.
- * Modules:: Where to store your code?
- * Data Types and Pattern Matching:: Implementing data structures.
- * Formatting Code:: Writing conventions.
-
- @end detailmenu
- @end menu
-
- @c *********************************************************************
- @node Introduction
- @chapter Introduction
-
- GNU Guix@footnote{``Guix'' is pronounced like ``geeks'', or ``ɡiːks''
- using the international phonetic alphabet (IPA).} is a functional
- package management tool for the GNU system. Package management consists
- of all activities that relate to building packages from sources,
- honoring their build-time and run-time dependencies,
- installing packages in user environments, upgrading installed packages
- to new versions or rolling back to a previous set, removing unused
- software packages, etc.
-
- @cindex functional package management
- The term @dfn{functional} refers to a specific package management
- discipline. In Guix, the package build and installation process is seen
- as a function, in the mathematical sense. That function takes inputs,
- such as build scripts, a compiler, and libraries, and
- returns an installed package. As a pure function, its result depends
- solely on its inputs---for instance, it cannot refer to software or
- scripts that were not explicitly passed as inputs. A build function
- always produces the same result when passed a given set of inputs. It
- cannot alter the system's environment in
- any way; for instance, it cannot create, modify, or delete files outside
- of its build and installation directories. This is achieved by running
- build processes in isolated environments (or @dfn{containers}), where only their
- explicit inputs are visible.
-
- @cindex store
- The result of package build functions is @dfn{cached} in the file
- system, in a special directory called @dfn{the store} (@pxref{The
- Store}). Each package is installed in a directory of its own, in the
- store---by default under @file{/gnu/store}. The directory name contains
- a hash of all the inputs used to build that package; thus, changing an
- input yields a different directory name.
-
- This approach is the foundation of Guix's salient features: support for
- transactional package upgrade and rollback, per-user installation, and
- garbage collection of packages (@pxref{Features}).
-
- Guix has a command-line interface, which allows users to build, install,
- upgrade, and remove packages, as well as a Scheme programming interface.
-
- @cindex Guix System Distribution
- @cindex GuixSD
- Last but not least, Guix is used to build a distribution of the GNU
- system, with many GNU and non-GNU free software packages. The Guix
- System Distribution, or GNU@tie{}GuixSD, takes advantage of the core
- properties of Guix at the system level. With GuixSD, users
- @emph{declare} all aspects of the operating system configuration, and
- Guix takes care of instantiating that configuration in a reproducible,
- stateless fashion. @xref{GNU Distribution}.
-
- @c *********************************************************************
- @node Installation
- @chapter Installation
-
- GNU Guix is available for download from its website at
- @url{http://www.gnu.org/software/guix/}. This section describes the
- software requirements of Guix, as well as how to install it and get
- ready to use it.
-
- Note that this section is concerned with the installation of the package
- manager, which can be done on top of a running GNU/Linux system. If,
- instead, you want to install the complete GNU operating system,
- @pxref{System Installation}.
-
- @menu
- * Binary Installation:: Getting Guix running in no time!
- * Requirements:: Software needed to build and run Guix.
- * Running the Test Suite:: Testing Guix.
- * Setting Up the Daemon:: Preparing the build daemon's environment.
- * Invoking guix-daemon:: Running the build daemon.
- @end menu
-
- @node Binary Installation
- @section Binary Installation
-
- This section describes how to install Guix on an arbitrary system from a
- self-contained tarball providing binaries for Guix and for all its
- dependencies. This is often quicker than installing from source, which
- is described in the next sections. The only requirement is to have
- GNU@tie{}tar and Xz.
-
- Installing goes along these lines:
-
- @enumerate
- @item
- Download the binary tarball from
- @indicateurl{ftp://alpha.gnu.org/gnu/guix/guix-binary-@value{VERSION}.@var{system}.tar.xz}@footnote{As
- usual, make sure to download the associated @file{.sig} file and to
- verify the authenticity of the tarball against it!}, where @var{system}
- is @code{x86_64-linux} for an @code{x86_64} machine already running the
- kernel Linux, and so on.
-
- @item
- As @code{root}, run:
-
- @example
- # cd /tmp
- # tar xf guix-binary-@value{VERSION}.@var{system}.tar.xz
- # mv var/guix /var/ && mv gnu /
- @end example
-
- This creates @file{/gnu/store} (@pxref{The Store}) and @file{/var/guix}.
- The latter contains a ready-to-use profile for @code{root} (see next
- step.)
-
- Do @emph{not} unpack the tarball on a working Guix system since that
- would overwrite its own essential files.
-
- @item
- Make @code{root}'s profile available under @file{~/.guix-profile}:
-
- @example
- # ln -sf /var/guix/profiles/per-user/root/guix-profile \
- ~root/.guix-profile
- @end example
-
- @item
- Run the daemon:
-
- @example
- # ~root/.guix-profile/bin/guix-daemon --build-users-group=guixbuild
- @end example
-
- @item
- Make the @command{guix} command available to other users on the machine,
- for instance with:
-
- @example
- # mkdir -p /usr/local/bin
- # cd /usr/local/bin
- # ln -s /var/guix/profiles/per-user/root/guix-profile/bin/guix
- @end example
-
- @item
- To use substitutes from @code{hydra.gnu.org} (@pxref{Substitutes}),
- authorize them:
-
- @example
- # guix archive --authorize < ~root/.guix-profile/share/guix/hydra.gnu.org.pub
- @end example
- @end enumerate
-
- And that's it!
-
- The @code{guix} package must remain available in @code{root}'s
- profile, or it would become subject to garbage collection---in which
- case you would find yourself badly handicapped by the lack of the
- @command{guix} command.
-
- The tarball in question can be (re)produced and verified simply by
- running the following command in the Guix source tree:
-
- @example
- make guix-binary.@var{system}.tar.xz
- @end example
-
-
- @node Requirements
- @section Requirements
-
- This section lists requirements when building Guix from source. The
- build procedure for Guix is the same as for other GNU software, and is
- not covered here. Please see the files @file{README} and @file{INSTALL}
- in the Guix source tree for additional details.
-
- GNU Guix depends on the following packages:
-
- @itemize
- @item @url{http://gnu.org/software/guile/, GNU Guile}, version 2.0.7 or later;
- @item @url{http://gnupg.org/, GNU libgcrypt};
- @item @url{http://www.gnu.org/software/make/, GNU Make}.
- @end itemize
-
- The following dependencies are optional:
-
- @itemize
- @item
- Installing
- @url{http://savannah.nongnu.org/projects/guile-json/, Guile-JSON} will
- allow you to use the @command{guix import pypi} command (@pxref{Invoking
- guix import}). It is of
- interest primarily for developers and not for casual users.
- @item
- Installing @uref{http://gnutls.org/, GnuTLS-Guile} will
- allow you to access @code{https} URLs with the @command{guix download}
- command (@pxref{Invoking guix download}), the @command{guix import pypi}
- command, and the @command{guix import cpan} command. This is primarily
- of interest to developers. @xref{Guile Preparations, how to install the
- GnuTLS bindings for Guile,, gnutls-guile, GnuTLS-Guile}.
- @end itemize
-
- Unless @code{--disable-daemon} was passed to @command{configure}, the
- following packages are also needed:
-
- @itemize
- @item @url{http://sqlite.org, SQLite 3};
- @item @url{http://www.bzip.org, libbz2};
- @item @url{http://gcc.gnu.org, GCC's g++}, with support for the
- C++11 standard.
- @end itemize
-
- When a working installation of @url{http://nixos.org/nix/, the Nix package
- manager} is available, you
- can instead configure Guix with @code{--disable-daemon}. In that case,
- Nix replaces the three dependencies above.
-
- Guix is compatible with Nix, so it is possible to share the same store
- between both. To do so, you must pass @command{configure} not only the
- same @code{--with-store-dir} value, but also the same
- @code{--localstatedir} value. The latter is essential because it
- specifies where the database that stores metadata about the store is
- located, among other things. The default values for Nix are
- @code{--with-store-dir=/nix/store} and @code{--localstatedir=/nix/var}.
- Note that @code{--disable-daemon} is not required if
- your goal is to share the store with Nix.
-
- @node Running the Test Suite
- @section Running the Test Suite
-
- After a successful @command{configure} and @code{make} run, it is a good
- idea to run the test suite. It can help catch issues with the setup or
- environment, or bugs in Guix itself---and really, reporting test
- failures is a good way to help improve the software. To run the test
- suite, type:
-
- @example
- make check
- @end example
-
- Test cases can run in parallel: you can use the @code{-j} option of
- GNU@tie{}make to speed things up. The first run may take a few minutes
- on a recent machine; subsequent runs will be faster because the store
- that is created for test purposes will already have various things in
- cache.
-
- Upon failure, please email @email{bug-guix@@gnu.org} and attach the
- @file{test-suite.log} file. When @file{tests/@var{something}.scm}
- fails, please also attach the @file{@var{something}.log} file available
- in the top-level build directory. Please specify the Guix version being
- used as well as version numbers of the dependencies
- (@pxref{Requirements}) in your message.
-
- @node Setting Up the Daemon
- @section Setting Up the Daemon
-
- @cindex daemon
- Operations such as building a package or running the garbage collector
- are all performed by a specialized process, the @dfn{build daemon}, on
- behalf of clients. Only the daemon may access the store and its
- associated database. Thus, any operation that manipulates the store
- goes through the daemon. For instance, command-line tools such as
- @command{guix package} and @command{guix build} communicate with the
- daemon (@i{via} remote procedure calls) to instruct it what to do.
-
- The following sections explain how to prepare the build daemon's
- environment. Also @ref{Substitutes}, for information on how to allow
- the daemon to download pre-built binaries.
-
- @menu
- * Build Environment Setup:: Preparing the isolated build environment.
- * Daemon Offload Setup:: Offloading builds to remote machines.
- @end menu
-
- @node Build Environment Setup
- @subsection Build Environment Setup
-
- In a standard multi-user setup, Guix and its daemon---the
- @command{guix-daemon} program---are installed by the system
- administrator; @file{/gnu/store} is owned by @code{root} and
- @command{guix-daemon} runs as @code{root}. Unprivileged users may use
- Guix tools to build packages or otherwise access the store, and the
- daemon will do it on their behalf, ensuring that the store is kept in a
- consistent state, and allowing built packages to be shared among users.
-
- @cindex build users
- When @command{guix-daemon} runs as @code{root}, you may not want package
- build processes themselves to run as @code{root} too, for obvious
- security reasons. To avoid that, a special pool of @dfn{build users}
- should be created for use by build processes started by the daemon.
- These build users need not have a shell and a home directory: they will
- just be used when the daemon drops @code{root} privileges in build
- processes. Having several such users allows the daemon to launch
- distinct build processes under separate UIDs, which guarantees that they
- do not interfere with each other---an essential feature since builds are
- regarded as pure functions (@pxref{Introduction}).
-
- On a GNU/Linux system, a build user pool may be created like this (using
- Bash syntax and the @code{shadow} commands):
-
- @c See http://lists.gnu.org/archive/html/bug-guix/2013-01/msg00239.html
- @c for why `-G' is needed.
- @example
- # groupadd --system guixbuild
- # for i in `seq -w 1 10`;
- do
- useradd -g guixbuild -G guixbuild \
- -d /var/empty -s `which nologin` \
- -c "Guix build user $i" --system \
- guixbuilder$i;
- done
- @end example
-
- @noindent
- The number of build users determines how many build jobs may run in
- parallel, as specified by the @option{--max-jobs} option
- (@pxref{Invoking guix-daemon, @option{--max-jobs}}).
- The @code{guix-daemon} program may then be run as @code{root} with:
-
- @example
- # guix-daemon --build-users-group=guixbuild
- @end example
-
- @cindex chroot
- @noindent
- This way, the daemon starts build processes in a chroot, under one of
- the @code{guixbuilder} users. On GNU/Linux, by default, the chroot
- environment contains nothing but:
-
- @c Keep this list in sync with libstore/build.cc! -----------------------
- @itemize
- @item
- a minimal @code{/dev} directory, created mostly independently from the
- host @code{/dev}@footnote{``Mostly'', because while the set of files
- that appear in the chroot's @code{/dev} is fixed, most of these files
- can only be created if the host has them.};
-
- @item
- the @code{/proc} directory; it only shows the container's processes
- since a separate PID name space is used;
-
- @item
- @file{/etc/passwd} with an entry for the current user and an entry for
- user @file{nobody};
-
- @item
- @file{/etc/group} with an entry for the user's group;
-
- @item
- @file{/etc/hosts} with an entry that maps @code{localhost} to
- @code{127.0.0.1};
-
- @item
- a writable @file{/tmp} directory.
- @end itemize
-
- If you are installing Guix as an unprivileged user, it is still possible
- to run @command{guix-daemon} provided you pass @code{--disable-chroot}.
- However, build processes will not be isolated from one another, and not
- from the rest of the system. Thus, build processes may interfere with
- each other, and may access programs, libraries, and other files
- available on the system---making it much harder to view them as
- @emph{pure} functions.
-
-
- @node Daemon Offload Setup
- @subsection Using the Offload Facility
-
- @cindex offloading
- @cindex build hook
- When desired, the build daemon can @dfn{offload}
- derivation builds to other machines
- running Guix, using the @code{offload} @dfn{build hook}. When that
- feature is enabled, a list of user-specified build machines is read from
- @file{/etc/guix/machines.scm}; anytime a build is requested, for
- instance via @code{guix build}, the daemon attempts to offload it to one
- of the machines that satisfies the derivation's constraints, in
- particular its system type---e.g., @file{x86_64-linux}. Missing
- prerequisites for the build are copied over SSH to the target machine,
- which then proceeds with the build; upon success the output(s) of the
- build are copied back to the initial machine.
-
- The @file{/etc/guix/machines.scm} file typically looks like this:
-
- @example
- (list (build-machine
- (name "eightysix.example.org")
- (system "x86_64-linux")
- (user "bob")
- (speed 2.)) ; incredibly fast!
-
- (build-machine
- (name "meeps.example.org")
- (system "mips64el-linux")
- (user "alice")
- (private-key
- (string-append (getenv "HOME")
- "/.ssh/id-rsa-for-guix"))))
- @end example
-
- @noindent
- In the example above we specify a list of two build machines, one for
- the @code{x86_64} architecture and one for the @code{mips64el}
- architecture.
-
- In fact, this file is---not surprisingly!---a Scheme file that is
- evaluated when the @code{offload} hook is started. Its return value
- must be a list of @code{build-machine} objects. While this example
- shows a fixed list of build machines, one could imagine, say, using
- DNS-SD to return a list of potential build machines discovered in the
- local network (@pxref{Introduction, Guile-Avahi,, guile-avahi, Using
- Avahi in Guile Scheme Programs}). The @code{build-machine} data type is
- detailed below.
-
- @deftp {Data Type} build-machine
- This data type represents build machines the daemon may offload builds
- to. The important fields are:
-
- @table @code
-
- @item name
- The remote machine's host name.
-
- @item system
- The remote machine's system type---e.g., @code{"x86_64-linux"}.
-
- @item user
- The user account to use when connecting to the remote machine over SSH.
- Note that the SSH key pair must @emph{not} be passphrase-protected, to
- allow non-interactive logins.
-
- @end table
-
- A number of optional fields may be specified:
-
- @table @code
-
- @item port
- Port number of the machine's SSH server (default: 22).
-
- @item private-key
- The SSH private key file to use when connecting to the machine.
-
- @item parallel-builds
- The number of builds that may run in parallel on the machine (1 by
- default.)
-
- @item speed
- A ``relative speed factor''. The offload scheduler will tend to prefer
- machines with a higher speed factor.
-
- @item features
- A list of strings denoting specific features supported by the machine.
- An example is @code{"kvm"} for machines that have the KVM Linux modules
- and corresponding hardware support. Derivations can request features by
- name, and they will be scheduled on matching build machines.
-
- @end table
- @end deftp
-
- The @code{guix} command must be in the search path on the build
- machines, since offloading works by invoking the @code{guix archive} and
- @code{guix build} commands.
-
- There's one last thing to do once @file{machines.scm} is in place. As
- explained above, when offloading, files are transferred back and forth
- between the machine stores. For this to work, you need to generate a
- key pair to allow the daemon to export signed archives of files from the
- store (@pxref{Invoking guix archive}):
-
- @example
- # guix archive --generate-key
- @end example
-
- @noindent
- Thus, when receiving files, a machine's build daemon can make sure they
- are genuine, have not been tampered with, and that they are signed by an
- authorized key.
-
-
- @node Invoking guix-daemon
- @section Invoking @command{guix-daemon}
-
- The @command{guix-daemon} program implements all the functionality to
- access the store. This includes launching build processes, running the
- garbage collector, querying the availability of a build result, etc. It
- is normally run as @code{root} like this:
-
- @example
- # guix-daemon --build-users-group=guixbuild
- @end example
-
- @noindent
- For details on how to set it up, @pxref{Setting Up the Daemon}.
-
- @cindex chroot
- @cindex container, build environment
- @cindex build environment
- @cindex reproducible builds
- By default, @command{guix-daemon} launches build processes under
- different UIDs, taken from the build group specified with
- @code{--build-users-group}. In addition, each build process is run in a
- chroot environment that only contains the subset of the store that the
- build process depends on, as specified by its derivation
- (@pxref{Programming Interface, derivation}), plus a set of specific
- system directories. By default, the latter contains @file{/dev} and
- @file{/dev/pts}. Furthermore, on GNU/Linux, the build environment is a
- @dfn{container}: in addition to having its own file system tree, it has
- a separate mount name space, its own PID name space, network name space,
- etc. This helps achieve reproducible builds (@pxref{Features}).
-
- When the daemon performs a build on behalf of the user, it creates a
- build directory under @file{/tmp} or under the directory specified by
- its @code{TMPDIR} environment variable; this directory is shared with
- the container for the duration of the build. Be aware that using a
- directory other than @file{/tmp} can affect build results---for example,
- with a longer directory name, a build process that uses Unix-domain
- sockets might hit the name length limitation for @code{sun_path}, which
- it would otherwise not hit.
-
- The build directory is automatically deleted upon completion, unless the
- build failed and the client specified @option{--keep-failed}
- (@pxref{Invoking guix build, @option{--keep-failed}}).
-
- The following command-line options are supported:
-
- @table @code
- @item --build-users-group=@var{group}
- Take users from @var{group} to run build processes (@pxref{Setting Up
- the Daemon, build users}).
-
- @item --no-substitutes
- @cindex substitutes
- Do not use substitutes for build products. That is, always build things
- locally instead of allowing downloads of pre-built binaries
- (@pxref{Substitutes}).
-
- By default substitutes are used, unless the client---such as the
- @command{guix package} command---is explicitly invoked with
- @code{--no-substitutes}.
-
- When the daemon runs with @code{--no-substitutes}, clients can still
- explicitly enable substitution @i{via} the @code{set-build-options}
- remote procedure call (@pxref{The Store}).
-
- @item --substitute-urls=@var{urls}
- Consider @var{urls} the default whitespace-separated list of substitute
- source URLs. When this option is omitted, @indicateurl{http://hydra.gnu.org}
- is used.
-
- This means that substitutes may be downloaded from @var{urls}, as long
- as they are signed by a trusted signature (@pxref{Substitutes}).
-
- @cindex build hook
- @item --no-build-hook
- Do not use the @dfn{build hook}.
-
- The build hook is a helper program that the daemon can start and to
- which it submits build requests. This mechanism is used to offload
- builds to other machines (@pxref{Daemon Offload Setup}).
-
- @item --cache-failures
- Cache build failures. By default, only successful builds are cached.
-
- @item --cores=@var{n}
- @itemx -c @var{n}
- Use @var{n} CPU cores to build each derivation; @code{0} means as many
- as available.
-
- The default value is @code{0}, but it may be overridden by clients, such
- as the @code{--cores} option of @command{guix build} (@pxref{Invoking
- guix build}).
-
- The effect is to define the @code{NIX_BUILD_CORES} environment variable
- in the build process, which can then use it to exploit internal
- parallelism---for instance, by running @code{make -j$NIX_BUILD_CORES}.
-
- @item --max-jobs=@var{n}
- @itemx -M @var{n}
- Allow at most @var{n} build jobs in parallel. The default value is
- @code{1}. Setting it to @code{0} means that no builds will be performed
- locally; instead, the daemon will offload builds (@pxref{Daemon Offload
- Setup}), or simply fail.
-
- @item --debug
- Produce debugging output.
-
- This is useful to debug daemon start-up issues, but then it may be
- overridden by clients, for example the @code{--verbosity} option of
- @command{guix build} (@pxref{Invoking guix build}).
-
- @item --chroot-directory=@var{dir}
- Add @var{dir} to the build chroot.
-
- Doing this may change the result of build processes---for instance if
- they use optional dependencies found in @var{dir} when it is available,
- and not otherwise. For that reason, it is not recommended to do so.
- Instead, make sure that each derivation declares all the inputs that it
- needs.
-
- @item --disable-chroot
- Disable chroot builds.
-
- Using this option is not recommended since, again, it would allow build
- processes to gain access to undeclared dependencies. It is necessary,
- though, when @command{guix-daemon} is running under an unprivileged user
- account.
-
- @item --disable-log-compression
- Disable compression of the build logs.
-
- Unless @code{--lose-logs} is used, all the build logs are kept in the
- @var{localstatedir}. To save space, the daemon automatically compresses
- them with bzip2 by default. This option disables that.
-
- @item --disable-deduplication
- @cindex deduplication
- Disable automatic file ``deduplication'' in the store.
-
- By default, files added to the store are automatically ``deduplicated'':
- if a newly added file is identical to another one found in the store,
- the daemon makes the new file a hard link to the other file. This can
- noticeably reduce disk usage, at the expense of slightly increasde
- input/output load at the end of a build process. This option disables
- this optimization.
-
- @item --gc-keep-outputs[=yes|no]
- Tell whether the garbage collector (GC) must keep outputs of live
- derivations.
-
- When set to ``yes'', the GC will keep the outputs of any live derivation
- available in the store---the @code{.drv} files. The default is ``no'',
- meaning that derivation outputs are kept only if they are GC roots.
-
- @item --gc-keep-derivations[=yes|no]
- Tell whether the garbage collector (GC) must keep derivations
- corresponding to live outputs.
-
- When set to ``yes'', as is the case by default, the GC keeps
- derivations---i.e., @code{.drv} files---as long as at least one of their
- outputs is live. This allows users to keep track of the origins of
- items in their store. Setting it to ``no'' saves a bit of disk space.
-
- Note that when both @code{--gc-keep-derivations} and
- @code{--gc-keep-outputs} are used, the effect is to keep all the build
- prerequisites (the sources, compiler, libraries, and other build-time
- tools) of live objects in the store, regardless of whether these
- prerequisites are live. This is convenient for developers since it
- saves rebuilds or downloads.
-
- @item --impersonate-linux-2.6
- On Linux-based systems, impersonate Linux 2.6. This means that the
- kernel's @code{uname} system call will report 2.6 as the release number.
-
- This might be helpful to build programs that (usually wrongfully) depend
- on the kernel version number.
-
- @item --lose-logs
- Do not keep build logs. By default they are kept under
- @code{@var{localstatedir}/guix/log}.
-
- @item --system=@var{system}
- Assume @var{system} as the current system type. By default it is the
- architecture/kernel pair found at configure time, such as
- @code{x86_64-linux}.
-
- @item --listen=@var{socket}
- Listen for connections on @var{socket}, the file name of a Unix-domain
- socket. The default socket is
- @file{@var{localstatedir}/daemon-socket/socket}. This option is only
- useful in exceptional circumstances, such as if you need to run several
- daemons on the same machine.
- @end table
-
-
- @c *********************************************************************
- @node Package Management
- @chapter Package Management
-
- The purpose of GNU Guix is to allow users to easily install, upgrade, and
- remove software packages, without having to know about their build
- procedure or dependencies. Guix also goes beyond this obvious set of
- features.
-
- This chapter describes the main features of Guix, as well as the package
- management tools it provides. Two user interfaces are provided for
- routine package management tasks: a command-line interface
- (@pxref{Invoking guix package, @code{guix package}}), and a visual user
- interface in Emacs (@pxref{Emacs Interface}).
-
- @menu
- * Features:: How Guix will make your life brighter.
- * Invoking guix package:: Package installation, removal, etc.
- * Emacs Interface:: Package management from Emacs.
- * Substitutes:: Downloading pre-built binaries.
- * Packages with Multiple Outputs:: Single source package, multiple outputs.
- * Invoking guix gc:: Running the garbage collector.
- * Invoking guix pull:: Fetching the latest Guix and distribution.
- * Invoking guix archive:: Exporting and importing store files.
- @end menu
-
- @node Features
- @section Features
-
- When using Guix, each package ends up in the @dfn{package store}, in its
- own directory---something that resembles
- @file{/gnu/store/xxx-package-1.2}, where @code{xxx} is a base32 string
- (note that Guix comes with an Emacs extension to shorten those file
- names, @pxref{Emacs Prettify}.)
-
- Instead of referring to these directories, users have their own
- @dfn{profile}, which points to the packages that they actually want to
- use. These profiles are stored within each user's home directory, at
- @code{$HOME/.guix-profile}.
-
- For example, @code{alice} installs GCC 4.7.2. As a result,
- @file{/home/alice/.guix-profile/bin/gcc} points to
- @file{/gnu/store/@dots{}-gcc-4.7.2/bin/gcc}. Now, on the same machine,
- @code{bob} had already installed GCC 4.8.0. The profile of @code{bob}
- simply continues to point to
- @file{/gnu/store/@dots{}-gcc-4.8.0/bin/gcc}---i.e., both versions of GCC
- coexist on the same system without any interference.
-
- The @command{guix package} command is the central tool to manage
- packages (@pxref{Invoking guix package}). It operates on those per-user
- profiles, and can be used @emph{with normal user privileges}.
-
- The command provides the obvious install, remove, and upgrade
- operations. Each invocation is actually a @emph{transaction}: either
- the specified operation succeeds, or nothing happens. Thus, if the
- @command{guix package} process is terminated during the transaction,
- or if a power outage occurs during the transaction, then the user's
- profile remains in its previous state, and remains usable.
-
- In addition, any package transaction may be @emph{rolled back}. So, if,
- for example, an upgrade installs a new version of a package that turns
- out to have a serious bug, users may roll back to the previous instance
- of their profile, which was known to work well. Similarly, the global
- system configuration is subject to transactional upgrades and roll-back
- (@pxref{Using the Configuration System}).
-
- All those packages in the package store may be @emph{garbage-collected}.
- Guix can determine which packages are still referenced by the user
- profiles, and remove those that are provably no longer referenced
- (@pxref{Invoking guix gc}). Users may also explicitly remove old
- generations of their profile so that the packages they refer to can be
- collected.
-
- @cindex reproducibility
- @cindex reproducible builds
- Finally, Guix takes a @dfn{purely functional} approach to package
- management, as described in the introduction (@pxref{Introduction}).
- Each @file{/gnu/store} package directory name contains a hash of all the
- inputs that were used to build that package---compiler, libraries, build
- scripts, etc. This direct correspondence allows users to make sure a
- given package installation matches the current state of their
- distribution. It also helps maximize @dfn{build reproducibility}:
- thanks to the isolated build environments that are used, a given build
- is likely to yield bit-identical files when performed on different
- machines (@pxref{Invoking guix-daemon, container}).
-
- @cindex substitutes
- This foundation allows Guix to support @dfn{transparent binary/source
- deployment}. When a pre-built binary for a @file{/gnu/store} item is
- available from an external source---a @dfn{substitute}, Guix just
- downloads it and unpacks it;
- otherwise, it builds the package from source, locally
- (@pxref{Substitutes}).
-
- Control over the build environment is a feature that is also useful for
- developers. The @command{guix environment} command allows developers of
- a package to quickly set up the right development environment for their
- package, without having to manually install the package's dependencies
- in their profile (@pxref{Invoking guix environment}).
-
- @node Invoking guix package
- @section Invoking @command{guix package}
-
- The @command{guix package} command is the tool that allows users to
- install, upgrade, and remove packages, as well as rolling back to
- previous configurations. It operates only on the user's own profile,
- and works with normal user privileges (@pxref{Features}). Its syntax
- is:
-
- @example
- guix package @var{options}
- @end example
-
- Primarily, @var{options} specifies the operations to be performed during
- the transaction. Upon completion, a new profile is created, but
- previous @dfn{generations} of the profile remain available, should the user
- want to roll back.
-
- For example, to remove @code{lua} and install @code{guile} and
- @code{guile-cairo} in a single transaction:
-
- @example
- guix package -r lua -i guile guile-cairo
- @end example
-
- @command{guix package} also supports a @dfn{declarative approach}
- whereby the user specifies the exact set of packages to be available and
- passes it @i{via} the @option{--manifest} option
- (@pxref{profile-manifest, @option{--manifest}}).
-
- For each user, a symlink to the user's default profile is automatically
- created in @file{$HOME/.guix-profile}. This symlink always points to the
- current generation of the user's default profile. Thus, users can add
- @file{$HOME/.guix-profile/bin} to their @code{PATH} environment
- variable, and so on.
- @cindex search paths
- If you are not using the Guix System Distribution, consider adding the
- following lines to your @file{~/.bash_profile} (@pxref{Bash Startup
- Files,,, bash, The GNU Bash Reference Manual}) so that newly-spawned
- shells get all the right environment variable definitions:
-
- @example
- GUIX_PROFILE="$HOME/.guix-profile" \
- source "$HOME/.guix-profile/etc/profile"
- @end example
-
- In a multi-user setup, user profiles are stored in a place registered as
- a @dfn{garbage-collector root}, which @file{$HOME/.guix-profile} points
- to (@pxref{Invoking guix gc}). That directory is normally
- @code{@var{localstatedir}/profiles/per-user/@var{user}}, where
- @var{localstatedir} is the value passed to @code{configure} as
- @code{--localstatedir}, and @var{user} is the user name. The
- @file{per-user} directory is created when @command{guix-daemon} is
- started, and the @var{user} sub-directory is created by @command{guix
- package}.
-
- The @var{options} can be among the following:
-
- @table @code
-
- @item --install=@var{package} @dots{}
- @itemx -i @var{package} @dots{}
- Install the specified @var{package}s.
-
- Each @var{package} may specify either a simple package name, such as
- @code{guile}, or a package name followed by a hyphen and version number,
- such as @code{guile-1.8.8} or simply @code{guile-1.8} (in the latter
- case, the newest version prefixed by @code{1.8} is selected.)
-
- If no version number is specified, the
- newest available version will be selected. In addition, @var{package}
- may contain a colon, followed by the name of one of the outputs of the
- package, as in @code{gcc:doc} or @code{binutils-2.22:lib}
- (@pxref{Packages with Multiple Outputs}). Packages with a corresponding
- name (and optionally version) are searched for among the GNU
- distribution modules (@pxref{Package Modules}).
-
- @cindex propagated inputs
- Sometimes packages have @dfn{propagated inputs}: these are dependencies
- that automatically get installed along with the required package
- (@pxref{package-propagated-inputs, @code{propagated-inputs} in
- @code{package} objects}, for information about propagated inputs in
- package definitions).
-
- @anchor{package-cmd-propagated-inputs}
- An example is the GNU MPC library: its C header files refer to those of
- the GNU MPFR library, which in turn refer to those of the GMP library.
- Thus, when installing MPC, the MPFR and GMP libraries also get installed
- in the profile; removing MPC also removes MPFR and GMP---unless they had
- also been explicitly installed independently.
-
- Besides, packages sometimes rely on the definition of environment
- variables for their search paths (see explanation of
- @code{--search-paths} below). Any missing or possibly incorrect
- environment variable definitions are reported here.
-
- @c XXX: keep me up-to-date
- Finally, when installing a GNU package, the tool reports the
- availability of a newer upstream version. In the future, it may provide
- the option of installing directly from the upstream version, even if
- that version is not yet in the distribution.
-
- @item --install-from-expression=@var{exp}
- @itemx -e @var{exp}
- Install the package @var{exp} evaluates to.
-
- @var{exp} must be a Scheme expression that evaluates to a
- @code{<package>} object. This option is notably useful to disambiguate
- between same-named variants of a package, with expressions such as
- @code{(@@ (gnu packages base) guile-final)}.
-
- Note that this option installs the first output of the specified
- package, which may be insufficient when needing a specific output of a
- multiple-output package.
-
- @item --remove=@var{package} @dots{}
- @itemx -r @var{package} @dots{}
- Remove the specified @var{package}s.
-
- As for @code{--install}, each @var{package} may specify a version number
- and/or output name in addition to the package name. For instance,
- @code{-r glibc:debug} would remove the @code{debug} output of
- @code{glibc}.
-
- @item --upgrade[=@var{regexp} @dots{}]
- @itemx -u [@var{regexp} @dots{}]
- Upgrade all the installed packages. If one or more @var{regexp}s are
- specified, upgrade only installed packages whose name matches a
- @var{regexp}. Also see the @code{--do-not-upgrade} option below.
-
- Note that this upgrades package to the latest version of packages found
- in the distribution currently installed. To update your distribution,
- you should regularly run @command{guix pull} (@pxref{Invoking guix
- pull}).
-
- @item --do-not-upgrade[=@var{regexp} @dots{}]
- When used together with the @code{--upgrade} option, do @emph{not}
- upgrade any packages whose name matches a @var{regexp}. For example, to
- upgrade all packages in the current profile except those containing the
- substring ``emacs'':
-
- @example
- $ guix package --upgrade . --do-not-upgrade emacs
- @end example
-
- @item @anchor{profile-manifest}--manifest=@var{file}
- @itemx -m @var{file}
- @cindex profile declaration
- @cindex profile manifest
- Create a new generation of the profile from the manifest object
- returned by the Scheme code in @var{file}.
-
- This allows you to @emph{declare} the profile's contents rather than
- constructing it through a sequence of @code{--install} and similar
- commands. The advantage is that @var{file} can be put under version
- control, copied to different machines to reproduce the same profile, and
- so on.
-
- @c FIXME: Add reference to (guix profile) documentation when available.
- @var{file} must return a @dfn{manifest} object, which is roughly a list
- of packages:
-
- @findex packages->manifest
- @example
- (use-package-modules guile emacs)
-
- (packages->manifest
- (list emacs
- guile-2.0
- ;; Use a specific package output.
- (list guile-2.0 "debug")))
- @end example
-
- @item --roll-back
- Roll back to the previous @dfn{generation} of the profile---i.e., undo
- the last transaction.
-
- When combined with options such as @code{--install}, roll back occurs
- before any other actions.
-
- When rolling back from the first generation that actually contains
- installed packages, the profile is made to point to the @dfn{zeroth
- generation}, which contains no files apart from its own meta-data.
-
- Installing, removing, or upgrading packages from a generation that has
- been rolled back to overwrites previous future generations. Thus, the
- history of a profile's generations is always linear.
-
- @item --switch-generation=@var{pattern}
- @itemx -S @var{pattern}
- Switch to a particular generation defined by @var{pattern}.
-
- @var{pattern} may be either a generation number or a number prefixed
- with ``+'' or ``-''. The latter means: move forward/backward by a
- specified number of generations. For example, if you want to return to
- the latest generation after @code{--roll-back}, use
- @code{--switch-generation=+1}.
-
- The difference between @code{--roll-back} and
- @code{--switch-generation=-1} is that @code{--switch-generation} will
- not make a zeroth generation, so if a specified generation does not
- exist, the current generation will not be changed.
-
- @item --search-paths[=@var{kind}]
- @cindex search paths
- Report environment variable definitions, in Bash syntax, that may be
- needed in order to use the set of installed packages. These environment
- variables are used to specify @dfn{search paths} for files used by some
- of the installed packages.
-
- For example, GCC needs the @code{CPATH} and @code{LIBRARY_PATH}
- environment variables to be defined so it can look for headers and
- libraries in the user's profile (@pxref{Environment Variables,,, gcc,
- Using the GNU Compiler Collection (GCC)}). If GCC and, say, the C
- library are installed in the profile, then @code{--search-paths} will
- suggest setting these variables to @code{@var{profile}/include} and
- @code{@var{profile}/lib}, respectively.
-
- The typical use case is to define these environment variables in the
- shell:
-
- @example
- $ eval `guix package --search-paths`
- @end example
-
- @var{kind} may be one of @code{exact}, @code{prefix}, or @code{suffix},
- meaning that the returned environment variable definitions will either
- be exact settings, or prefixes or suffixes of the current value of these
- variables. When omitted, @var{kind} defaults to @code{exact}.
-
- @item --profile=@var{profile}
- @itemx -p @var{profile}
- Use @var{profile} instead of the user's default profile.
-
- @item --verbose
- Produce verbose output. In particular, emit the environment's build log
- on the standard error port.
-
- @item --bootstrap
- Use the bootstrap Guile to build the profile. This option is only
- useful to distribution developers.
-
- @end table
-
- In addition to these actions @command{guix package} supports the
- following options to query the current state of a profile, or the
- availability of packages:
-
- @table @option
-
- @item --search=@var{regexp}
- @itemx -s @var{regexp}
- List the available packages whose name, synopsis, or description matches
- @var{regexp}. Print all the meta-data of matching packages in
- @code{recutils} format (@pxref{Top, GNU recutils databases,, recutils,
- GNU recutils manual}).
-
- This allows specific fields to be extracted using the @command{recsel}
- command, for instance:
-
- @example
- $ guix package -s malloc | recsel -p name,version
- name: glibc
- version: 2.17
-
- name: libgc
- version: 7.2alpha6
- @end example
-
- Similarly, to show the name of all the packages available under the
- terms of the GNU@tie{}LGPL version 3:
-
- @example
- $ guix package -s "" | recsel -p name -e 'license ~ "LGPL 3"'
- name: elfutils
-
- name: gmp
- @dots{}
- @end example
-
- @item --show=@var{package}
- Show details about @var{package}, taken from the list of available packages, in
- @code{recutils} format (@pxref{Top, GNU recutils databases,, recutils, GNU
- recutils manual}).
-
- @example
- $ guix package --show=python | recsel -p name,version
- name: python
- version: 2.7.6
-
- name: python
- version: 3.3.5
- @end example
-
- You may also specify the full name of a package to only get details about a
- specific version of it:
- @example
- $ guix package --show=python-3.3.5 | recsel -p name,version
- name: python
- version: 3.3.5
- @end example
-
-
-
- @item --list-installed[=@var{regexp}]
- @itemx -I [@var{regexp}]
- List the currently installed packages in the specified profile, with the
- most recently installed packages shown last. When @var{regexp} is
- specified, list only installed packages whose name matches @var{regexp}.
-
- For each installed package, print the following items, separated by
- tabs: the package name, its version string, the part of the package that
- is installed (for instance, @code{out} for the default output,
- @code{include} for its headers, etc.), and the path of this package in
- the store.
-
- @item --list-available[=@var{regexp}]
- @itemx -A [@var{regexp}]
- List packages currently available in the distribution for this system
- (@pxref{GNU Distribution}). When @var{regexp} is specified, list only
- installed packages whose name matches @var{regexp}.
-
- For each package, print the following items separated by tabs: its name,
- its version string, the parts of the package (@pxref{Packages with
- Multiple Outputs}), and the source location of its definition.
-
- @item --list-generations[=@var{pattern}]
- @itemx -l [@var{pattern}]
- Return a list of generations along with their creation dates; for each
- generation, show the installed packages, with the most recently
- installed packages shown last. Note that the zeroth generation is never
- shown.
-
- For each installed package, print the following items, separated by
- tabs: the name of a package, its version string, the part of the package
- that is installed (@pxref{Packages with Multiple Outputs}), and the
- location of this package in the store.
-
- When @var{pattern} is used, the command returns only matching
- generations. Valid patterns include:
-
- @itemize
- @item @emph{Integers and comma-separated integers}. Both patterns denote
- generation numbers. For instance, @code{--list-generations=1} returns
- the first one.
-
- And @code{--list-generations=1,8,2} outputs three generations in the
- specified order. Neither spaces nor trailing commas are allowed.
-
- @item @emph{Ranges}. @code{--list-generations=2..9} prints the
- specified generations and everything in between. Note that the start of
- a range must be lesser than its end.
-
- It is also possible to omit the endpoint. For example,
- @code{--list-generations=2..}, returns all generations starting from the
- second one.
-
- @item @emph{Durations}. You can also get the last @emph{N}@tie{}days, weeks,
- or months by passing an integer along with the first letter of the
- duration. For example, @code{--list-generations=20d} lists generations
- that are up to 20 days old.
- @end itemize
-
- @item --delete-generations[=@var{pattern}]
- @itemx -d [@var{pattern}]
- When @var{pattern} is omitted, delete all generations except the current
- one.
-
- This command accepts the same patterns as @option{--list-generations}.
- When @var{pattern} is specified, delete the matching generations. When
- @var{pattern} specifies a duration, generations @emph{older} than the
- specified duration match. For instance, @code{--delete-generations=1m}
- deletes generations that are more than one month old.
-
- If the current generation matches, it is @emph{not} deleted. Also, the
- zeroth generation is never deleted.
-
- Note that deleting generations prevents roll-back to them.
- Consequently, this command must be used with care.
-
- @end table
-
- Finally, since @command{guix package} may actually start build
- processes, it supports all the common build options that @command{guix
- build} supports (@pxref{Invoking guix build, common build options}).
-
- @include emacs.texi
-
- @node Substitutes
- @section Substitutes
-
- @cindex substitutes
- @cindex pre-built binaries
- Guix supports transparent source/binary deployment, which means that it
- can either build things locally, or download pre-built items from a
- server. We call these pre-built items @dfn{substitutes}---they are
- substitutes for local build results. In many cases, downloading a
- substitute is much faster than building things locally.
-
- Substitutes can be anything resulting from a derivation build
- (@pxref{Derivations}). Of course, in the common case, they are
- pre-built package binaries, but source tarballs, for instance, which
- also result from derivation builds, can be available as substitutes.
-
- The @code{hydra.gnu.org} server is a front-end to a build farm that
- builds packages from the GNU distribution continuously for some
- architectures, and makes them available as substitutes. This is the
- default source of substitutes; it can be overridden by passing
- @command{guix-daemon} the @code{--substitute-urls} option
- (@pxref{Invoking guix-daemon}).
-
- @cindex security
- @cindex digital signatures
- To allow Guix to download substitutes from @code{hydra.gnu.org}, you
- must add its public key to the access control list (ACL) of archive
- imports, using the @command{guix archive} command (@pxref{Invoking guix
- archive}). Doing so implies that you trust @code{hydra.gnu.org} to not
- be compromised and to serve genuine substitutes.
-
- This public key is installed along with Guix, in
- @code{@var{prefix}/share/guix/hydra.gnu.org.pub}, where @var{prefix} is
- the installation prefix of Guix. If you installed Guix from source,
- make sure you checked the GPG signature of
- @file{guix-@value{VERSION}.tar.gz}, which contains this public key file.
- Then, you can run something like this:
-
- @example
- # guix archive --authorize < hydra.gnu.org.pub
- @end example
-
- Once this is in place, the output of a command like @code{guix build}
- should change from something like:
-
- @example
- $ guix build emacs --dry-run
- The following derivations would be built:
- /gnu/store/yr7bnx8xwcayd6j95r2clmkdl1qh688w-emacs-24.3.drv
- /gnu/store/x8qsh1hlhgjx6cwsjyvybnfv2i37z23w-dbus-1.6.4.tar.gz.drv
- /gnu/store/1ixwp12fl950d15h2cj11c73733jay0z-alsa-lib-1.0.27.1.tar.bz2.drv
- /gnu/store/nlma1pw0p603fpfiqy7kn4zm105r5dmw-util-linux-2.21.drv
- @dots{}
- @end example
-
- @noindent
- to something like:
-
- @example
- $ guix build emacs --dry-run
- The following files would be downloaded:
- /gnu/store/pk3n22lbq6ydamyymqkkz7i69wiwjiwi-emacs-24.3
- /gnu/store/2ygn4ncnhrpr61rssa6z0d9x22si0va3-libjpeg-8d
- /gnu/store/71yz6lgx4dazma9dwn2mcjxaah9w77jq-cairo-1.12.16
- /gnu/store/7zdhgp0n1518lvfn8mb96sxqfmvqrl7v-libxrender-0.9.7
- @dots{}
- @end example
-
- @noindent
- This indicates that substitutes from @code{hydra.gnu.org} are usable and
- will be downloaded, when possible, for future builds.
-
- Guix ignores substitutes that are not signed, or that are not signed by
- one of the keys listed in the ACL. It also detects and raises an error
- when attempting to use a substitute that has been tampered with.
-
- The substitute mechanism can be disabled globally by running
- @code{guix-daemon} with @code{--no-substitutes} (@pxref{Invoking
- guix-daemon}). It can also be disabled temporarily by passing the
- @code{--no-substitutes} option to @command{guix package}, @command{guix
- build}, and other command-line tools.
-
-
- Today, each individual's control over their own computing is at the
- mercy of institutions, corporations, and groups with enough power and
- determination to subvert the computing infrastructure and exploit its
- weaknesses. While using @code{hydra.gnu.org} substitutes can be
- convenient, we encourage users to also build on their own, or even run
- their own build farm, such that @code{hydra.gnu.org} is less of an
- interesting target. One way to help is by publishing the software you
- build using @command{guix publish} so that others have one more choice
- of server to download substitutes from (@pxref{Invoking guix publish}).
-
- Guix has the foundations to maximize build reproducibility
- (@pxref{Features}). In most cases, independent builds of a given
- package or derivation should yield bit-identical results. Thus, through
- a diverse set of independent package builds, we can strengthen the
- integrity of our systems.
-
- In the future, we want Guix to have support to publish and retrieve
- binaries to/from other users, in a peer-to-peer fashion. If you would
- like to discuss this project, join us on @email{guix-devel@@gnu.org}.
-
-
- @node Packages with Multiple Outputs
- @section Packages with Multiple Outputs
-
- @cindex multiple-output packages
- @cindex package outputs
-
- Often, packages defined in Guix have a single @dfn{output}---i.e., the
- source package leads exactly one directory in the store. When running
- @command{guix package -i glibc}, one installs the default output of the
- GNU libc package; the default output is called @code{out}, but its name
- can be omitted as shown in this command. In this particular case, the
- default output of @code{glibc} contains all the C header files, shared
- libraries, static libraries, Info documentation, and other supporting
- files.
-
- Sometimes it is more appropriate to separate the various types of files
- produced from a single source package into separate outputs. For
- instance, the GLib C library (used by GTK+ and related packages)
- installs more than 20 MiB of reference documentation as HTML pages.
- To save space for users who do not need it, the documentation goes to a
- separate output, called @code{doc}. To install the main GLib output,
- which contains everything but the documentation, one would run:
-
- @example
- guix package -i glib
- @end example
-
- The command to install its documentation is:
-
- @example
- guix package -i glib:doc
- @end example
-
- Some packages install programs with different ``dependency footprints''.
- For instance, the WordNet package install both command-line tools and
- graphical user interfaces (GUIs). The former depend solely on the C
- library, whereas the latter depend on Tcl/Tk and the underlying X
- libraries. In this case, we leave the command-line tools in the default
- output, whereas the GUIs are in a separate output. This allows users
- who do not need the GUIs to save space.
-
- There are several such multiple-output packages in the GNU distribution.
- Other conventional output names include @code{lib} for libraries and
- possibly header files, @code{bin} for stand-alone programs, and
- @code{debug} for debugging information (@pxref{Installing Debugging
- Files}). The outputs of a packages are listed in the third column of
- the output of @command{guix package --list-available} (@pxref{Invoking
- guix package}).
-
-
- @node Invoking guix gc
- @section Invoking @command{guix gc}
-
- @cindex garbage collector
- Packages that are installed but not used may be @dfn{garbage-collected}.
- The @command{guix gc} command allows users to explicitly run the garbage
- collector to reclaim space from the @file{/gnu/store} directory. It is
- the @emph{only} way to remove files from @file{/gnu/store}---removing
- files or directories manually may break it beyond repair!
-
- The garbage collector has a set of known @dfn{roots}: any file under
- @file{/gnu/store} reachable from a root is considered @dfn{live} and
- cannot be deleted; any other file is considered @dfn{dead} and may be
- deleted. The set of garbage collector roots includes default user
- profiles, and may be augmented with @command{guix build --root}, for
- example (@pxref{Invoking guix build}).
-
- Prior to running @code{guix gc --collect-garbage} to make space, it is
- often useful to remove old generations from user profiles; that way, old
- package builds referenced by those generations can be reclaimed. This
- is achieved by running @code{guix package --delete-generations}
- (@pxref{Invoking guix package}).
-
- The @command{guix gc} command has three modes of operation: it can be
- used to garbage-collect any dead files (the default), to delete specific
- files (the @code{--delete} option), to print garbage-collector
- information, or for more advanced queries. The garbage collection
- options are as follows:
-
- @table @code
- @item --collect-garbage[=@var{min}]
- @itemx -C [@var{min}]
- Collect garbage---i.e., unreachable @file{/gnu/store} files and
- sub-directories. This is the default operation when no option is
- specified.
-
- When @var{min} is given, stop once @var{min} bytes have been collected.
- @var{min} may be a number of bytes, or it may include a unit as a
- suffix, such as @code{MiB} for mebibytes and @code{GB} for gigabytes
- (@pxref{Block size, size specifications,, coreutils, GNU Coreutils}).
-
- When @var{min} is omitted, collect all the garbage.
-
- @item --delete
- @itemx -d
- Attempt to delete all the store files and directories specified as
- arguments. This fails if some of the files are not in the store, or if
- they are still live.
-
- @item --list-dead
- Show the list of dead files and directories still present in the
- store---i.e., files and directories no longer reachable from any root.
-
- @item --list-live
- Show the list of live store files and directories.
-
- @end table
-
- In addition, the references among existing store files can be queried:
-
- @table @code
-
- @item --references
- @itemx --referrers
- List the references (respectively, the referrers) of store files given
- as arguments.
-
- @item --requisites
- @itemx -R
- List the requisites of the store files passed as arguments. Requisites
- include the store files themselves, their references, and the references
- of these, recursively. In other words, the returned list is the
- @dfn{transitive closure} of the store files.
-
- @end table
-
- Lastly, the following options allow you to check the integrity of the
- store and to control disk usage.
-
- @table @option
-
- @item --verify[=@var{options}]
- @cindex integrity, of the store
- @cindex integrity checking
- Verify the integrity of the store.
-
- By default, make sure that all the store items marked as valid in the
- daemon's database actually exist in @file{/gnu/store}.
-
- When provided, @var{options} must a comma-separated list containing one
- or more of @code{contents} and @code{repair}.
-
- When passing @option{--verify=contents}, the daemon will compute the
- content hash of each store item and compare it against its hash in the
- database. Hash mismatches are reported as data corruptions. Because it
- traverses @emph{all the files in the store}, this command can take a
- long time, especially on systems with a slow disk drive.
-
- @cindex repairing the store
- Using @option{--verify=repair} or @option{--verify=contents,repair}
- causes the daemon to try to repair corrupt store items by fetching
- substitutes for them (@pxref{Substitutes}). Because repairing is not
- atomic, and thus potentially dangerous, it is available only to the
- system administrator.
-
- @item --optimize
- @cindex deduplication
- Optimize the store by hard-linking identical files---this is
- @dfn{deduplication}.
-
- The daemon performs deduplication after each successful build or archive
- import, unless it was started with @code{--disable-deduplication}
- (@pxref{Invoking guix-daemon, @code{--disable-deduplication}}). Thus,
- this option is primarily useful when the daemon was running with
- @code{--disable-deduplication}.
-
- @end table
-
- @node Invoking guix pull
- @section Invoking @command{guix pull}
-
- Packages are installed or upgraded to the latest version available in
- the distribution currently available on your local machine. To update
- that distribution, along with the Guix tools, you must run @command{guix
- pull}: the command downloads the latest Guix source code and package
- descriptions, and deploys it.
-
- On completion, @command{guix package} will use packages and package
- versions from this just-retrieved copy of Guix. Not only that, but all
- the Guix commands and Scheme modules will also be taken from that latest
- version. New @command{guix} sub-commands added by the update also
- become available.
-
- The @command{guix pull} command is usually invoked with no arguments,
- but it supports the following options:
-
- @table @code
- @item --verbose
- Produce verbose output, writing build logs to the standard error output.
-
- @item --url=@var{url}
- Download the source tarball of Guix from @var{url}.
-
- By default, the tarball is taken from its canonical address at
- @code{gnu.org}, for the stable branch of Guix.
-
- @item --bootstrap
- Use the bootstrap Guile to build the latest Guix. This option is only
- useful to Guix developers.
- @end table
-
-
- @node Invoking guix archive
- @section Invoking @command{guix archive}
-
- The @command{guix archive} command allows users to @dfn{export} files
- from the store into a single archive, and to later @dfn{import} them.
- In particular, it allows store files to be transferred from one machine
- to another machine's store. For example, to transfer the @code{emacs}
- package to a machine connected over SSH, one would run:
-
- @example
- guix archive --export -r emacs | ssh the-machine guix archive --import
- @end example
-
- @noindent
- Similarly, a complete user profile may be transferred from one machine
- to another like this:
-
- @example
- guix archive --export -r $(readlink -f ~/.guix-profile) | \
- ssh the-machine guix-archive --import
- @end example
-
- @noindent
- However, note that, in both examples, all of @code{emacs} and the
- profile as well as all of their dependencies are transferred (due to
- @code{-r}), regardless of what is already available in the target
- machine's store. The @code{--missing} option can help figure out which
- items are missing from the target's store.
-
- Archives are stored in the ``Nix archive'' or ``Nar'' format, which is
- comparable in spirit to `tar', but with a few noteworthy differences
- that make it more appropriate for our purposes. First, rather than
- recording all Unix meta-data for each file, the Nar format only mentions
- the file type (regular, directory, or symbolic link); Unix permissions
- and owner/group are dismissed. Second, the order in which directory
- entries are stored always follows the order of file names according to
- the C locale collation order. This makes archive production fully
- deterministic.
-
- When exporting, the daemon digitally signs the contents of the archive,
- and that digital signature is appended. When importing, the daemon
- verifies the signature and rejects the import in case of an invalid
- signature or if the signing key is not authorized.
- @c FIXME: Add xref to daemon doc about signatures.
-
- The main options are:
-
- @table @code
- @item --export
- Export the specified store files or packages (see below.) Write the
- resulting archive to the standard output.
-
- Dependencies are @emph{not} included in the output, unless
- @code{--recursive} is passed.
-
- @item -r
- @itemx --recursive
- When combined with @code{--export}, this instructs @command{guix
- archive} to include dependencies of the given items in the archive.
- Thus, the resulting archive is self-contained: it contains the closure
- of the exported store items.
-
- @item --import
- Read an archive from the standard input, and import the files listed
- therein into the store. Abort if the archive has an invalid digital
- signature, or if it is signed by a public key not among the authorized
- keys (see @code{--authorize} below.)
-
- @item --missing
- Read a list of store file names from the standard input, one per line,
- and write on the standard output the subset of these files missing from
- the store.
-
- @item --generate-key[=@var{parameters}]
- @cindex signing, archives
- Generate a new key pair for the daemons. This is a prerequisite before
- archives can be exported with @code{--export}. Note that this operation
- usually takes time, because it needs to gather enough entropy to
- generate the key pair.
-
- The generated key pair is typically stored under @file{/etc/guix}, in
- @file{signing-key.pub} (public key) and @file{signing-key.sec} (private
- key, which must be kept secret.) When @var{parameters} is omitted,
- an ECDSA key using the Ed25519 curve is generated, or, for Libgcrypt
- versions before 1.6.0, it is a 4096-bit RSA key.
- Alternately, @var{parameters} can specify
- @code{genkey} parameters suitable for Libgcrypt (@pxref{General
- public-key related Functions, @code{gcry_pk_genkey},, gcrypt, The
- Libgcrypt Reference Manual}).
-
- @item --authorize
- @cindex authorizing, archives
- Authorize imports signed by the public key passed on standard input.
- The public key must be in ``s-expression advanced format''---i.e., the
- same format as the @file{signing-key.pub} file.
-
- The list of authorized keys is kept in the human-editable file
- @file{/etc/guix/acl}. The file contains
- @url{http://people.csail.mit.edu/rivest/Sexp.txt, ``advanced-format
- s-expressions''} and is structured as an access-control list in the
- @url{http://theworld.com/~cme/spki.txt, Simple Public-Key Infrastructure
- (SPKI)}.
- @end table
-
- To export store files as an archive to the standard output, run:
-
- @example
- guix archive --export @var{options} @var{specifications}...
- @end example
-
- @var{specifications} may be either store file names or package
- specifications, as for @command{guix package} (@pxref{Invoking guix
- package}). For instance, the following command creates an archive
- containing the @code{gui} output of the @code{git} package and the main
- output of @code{emacs}:
-
- @example
- guix archive --export git:gui /gnu/store/...-emacs-24.3 > great.nar
- @end example
-
- If the specified packages are not built yet, @command{guix archive}
- automatically builds them. The build process may be controlled with the
- same options that can be passed to the @command{guix build} command
- (@pxref{Invoking guix build, common build options}).
-
-
- @c *********************************************************************
- @node Programming Interface
- @chapter Programming Interface
-
- GNU Guix provides several Scheme programming interfaces (APIs) to
- define, build, and query packages. The first interface allows users to
- write high-level package definitions. These definitions refer to
- familiar packaging concepts, such as the name and version of a package,
- its build system, and its dependencies. These definitions can then be
- turned into concrete build actions.
-
- Build actions are performed by the Guix daemon, on behalf of users. In a
- standard setup, the daemon has write access to the store---the
- @file{/gnu/store} directory---whereas users do not. The recommended
- setup also has the daemon perform builds in chroots, under a specific
- build users, to minimize interference with the rest of the system.
-
- @cindex derivation
- Lower-level APIs are available to interact with the daemon and the
- store. To instruct the daemon to perform a build action, users actually
- provide it with a @dfn{derivation}. A derivation is a low-level
- representation of the build actions to be taken, and the environment in
- which they should occur---derivations are to package definitions what
- assembly is to C programs. The term ``derivation'' comes from the fact
- that build results @emph{derive} from them.
-
- This chapter describes all these APIs in turn, starting from high-level
- package definitions.
-
- @menu
- * Defining Packages:: Defining new packages.
- * Build Systems:: Specifying how packages are built.
- * The Store:: Manipulating the package store.
- * Derivations:: Low-level interface to package derivations.
- * The Store Monad:: Purely functional interface to the store.
- * G-Expressions:: Manipulating build expressions.
- @end menu
-
- @node Defining Packages
- @section Defining Packages
-
- The high-level interface to package definitions is implemented in the
- @code{(guix packages)} and @code{(guix build-system)} modules. As an
- example, the package definition, or @dfn{recipe}, for the GNU Hello
- package looks like this:
-
- @example
- (define-module (gnu packages hello)
- #:use-module (guix packages)
- #:use-module (guix download)
- #:use-module (guix build-system gnu)
- #:use-module (guix licenses))
-
- (define-public hello
- (package
- (name "hello")
- (version "2.8")
- (source (origin
- (method url-fetch)
- (uri (string-append "mirror://gnu/hello/hello-" version
- ".tar.gz"))
- (sha256
- (base32 "0wqd8sjmxfskrflaxywc7gqw7sfawrfvdxd9skxawzfgyy0pzdz6"))))
- (build-system gnu-build-system)
- (arguments `(#:configure-flags '("--enable-silent-rules")))
- (inputs `(("gawk" ,gawk)))
- (synopsis "Hello, GNU world: An example GNU package")
- (description "Guess what GNU Hello prints!")
- (home-page "http://www.gnu.org/software/hello/")
- (license gpl3+)))
- @end example
-
- @noindent
- Without being a Scheme expert, the reader may have guessed the meaning
- of the various fields here. This expression binds variable @code{hello}
- to a @code{<package>} object, which is essentially a record
- (@pxref{SRFI-9, Scheme records,, guile, GNU Guile Reference Manual}).
- This package object can be inspected using procedures found in the
- @code{(guix packages)} module; for instance, @code{(package-name hello)}
- returns---surprise!---@code{"hello"}.
-
- With luck, you may be able to import part or all of the definition of
- the package you are interested in from another repository, using the
- @code{guix import} command (@pxref{Invoking guix import}).
-
- In the example above, @var{hello} is defined into a module of its own,
- @code{(gnu packages hello)}. Technically, this is not strictly
- necessary, but it is convenient to do so: all the packages defined in
- modules under @code{(gnu packages @dots{})} are automatically known to
- the command-line tools (@pxref{Package Modules}).
-
- There are a few points worth noting in the above package definition:
-
- @itemize
- @item
- The @code{source} field of the package is an @code{<origin>} object
- (@pxref{origin Reference}, for the complete reference).
- Here, the @code{url-fetch} method from @code{(guix download)} is used,
- meaning that the source is a file to be downloaded over FTP or HTTP.
-
- The @code{mirror://gnu} prefix instructs @code{url-fetch} to use one of
- the GNU mirrors defined in @code{(guix download)}.
-
- The @code{sha256} field specifies the expected SHA256 hash of the file
- being downloaded. It is mandatory, and allows Guix to check the
- integrity of the file. The @code{(base32 @dots{})} form introduces the
- base32 representation of the hash. You can obtain this information with
- @code{guix download} (@pxref{Invoking guix download}) and @code{guix
- hash} (@pxref{Invoking guix hash}).
-
- @cindex patches
- When needed, the @code{origin} form can also have a @code{patches} field
- listing patches to be applied, and a @code{snippet} field giving a
- Scheme expression to modify the source code.
-
- @item
- @cindex GNU Build System
- The @code{build-system} field specifies the procedure to build the
- package (@pxref{Build Systems}). Here, @var{gnu-build-system}
- represents the familiar GNU Build System, where packages may be
- configured, built, and installed with the usual @code{./configure &&
- make && make check && make install} command sequence.
-
- @item
- The @code{arguments} field specifies options for the build system
- (@pxref{Build Systems}). Here it is interpreted by
- @var{gnu-build-system} as a request run @file{configure} with the
- @code{--enable-silent-rules} flag.
-
- @item
- The @code{inputs} field specifies inputs to the build process---i.e.,
- build-time or run-time dependencies of the package. Here, we define an
- input called @code{"gawk"} whose value is that of the @var{gawk}
- variable; @var{gawk} is itself bound to a @code{<package>} object.
-
- Note that GCC, Coreutils, Bash, and other essential tools do not need to
- be specified as inputs here. Instead, @var{gnu-build-system} takes care
- of ensuring that they are present (@pxref{Build Systems}).
-
- However, any other dependencies need to be specified in the
- @code{inputs} field. Any dependency not specified here will simply be
- unavailable to the build process, possibly leading to a build failure.
- @end itemize
-
- @xref{package Reference}, for a full description of possible fields.
-
- Once a package definition is in place, the
- package may actually be built using the @code{guix build} command-line
- tool (@pxref{Invoking guix build}). @xref{Packaging Guidelines}, for
- more information on how to test package definitions, and
- @ref{Invoking guix lint}, for information on how to check a definition
- for style conformance.
-
- Eventually, updating the package definition to a new upstream version
- can be partly automated by the @command{guix refresh} command
- (@pxref{Invoking guix refresh}).
-
- Behind the scenes, a derivation corresponding to the @code{<package>}
- object is first computed by the @code{package-derivation} procedure.
- That derivation is stored in a @code{.drv} file under @file{/gnu/store}.
- The build actions it prescribes may then be realized by using the
- @code{build-derivations} procedure (@pxref{The Store}).
-
- @deffn {Scheme Procedure} package-derivation @var{store} @var{package} [@var{system}]
- Return the @code{<derivation>} object of @var{package} for @var{system}
- (@pxref{Derivations}).
-
- @var{package} must be a valid @code{<package>} object, and @var{system}
- must be a string denoting the target system type---e.g.,
- @code{"x86_64-linux"} for an x86_64 Linux-based GNU system. @var{store}
- must be a connection to the daemon, which operates on the store
- (@pxref{The Store}).
- @end deffn
-
- @noindent
- @cindex cross-compilation
- Similarly, it is possible to compute a derivation that cross-builds a
- package for some other system:
-
- @deffn {Scheme Procedure} package-cross-derivation @var{store} @
- @var{package} @var{target} [@var{system}]
- Return the @code{<derivation>} object of @var{package} cross-built from
- @var{system} to @var{target}.
-
- @var{target} must be a valid GNU triplet denoting the target hardware
- and operating system, such as @code{"mips64el-linux-gnu"}
- (@pxref{Configuration Names, GNU configuration triplets,, configure, GNU
- Configure and Build System}).
- @end deffn
-
- @menu
- * package Reference :: The package data type.
- * origin Reference:: The origin data type.
- @end menu
-
-
- @node package Reference
- @subsection @code{package} Reference
-
- This section summarizes all the options available in @code{package}
- declarations (@pxref{Defining Packages}).
-
- @deftp {Data Type} package
- This is the data type representing a package recipe.
-
- @table @asis
- @item @code{name}
- The name of the package, as a string.
-
- @item @code{version}
- The version of the package, as a string.
-
- @item @code{source}
- An origin object telling how the source code for the package should be
- acquired (@pxref{origin Reference}).
-
- @item @code{build-system}
- The build system that should be used to build the package (@pxref{Build
- Systems}).
-
- @item @code{arguments} (default: @code{'()})
- The arguments that should be passed to the build system. This is a
- list, typically containing sequential keyword-value pairs.
-
- @item @code{inputs} (default: @code{'()})
- Package or derivation inputs to the build. This is a list of lists,
- where each list has the name of the input (a string) as its first
- element, a package or derivation object as its second element, and
- optionally the name of the output of the package or derivation that
- should be used, which defaults to @code{"out"}.
-
- @item @anchor{package-propagated-inputs}@code{propagated-inputs} (default: @code{'()})
- @cindex propagated inputs
- This field is like @code{inputs}, but the specified packages will be
- force-installed alongside the package they belong to
- (@pxref{package-cmd-propagated-inputs, @command{guix package}}, for
- information on how @command{guix package} deals with propagated inputs.)
-
- For example this is necessary when a library needs headers of another
- library to compile, or needs another shared library to be linked
- alongside itself when a program wants to link to it.
-
- @item @code{native-inputs} (default: @code{'()})
- This field is like @code{inputs}, but in case of a cross-compilation it
- will be ensured that packages for the architecture of the build machine
- are present, such that executables from them can be used during the
- build.
-
- This is typically where you would list tools needed at build time but
- not at run time, such as Autoconf, Automake, pkg-config, Gettext, or
- Bison. @command{guix lint} can report likely mistakes in this area
- (@pxref{Invoking guix lint}).
-
- @item @code{self-native-input?} (default: @code{#f})
- This is a Boolean field telling whether the package should use itself as
- a native input when cross-compiling.
-
- @item @code{outputs} (default: @code{'("out")})
- The list of output names of the package. @xref{Packages with Multiple
- Outputs}, for typical uses of additional outputs.
-
- @item @code{native-search-paths} (default: @code{'()})
- @itemx @code{search-paths} (default: @code{'()})
- A list of @code{search-path-specification} objects describing
- search-path environment variables honored by the package.
-
- @item @code{replacement} (default: @code{#f})
- This must either @code{#f} or a package object that will be used as a
- @dfn{replacement} for this package. @xref{Security Updates, grafts},
- for details.
-
- @item @code{synopsis}
- A one-line description of the package.
-
- @item @code{description}
- A more elaborate description of the package.
-
- @item @code{license}
- The license of the package; a value from @code{(guix licenses)}.
-
- @item @code{home-page}
- The URL to the home-page of the package, as a string.
-
- @item @code{supported-systems} (default: @var{%supported-systems})
- The list of systems supported by the package, as strings of the form
- @code{architecture-kernel}, for example @code{"x86_64-linux"}.
-
- @item @code{maintainers} (default: @code{'()})
- The list of maintainers of the package, as @code{maintainer} objects.
-
- @item @code{location} (default: source location of the @code{package} form)
- The source location of the package. It's useful to override this when
- inheriting from another package, in which case this field is not
- automatically corrected.
- @end table
- @end deftp
-
-
- @node origin Reference
- @subsection @code{origin} Reference
-
- This section summarizes all the options available in @code{origin}
- declarations (@pxref{Defining Packages}).
-
- @deftp {Data Type} origin
- This is the data type representing a source code origin.
-
- @table @asis
- @item @code{uri}
- An object containing the URI of the source. The object type depends on
- the @code{method} (see below). For example, when using the
- @var{url-fetch} method of @code{(guix download)}, the valid @code{uri}
- values are: a URL represented as a string, or a list thereof.
-
- @item @code{method}
- A procedure that will handle the URI.
-
- Examples include:
-
- @table @asis
- @item @var{url-fetch} from @code{(guix download)}
- download a file the HTTP, HTTPS, or FTP URL specified in the
- @code{uri} field;
-
- @item @var{git-fetch} from @code{(guix git-download)}
- clone the Git version control repository, and check out the revision
- specified in the @code{uri} field as a @code{git-reference} object; a
- @code{git-reference} looks like this:
-
- @example
- (git-reference
- (url "git://git.debian.org/git/pkg-shadow/shadow")
- (commit "v4.1.5.1"))
- @end example
- @end table
-
- @item @code{sha256}
- A bytevector containing the SHA-256 hash of the source. Typically the
- @code{base32} form is used here to generate the bytevector from a
- base-32 string.
-
- @item @code{file-name} (default: @code{#f})
- The file name under which the source code should be saved. When this is
- @code{#f}, a sensible default value will be used in most cases. In case
- the source is fetched from a URL, the file name from the URL will be
- used. For version control checkouts, it's recommended to provide the
- file name explicitly because the default is not very descriptive.
-
- @item @code{patches} (default: @code{'()})
- A list of file names containing patches to be applied to the source.
-
- @item @code{snippet} (default: @code{#f})
- A quoted piece of code that will be run in the source directory to make
- any modifications, which is sometimes more convenient than a patch.
-
- @item @code{patch-flags} (default: @code{'("-p1")})
- A list of command-line flags that should be passed to the @code{patch}
- command.
-
- @item @code{patch-inputs} (default: @code{#f})
- Input packages or derivations to the patching process. When this is
- @code{#f}, the usual set of inputs necessary for patching are provided,
- such as GNU@tie{}Patch.
-
- @item @code{modules} (default: @code{'()})
- A list of Guile modules that should be loaded during the patching
- process and while running the code in the @code{snippet} field.
-
- @item @code{imported-modules} (default: @code{'()})
- The list of Guile modules to import in the patch derivation, for use by
- the @code{snippet}.
-
- @item @code{patch-guile} (default: @code{#f})
- The Guile package that should be used in the patching process. When
- this is @code{#f}, a sensible default is used.
- @end table
- @end deftp
-
-
- @node Build Systems
- @section Build Systems
-
- @cindex build system
- Each package definition specifies a @dfn{build system} and arguments for
- that build system (@pxref{Defining Packages}). This @code{build-system}
- field represents the build procedure of the package, as well implicit
- dependencies of that build procedure.
-
- Build systems are @code{<build-system>} objects. The interface to
- create and manipulate them is provided by the @code{(guix build-system)}
- module, and actual build systems are exported by specific modules.
-
- @cindex bag (low-level package representation)
- Under the hood, build systems first compile package objects to
- @dfn{bags}. A @dfn{bag} is like a package, but with less
- ornamentation---in other words, a bag is a lower-level representation of
- a package, which includes all the inputs of that package, including some
- that were implicitly added by the build system. This intermediate
- representation is then compiled to a derivation (@pxref{Derivations}).
-
- Build systems accept an optional list of @dfn{arguments}. In package
- definitions, these are passed @i{via} the @code{arguments} field
- (@pxref{Defining Packages}). They are typically keyword arguments
- (@pxref{Optional Arguments, keyword arguments in Guile,, guile, GNU
- Guile Reference Manual}). The value of these arguments is usually
- evaluated in the @dfn{build stratum}---i.e., by a Guile process launched
- by the daemon (@pxref{Derivations}).
-
- The main build system is @var{gnu-build-system}, which implements the
- standard build procedure for GNU packages and many other packages. It
- is provided by the @code{(guix build-system gnu)} module.
-
- @defvr {Scheme Variable} gnu-build-system
- @var{gnu-build-system} represents the GNU Build System, and variants
- thereof (@pxref{Configuration, configuration and makefile conventions,,
- standards, GNU Coding Standards}).
-
- @cindex build phases
- In a nutshell, packages using it configured, built, and installed with
- the usual @code{./configure && make && make check && make install}
- command sequence. In practice, a few additional steps are often needed.
- All these steps are split up in separate @dfn{phases},
- notably@footnote{Please see the @code{(guix build gnu-build-system)}
- modules for more details about the build phases.}:
-
- @table @code
- @item unpack
- Unpack the source tarball, and change the current directory to the
- extracted source tree. If the source is actually a directory, copy it
- to the build tree, and enter that directory.
-
- @item patch-source-shebangs
- Patch shebangs encountered in source files so they refer to the right
- store file names. For instance, this changes @code{#!/bin/sh} to
- @code{#!/gnu/store/@dots{}-bash-4.3/bin/sh}.
-
- @item configure
- Run the @file{configure} script with a number of default options, such
- as @code{--prefix=/gnu/store/@dots{}}, as well as the options specified
- by the @code{#:configure-flags} argument.
-
- @item build
- Run @code{make} with the list of flags specified with
- @code{#:make-flags}. If the @code{#:parallel-builds?} argument is true
- (the default), build with @code{make -j}.
-
- @item check
- Run @code{make check}, or some other target specified with
- @code{#:test-target}, unless @code{#:tests? #f} is passed. If the
- @code{#:parallel-tests?} argument is true (the default), run @code{make
- check -j}.
-
- @item install
- Run @code{make install} with the flags listed in @code{#:make-flags}.
-
- @item patch-shebangs
- Patch shebangs on the installed executable files.
-
- @item strip
- Strip debugging symbols from ELF files (unless @code{#:strip-binaries?}
- is false), copying them to the @code{debug} output when available
- (@pxref{Installing Debugging Files}).
- @end table
-
- @vindex %standard-phases
- The build-side module @code{(guix build gnu-build-system)} defines
- @var{%standard-phases} as the default list of build phases.
- @var{%standard-phases} is a list of symbol/procedure pairs, where the
- procedure implements the actual phase.
-
- The list of phases used for a particular package can be changed with the
- @code{#:phases} parameter. For instance, passing:
-
- @example
- #:phases (alist-delete 'configure %standard-phases)
- @end example
-
- means that all the phases described above will be used, except the
- @code{configure} phase.
-
- In addition, this build system ensures that the ``standard'' environment
- for GNU packages is available. This includes tools such as GCC, libc,
- Coreutils, Bash, Make, Diffutils, grep, and sed (see the @code{(guix
- build-system gnu)} module for a complete list.) We call these the
- @dfn{implicit inputs} of a package, because package definitions don't
- have to mention them.
- @end defvr
-
- Other @code{<build-system>} objects are defined to support other
- conventions and tools used by free software packages. They inherit most
- of @var{gnu-build-system}, and differ mainly in the set of inputs
- implicitly added to the build process, and in the list of phases
- executed. Some of these build systems are listed below.
-
- @defvr {Scheme Variable} cmake-build-system
- This variable is exported by @code{(guix build-system cmake)}. It
- implements the build procedure for packages using the
- @url{http://www.cmake.org, CMake build tool}.
-
- It automatically adds the @code{cmake} package to the set of inputs.
- Which package is used can be specified with the @code{#:cmake}
- parameter.
-
- The @code{#:configure-flags} parameter is taken as a list of flags
- passed to the @command{cmake} command. The @code{#:build-type}
- parameter specifies in abstract terms the flags passed to the compiler;
- it defaults to @code{"RelWithDebInfo"} (short for ``release mode with
- debugging information''), which roughly means that code is compiled with
- @code{-O2 -g}, as is the case for Autoconf-based packages by default.
- @end defvr
-
- @defvr {Scheme Variable} glib-or-gtk-build-system
- This variable is exported by @code{(guix build-system glib-or-gtk)}. It
- is intended for use with packages making use of GLib or GTK+.
-
- This build system adds the following two phases to the ones defined by
- @var{gnu-build-system}:
-
- @table @code
- @item glib-or-gtk-wrap
- The phase @code{glib-or-gtk-wrap} ensures that programs found under
- @file{bin/} are able to find GLib's ``schemas'' and
- @uref{https://developer.gnome.org/gtk3/stable/gtk-running.html, GTK+
- modules}. This is achieved by wrapping the programs in launch scripts
- that appropriately set the @code{XDG_DATA_DIRS} and @code{GTK_PATH}
- environment variables.
-
- It is possible to exclude specific package outputs from that wrapping
- process by listing their names in the
- @code{#:glib-or-gtk-wrap-excluded-outputs} parameter. This is useful
- when an output is known not to contain any GLib or GTK+ binaries, and
- where wrapping would gratuitously add a dependency of that output on
- GLib and GTK+.
-
- @item glib-or-gtk-compile-schemas
- The phase @code{glib-or-gtk-compile-schemas} makes sure that all GLib's
- @uref{https://developer.gnome.org/gio/stable/glib-compile-schemas.html,
- GSettings schemas} are compiled. Compilation is performed by the
- @command{glib-compile-schemas} program. It is provided by the package
- @code{glib:bin} which is automatically imported by the build system.
- The @code{glib} package providing @command{glib-compile-schemas} can be
- specified with the @code{#:glib} parameter.
- @end table
-
- Both phases are executed after the @code{install} phase.
- @end defvr
-
- @defvr {Scheme Variable} python-build-system
- This variable is exported by @code{(guix build-system python)}. It
- implements the more or less standard build procedure used by Python
- packages, which consists in running @code{python setup.py build} and
- then @code{python setup.py install --prefix=/gnu/store/@dots{}}.
-
- For packages that install stand-alone Python programs under @code{bin/},
- it takes care of wrapping these programs so their @code{PYTHONPATH}
- environment variable points to all the Python libraries they depend on.
-
- Which Python package is used can be specified with the @code{#:python}
- parameter.
- @end defvr
-
- @defvr {Scheme Variable} perl-build-system
- This variable is exported by @code{(guix build-system perl)}. It
- implements the standard build procedure for Perl packages, which either
- consists in running @code{perl Build.PL --prefix=/gnu/store/@dots{}},
- followed by @code{Build} and @code{Build install}; or in running
- @code{perl Makefile.PL PREFIX=/gnu/store/@dots{}}, followed by
- @code{make} and @code{make install}; depending on which of
- @code{Build.PL} or @code{Makefile.PL} is present in the package
- distribution. Preference is given to the former if both @code{Build.PL}
- and @code{Makefile.PL} exist in the package distribution. This
- preference can be reversed by specifying @code{#t} for the
- @code{#:make-maker?} parameter.
-
- The initial @code{perl Makefile.PL} or @code{perl Build.PL} invocation
- passes flags specified by the @code{#:make-maker-flags} or
- @code{#:module-build-flags} parameter, respectively.
-
- Which Perl package is used can be specified with @code{#:perl}.
- @end defvr
-
- @defvr {Scheme Variable} ruby-build-system
- This variable is exported by @code{(guix build-system ruby)}. It
- implements the RubyGems build procedure used by Ruby packages, which
- involves running @code{gem build} followed by @code{gem install}.
-
- Which Ruby package is used can be specified with the @code{#:ruby}
- parameter.
- @end defvr
-
- @defvr {Scheme Variable} waf-build-system
- This variable is exported by @code{(guix build-system waf)}. It
- implements a build procedure around the @code{waf} script. The common
- phases---@code{configure}, @code{build}, and @code{install}---are
- implemented by passing their names as arguments to the @code{waf}
- script.
-
- The @code{waf} script is executed by the Python interpreter. Which
- Python package is used to run the script can be specified with the
- @code{#:python} parameter.
- @end defvr
-
- @defvr {Scheme Variable} haskell-build-system
- This variable is exported by @code{(guix build-system haskell)}. It
- implements the Cabal build procedure used by Haskell packages, which
- involves running @code{runhaskell Setup.hs configure
- --prefix=/gnu/store/@dots{}} and @code{runhaskell Setup.hs build}.
- Instead of installing the package by running @code{runhaskell Setup.hs
- install}, to avoid trying to register libraries in the read-only
- compiler store directory, the build system uses @code{runhaskell
- Setup.hs copy}, followed by @code{runhaskell Setup.hs register}. In
- addition, the build system generates the package documentation by
- running @code{runhaskell Setup.hs haddock}, unless @code{#:haddock? #f}
- is passed. Optional Haddock parameters can be passed with the help of
- the @code{#:haddock-flags} parameter. If the file @code{Setup.hs} is
- not found, the build system looks for @code{Setup.lhs} instead.
-
- Which Haskell compiler is used can be specified with the @code{#:haskell}
- parameter which defaults to @code{ghc}.
- @end defvr
-
- Lastly, for packages that do not need anything as sophisticated, a
- ``trivial'' build system is provided. It is trivial in the sense that
- it provides basically no support: it does not pull any implicit inputs,
- and does not have a notion of build phases.
-
- @defvr {Scheme Variable} trivial-build-system
- This variable is exported by @code{(guix build-system trivial)}.
-
- This build system requires a @code{#:builder} argument. This argument
- must be a Scheme expression that builds the package's output(s)---as
- with @code{build-expression->derivation} (@pxref{Derivations,
- @code{build-expression->derivation}}).
- @end defvr
-
- @node The Store
- @section The Store
-
- @cindex store
- @cindex store paths
-
- Conceptually, the @dfn{store} is where derivations that have been
- successfully built are stored---by default, under @file{/gnu/store}.
- Sub-directories in the store are referred to as @dfn{store paths}. The
- store has an associated database that contains information such has the
- store paths referred to by each store path, and the list of @emph{valid}
- store paths---paths that result from a successful build.
-
- The store is always accessed by the daemon on behalf of its clients
- (@pxref{Invoking guix-daemon}). To manipulate the store, clients
- connect to the daemon over a Unix-domain socket, send it requests, and
- read the result---these are remote procedure calls, or RPCs.
-
- The @code{(guix store)} module provides procedures to connect to the
- daemon, and to perform RPCs. These are described below.
-
- @deffn {Scheme Procedure} open-connection [@var{file}] [#:reserve-space? #t]
- Connect to the daemon over the Unix-domain socket at @var{file}. When
- @var{reserve-space?} is true, instruct it to reserve a little bit of
- extra space on the file system so that the garbage collector can still
- operate, should the disk become full. Return a server object.
-
- @var{file} defaults to @var{%default-socket-path}, which is the normal
- location given the options that were passed to @command{configure}.
- @end deffn
-
- @deffn {Scheme Procedure} close-connection @var{server}
- Close the connection to @var{server}.
- @end deffn
-
- @defvr {Scheme Variable} current-build-output-port
- This variable is bound to a SRFI-39 parameter, which refers to the port
- where build and error logs sent by the daemon should be written.
- @end defvr
-
- Procedures that make RPCs all take a server object as their first
- argument.
-
- @deffn {Scheme Procedure} valid-path? @var{server} @var{path}
- Return @code{#t} when @var{path} is a valid store path.
- @end deffn
-
- @deffn {Scheme Procedure} add-text-to-store @var{server} @var{name} @var{text} [@var{references}]
- Add @var{text} under file @var{name} in the store, and return its store
- path. @var{references} is the list of store paths referred to by the
- resulting store path.
- @end deffn
-
- @deffn {Scheme Procedure} build-derivations @var{server} @var{derivations}
- Build @var{derivations} (a list of @code{<derivation>} objects or
- derivation paths), and return when the worker is done building them.
- Return @code{#t} on success.
- @end deffn
-
- Note that the @code{(guix monads)} module provides a monad as well as
- monadic versions of the above procedures, with the goal of making it
- more convenient to work with code that accesses the store (@pxref{The
- Store Monad}).
-
- @c FIXME
- @i{This section is currently incomplete.}
-
- @node Derivations
- @section Derivations
-
- @cindex derivations
- Low-level build actions and the environment in which they are performed
- are represented by @dfn{derivations}. A derivation contain the
- following pieces of information:
-
- @itemize
- @item
- The outputs of the derivation---derivations produce at least one file or
- directory in the store, but may produce more.
-
- @item
- The inputs of the derivations, which may be other derivations or plain
- files in the store (patches, build scripts, etc.)
-
- @item
- The system type targeted by the derivation---e.g., @code{x86_64-linux}.
-
- @item
- The file name of a build script in the store, along with the arguments
- to be passed.
-
- @item
- A list of environment variables to be defined.
-
- @end itemize
-
- @cindex derivation path
- Derivations allow clients of the daemon to communicate build actions to
- the store. They exist in two forms: as an in-memory representation,
- both on the client- and daemon-side, and as files in the store whose
- name end in @code{.drv}---these files are referred to as @dfn{derivation
- paths}. Derivations paths can be passed to the @code{build-derivations}
- procedure to perform the build actions they prescribe (@pxref{The
- Store}).
-
- The @code{(guix derivations)} module provides a representation of
- derivations as Scheme objects, along with procedures to create and
- otherwise manipulate derivations. The lowest-level primitive to create
- a derivation is the @code{derivation} procedure:
-
- @deffn {Scheme Procedure} derivation @var{store} @var{name} @var{builder} @
- @var{args} [#:outputs '("out")] [#:hash #f] [#:hash-algo #f] @
- [#:recursive? #f] [#:inputs '()] [#:env-vars '()] @
- [#:system (%current-system)] [#:references-graphs #f] @
- [#:allowed-references #f] [#:leaked-env-vars #f] [#:local-build? #f]
- Build a derivation with the given arguments, and return the resulting
- @code{<derivation>} object.
-
- When @var{hash} and @var{hash-algo} are given, a
- @dfn{fixed-output derivation} is created---i.e., one whose result is
- known in advance, such as a file download. If, in addition,
- @var{recursive?} is true, then that fixed output may be an executable
- file or a directory and @var{hash} must be the hash of an archive
- containing this output.
-
- When @var{references-graphs} is true, it must be a list of file
- name/store path pairs. In that case, the reference graph of each store
- path is exported in the build environment in the corresponding file, in
- a simple text format.
-
- When @var{allowed-references} is true, it must be a list of store items
- or outputs that the derivation's output may refer to.
-
- When @var{leaked-env-vars} is true, it must be a list of strings
- denoting environment variables that are allowed to ``leak'' from the
- daemon's environment to the build environment. This is only applicable
- to fixed-output derivations---i.e., when @var{hash} is true. The main
- use is to allow variables such as @code{http_proxy} to be passed to
- derivations that download files.
-
- When @var{local-build?} is true, declare that the derivation is not a
- good candidate for offloading and should rather be built locally
- (@pxref{Daemon Offload Setup}). This is the case for small derivations
- where the costs of data transfers would outweigh the benefits.
- @end deffn
-
- @noindent
- Here's an example with a shell script as its builder, assuming
- @var{store} is an open connection to the daemon, and @var{bash} points
- to a Bash executable in the store:
-
- @lisp
- (use-modules (guix utils)
- (guix store)
- (guix derivations))
-
- (let ((builder ; add the Bash script to the store
- (add-text-to-store store "my-builder.sh"
- "echo hello world > $out\n" '())))
- (derivation store "foo"
- bash `("-e" ,builder)
- #:inputs `((,bash) (,builder))
- #:env-vars '(("HOME" . "/homeless"))))
- @result{} #<derivation /gnu/store/@dots{}-foo.drv => /gnu/store/@dots{}-foo>
- @end lisp
-
- As can be guessed, this primitive is cumbersome to use directly. A
- better approach is to write build scripts in Scheme, of course! The
- best course of action for that is to write the build code as a
- ``G-expression'', and to pass it to @code{gexp->derivation}. For more
- information, @pxref{G-Expressions}.
-
- Once upon a time, @code{gexp->derivation} did not exist and constructing
- derivations with build code written in Scheme was achieved with
- @code{build-expression->derivation}, documented below. This procedure
- is now deprecated in favor of the much nicer @code{gexp->derivation}.
-
- @deffn {Scheme Procedure} build-expression->derivation @var{store} @
- @var{name} @var{exp} @
- [#:system (%current-system)] [#:inputs '()] @
- [#:outputs '("out")] [#:hash #f] [#:hash-algo #f] @
- [#:recursive? #f] [#:env-vars '()] [#:modules '()] @
- [#:references-graphs #f] [#:allowed-references #f] @
- [#:local-build? #f] [#:guile-for-build #f]
- Return a derivation that executes Scheme expression @var{exp} as a
- builder for derivation @var{name}. @var{inputs} must be a list of
- @code{(name drv-path sub-drv)} tuples; when @var{sub-drv} is omitted,
- @code{"out"} is assumed. @var{modules} is a list of names of Guile
- modules from the current search path to be copied in the store,
- compiled, and made available in the load path during the execution of
- @var{exp}---e.g., @code{((guix build utils) (guix build
- gnu-build-system))}.
-
- @var{exp} is evaluated in an environment where @code{%outputs} is bound
- to a list of output/path pairs, and where @code{%build-inputs} is bound
- to a list of string/output-path pairs made from @var{inputs}.
- Optionally, @var{env-vars} is a list of string pairs specifying the name
- and value of environment variables visible to the builder. The builder
- terminates by passing the result of @var{exp} to @code{exit}; thus, when
- @var{exp} returns @code{#f}, the build is considered to have failed.
-
- @var{exp} is built using @var{guile-for-build} (a derivation). When
- @var{guile-for-build} is omitted or is @code{#f}, the value of the
- @code{%guile-for-build} fluid is used instead.
-
- See the @code{derivation} procedure for the meaning of
- @var{references-graphs}, @var{allowed-references}, and @var{local-build?}.
- @end deffn
-
- @noindent
- Here's an example of a single-output derivation that creates a directory
- containing one file:
-
- @lisp
- (let ((builder '(let ((out (assoc-ref %outputs "out")))
- (mkdir out) ; create /gnu/store/@dots{}-goo
- (call-with-output-file (string-append out "/test")
- (lambda (p)
- (display '(hello guix) p))))))
- (build-expression->derivation store "goo" builder))
-
- @result{} #<derivation /gnu/store/@dots{}-goo.drv => @dots{}>
- @end lisp
-
-
- @node The Store Monad
- @section The Store Monad
-
- @cindex monad
-
- The procedures that operate on the store described in the previous
- sections all take an open connection to the build daemon as their first
- argument. Although the underlying model is functional, they either have
- side effects or depend on the current state of the store.
-
- The former is inconvenient: the connection to the build daemon has to be
- carried around in all those functions, making it impossible to compose
- functions that do not take that parameter with functions that do. The
- latter can be problematic: since store operations have side effects
- and/or depend on external state, they have to be properly sequenced.
-
- @cindex monadic values
- @cindex monadic functions
- This is where the @code{(guix monads)} module comes in. This module
- provides a framework for working with @dfn{monads}, and a particularly
- useful monad for our uses, the @dfn{store monad}. Monads are a
- construct that allows two things: associating ``context'' with values
- (in our case, the context is the store), and building sequences of
- computations (here computations include accesses to the store.) Values
- in a monad---values that carry this additional context---are called
- @dfn{monadic values}; procedures that return such values are called
- @dfn{monadic procedures}.
-
- Consider this ``normal'' procedure:
-
- @example
- (define (sh-symlink store)
- ;; Return a derivation that symlinks the 'bash' executable.
- (let* ((drv (package-derivation store bash))
- (out (derivation->output-path drv))
- (sh (string-append out "/bin/bash")))
- (build-expression->derivation store "sh"
- `(symlink ,sh %output))))
- @end example
-
- Using @code{(guix monads)} and @code{(guix gexp)}, it may be rewritten
- as a monadic function:
-
- @example
- (define (sh-symlink)
- ;; Same, but return a monadic value.
- (mlet %store-monad ((drv (package->derivation bash)))
- (gexp->derivation "sh"
- #~(symlink (string-append #$drv "/bin/bash")
- #$output))))
- @end example
-
- There several things to note in the second version: the @code{store}
- parameter is now implicit and is ``threaded'' in the calls to the
- @code{package->derivation} and @code{gexp->derivation} monadic
- procedures, and the monadic value returned by @code{package->derivation}
- is @dfn{bound} using @code{mlet} instead of plain @code{let}.
-
- As it turns out, the call to @code{package->derivation} can even be
- omitted since it will take place implicitly, as we will see later
- (@pxref{G-Expressions}):
-
- @example
- (define (sh-symlink)
- (gexp->derivation "sh"
- #~(symlink (string-append #$bash "/bin/bash")
- #$output)))
- @end example
-
- Calling the monadic @code{sh-symlink} has no effect. To get the desired
- effect, one must use @code{run-with-store}:
-
- @example
- (run-with-store (open-connection) (sh-symlink))
- @result{} /gnu/store/...-sh-symlink
- @end example
-
- Note that the @code{(guix monad-repl)} module extends Guile's REPL with
- new ``meta-commands'' to make it easier to deal with monadic procedures:
- @code{run-in-store}, and @code{enter-store-monad}. The former, is used
- to ``run'' a single monadic value through the store:
-
- @example
- scheme@@(guile-user)> ,run-in-store (package->derivation hello)
- $1 = #<derivation /gnu/store/@dots{}-hello-2.9.drv => @dots{}>
- @end example
-
- The latter enters a recursive REPL, where all the return values are
- automatically run through the store:
-
- @example
- scheme@@(guile-user)> ,enter-store-monad
- store-monad@@(guile-user) [1]> (package->derivation hello)
- $2 = #<derivation /gnu/store/@dots{}-hello-2.9.drv => @dots{}>
- store-monad@@(guile-user) [1]> (text-file "foo" "Hello!")
- $3 = "/gnu/store/@dots{}-foo"
- store-monad@@(guile-user) [1]> ,q
- scheme@@(guile-user)>
- @end example
-
- @noindent
- Note that non-monadic values cannot be returned in the
- @code{store-monad} REPL.
-
- The main syntactic forms to deal with monads in general are provided by
- the @code{(guix monads)} module and are described below.
-
- @deffn {Scheme Syntax} with-monad @var{monad} @var{body} ...
- Evaluate any @code{>>=} or @code{return} forms in @var{body} as being
- in @var{monad}.
- @end deffn
-
- @deffn {Scheme Syntax} return @var{val}
- Return a monadic value that encapsulates @var{val}.
- @end deffn
-
- @deffn {Scheme Syntax} >>= @var{mval} @var{mproc} ...
- @dfn{Bind} monadic value @var{mval}, passing its ``contents'' to monadic
- procedures @var{mproc}@dots{}@footnote{This operation is commonly
- referred to as ``bind'', but that name denotes an unrelated procedure in
- Guile. Thus we use this somewhat cryptic symbol inherited from the
- Haskell language.}. There can be one @var{mproc} or several of them, as
- in this example:
-
- @example
- (run-with-state
- (with-monad %state-monad
- (>>= (return 1)
- (lambda (x) (return (+ 1 x)))
- (lambda (x) (return (* 2 x)))))
- 'some-state)
-
- @result{} 4
- @result{} some-state
- @end example
- @end deffn
-
- @deffn {Scheme Syntax} mlet @var{monad} ((@var{var} @var{mval}) ...) @
- @var{body} ...
- @deffnx {Scheme Syntax} mlet* @var{monad} ((@var{var} @var{mval}) ...) @
- @var{body} ...
- Bind the variables @var{var} to the monadic values @var{mval} in
- @var{body}. The form (@var{var} -> @var{val}) binds @var{var} to the
- ``normal'' value @var{val}, as per @code{let}.
-
- @code{mlet*} is to @code{mlet} what @code{let*} is to @code{let}
- (@pxref{Local Bindings,,, guile, GNU Guile Reference Manual}).
- @end deffn
-
- @deffn {Scheme System} mbegin @var{monad} @var{mexp} ...
- Bind @var{mexp} and the following monadic expressions in sequence,
- returning the result of the last expression.
-
- This is akin to @code{mlet}, except that the return values of the
- monadic expressions are ignored. In that sense, it is analogous to
- @code{begin}, but applied to monadic expressions.
- @end deffn
-
- @cindex state monad
- The @code{(guix monads)} module provides the @dfn{state monad}, which
- allows an additional value---the state---to be @emph{threaded} through
- monadic procedure calls.
-
- @defvr {Scheme Variable} %state-monad
- The state monad. Procedures in the state monad can access and change
- the state that is threaded.
-
- Consider the example below. The @code{square} procedure returns a value
- in the state monad. It returns the square of its argument, but also
- increments the current state value:
-
- @example
- (define (square x)
- (mlet %state-monad ((count (current-state)))
- (mbegin %state-monad
- (set-current-state (+ 1 count))
- (return (* x x)))))
-
- (run-with-state (sequence %state-monad (map square (iota 3))) 0)
- @result{} (0 1 4)
- @result{} 3
- @end example
-
- When ``run'' through @var{%state-monad}, we obtain that additional state
- value, which is the number of @code{square} calls.
- @end defvr
-
- @deffn {Monadic Procedure} current-state
- Return the current state as a monadic value.
- @end deffn
-
- @deffn {Monadic Procedure} set-current-state @var{value}
- Set the current state to @var{value} and return the previous state as a
- monadic value.
- @end deffn
-
- @deffn {Monadic Procedure} state-push @var{value}
- Push @var{value} to the current state, which is assumed to be a list,
- and return the previous state as a monadic value.
- @end deffn
-
- @deffn {Monadic Procedure} state-pop
- Pop a value from the current state and return it as a monadic value.
- The state is assumed to be a list.
- @end deffn
-
- @deffn {Scheme Procedure} run-with-state @var{mval} [@var{state}]
- Run monadic value @var{mval} starting with @var{state} as the initial
- state. Return two values: the resulting value, and the resulting state.
- @end deffn
-
- The main interface to the store monad, provided by the @code{(guix
- store)} module, is as follows.
-
- @defvr {Scheme Variable} %store-monad
- The store monad---an alias for @var{%state-monad}.
-
- Values in the store monad encapsulate accesses to the store. When its
- effect is needed, a value of the store monad must be ``evaluated'' by
- passing it to the @code{run-with-store} procedure (see below.)
- @end defvr
-
- @deffn {Scheme Procedure} run-with-store @var{store} @var{mval} [#:guile-for-build] [#:system (%current-system)]
- Run @var{mval}, a monadic value in the store monad, in @var{store}, an
- open store connection.
- @end deffn
-
- @deffn {Monadic Procedure} text-file @var{name} @var{text} [@var{references}]
- Return as a monadic value the absolute file name in the store of the file
- containing @var{text}, a string. @var{references} is a list of store items that the
- resulting text file refers to; it defaults to the empty list.
- @end deffn
-
- @deffn {Monadic Procedure} interned-file @var{file} [@var{name}] @
- [#:recursive? #t]
- Return the name of @var{file} once interned in the store. Use
- @var{name} as its store name, or the basename of @var{file} if
- @var{name} is omitted.
-
- When @var{recursive?} is true, the contents of @var{file} are added
- recursively; if @var{file} designates a flat file and @var{recursive?}
- is true, its contents are added, and its permission bits are kept.
-
- The example below adds a file to the store, under two different names:
-
- @example
- (run-with-store (open-connection)
- (mlet %store-monad ((a (interned-file "README"))
- (b (interned-file "README" "LEGU-MIN")))
- (return (list a b))))
-
- @result{} ("/gnu/store/rwm@dots{}-README" "/gnu/store/44i@dots{}-LEGU-MIN")
- @end example
-
- @end deffn
-
- The @code{(guix packages)} module exports the following package-related
- monadic procedures:
-
- @deffn {Monadic Procedure} package-file @var{package} [@var{file}] @
- [#:system (%current-system)] [#:target #f] @
- [#:output "out"] Return as a monadic
- value in the absolute file name of @var{file} within the @var{output}
- directory of @var{package}. When @var{file} is omitted, return the name
- of the @var{output} directory of @var{package}. When @var{target} is
- true, use it as a cross-compilation target triplet.
- @end deffn
-
- @deffn {Monadic Procedure} package->derivation @var{package} [@var{system}]
- @deffnx {Monadic Procedure} package->cross-derivation @var{package} @
- @var{target} [@var{system}]
- Monadic version of @code{package-derivation} and
- @code{package-cross-derivation} (@pxref{Defining Packages}).
- @end deffn
-
-
- @node G-Expressions
- @section G-Expressions
-
- @cindex G-expression
- @cindex build code quoting
- So we have ``derivations'', which represent a sequence of build actions
- to be performed to produce an item in the store (@pxref{Derivations}).
- Those build actions are performed when asking the daemon to actually
- build the derivations; they are run by the daemon in a container
- (@pxref{Invoking guix-daemon}).
-
- @cindex strata of code
- It should come as no surprise that we like to write those build actions
- in Scheme. When we do that, we end up with two @dfn{strata} of Scheme
- code@footnote{The term @dfn{stratum} in this context was coined by
- Manuel Serrano et al.@: in the context of their work on Hop. Oleg
- Kiselyov, who has written insightful
- @url{http://okmij.org/ftp/meta-programming/#meta-scheme, essays and code
- on this topic}, refers to this kind of code generation as
- @dfn{staging}.}: the ``host code''---code that defines packages, talks
- to the daemon, etc.---and the ``build code''---code that actually
- performs build actions, such as making directories, invoking
- @command{make}, etc.
-
- To describe a derivation and its build actions, one typically needs to
- embed build code inside host code. It boils down to manipulating build
- code as data, and Scheme's homoiconicity---code has a direct
- representation as data---comes in handy for that. But we need more than
- Scheme's normal @code{quasiquote} mechanism to construct build
- expressions.
-
- The @code{(guix gexp)} module implements @dfn{G-expressions}, a form of
- S-expressions adapted to build expressions. G-expressions, or
- @dfn{gexps}, consist essentially in three syntactic forms: @code{gexp},
- @code{ungexp}, and @code{ungexp-splicing} (or simply: @code{#~},
- @code{#$}, and @code{#$@@}), which are comparable respectively to
- @code{quasiquote}, @code{unquote}, and @code{unquote-splicing}
- (@pxref{Expression Syntax, @code{quasiquote},, guile, GNU Guile
- Reference Manual}). However, there are major differences:
-
- @itemize
- @item
- Gexps are meant to be written to a file and run or manipulated by other
- processes.
-
- @item
- When a high-level object such as a package or derivation is unquoted
- inside a gexp, the result is as if its output file name had been
- introduced.
-
- @item
- Gexps carry information about the packages or derivations they refer to,
- and these dependencies are automatically added as inputs to the build
- processes that use them.
- @end itemize
-
- This mechanism is not limited to package and derivation
- objects: @dfn{compilers} able to ``lower'' other high-level objects to
- derivations can be defined, such that these objects can also be inserted
- into gexps. For example, a useful type of high-level object that can be
- inserted in a gexp is ``file-like objects'', which make it easy to
- add files to the store and refer to them in
- derivations and such (see @code{local-file} and @code{plain-file}
- below.)
-
- To illustrate the idea, here is an example of a gexp:
-
- @example
- (define build-exp
- #~(begin
- (mkdir #$output)
- (chdir #$output)
- (symlink (string-append #$coreutils "/bin/ls")
- "list-files")))
- @end example
-
- This gexp can be passed to @code{gexp->derivation}; we obtain a
- derivation that builds a directory containing exactly one symlink to
- @file{/gnu/store/@dots{}-coreutils-8.22/bin/ls}:
-
- @example
- (gexp->derivation "the-thing" build-exp)
- @end example
-
- As one would expect, the @code{"/gnu/store/@dots{}-coreutils-8.22"} string is
- substituted to the reference to the @var{coreutils} package in the
- actual build code, and @var{coreutils} is automatically made an input to
- the derivation. Likewise, @code{#$output} (equivalent to @code{(ungexp
- output)}) is replaced by a string containing the derivation's output
- directory name.
-
- @cindex cross compilation
- In a cross-compilation context, it is useful to distinguish between
- references to the @emph{native} build of a package---that can run on the
- host---versus references to cross builds of a package. To that end, the
- @code{#+} plays the same role as @code{#$}, but is a reference to a
- native package build:
-
- @example
- (gexp->derivation "vi"
- #~(begin
- (mkdir #$output)
- (system* (string-append #+coreutils "/bin/ln")
- "-s"
- (string-append #$emacs "/bin/emacs")
- (string-append #$output "/bin/vi")))
- #:target "mips64el-linux")
- @end example
-
- @noindent
- In the example above, the native build of @var{coreutils} is used, so
- that @command{ln} can actually run on the host; but then the
- cross-compiled build of @var{emacs} is referenced.
-
- The syntactic form to construct gexps is summarized below.
-
- @deffn {Scheme Syntax} #~@var{exp}
- @deffnx {Scheme Syntax} (gexp @var{exp})
- Return a G-expression containing @var{exp}. @var{exp} may contain one
- or more of the following forms:
-
- @table @code
- @item #$@var{obj}
- @itemx (ungexp @var{obj})
- Introduce a reference to @var{obj}. @var{obj} may have one of the
- supported types, for example a package or a
- derivation, in which case the @code{ungexp} form is replaced by its
- output file name---e.g., @code{"/gnu/store/@dots{}-coreutils-8.22}.
-
- If @var{obj} is a list, it is traversed and references to supported
- objects are substituted similarly.
-
- If @var{obj} is another gexp, its contents are inserted and its
- dependencies are added to those of the containing gexp.
-
- If @var{obj} is another kind of object, it is inserted as is.
-
- @item #$@var{obj}:@var{output}
- @itemx (ungexp @var{obj} @var{output})
- This is like the form above, but referring explicitly to the
- @var{output} of @var{obj}---this is useful when @var{obj} produces
- multiple outputs (@pxref{Packages with Multiple Outputs}).
-
- @item #+@var{obj}
- @itemx #+@var{obj}:output
- @itemx (ungexp-native @var{obj})
- @itemx (ungexp-native @var{obj} @var{output})
- Same as @code{ungexp}, but produces a reference to the @emph{native}
- build of @var{obj} when used in a cross compilation context.
-
- @item #$output[:@var{output}]
- @itemx (ungexp output [@var{output}])
- Insert a reference to derivation output @var{output}, or to the main
- output when @var{output} is omitted.
-
- This only makes sense for gexps passed to @code{gexp->derivation}.
-
- @item #$@@@var{lst}
- @itemx (ungexp-splicing @var{lst})
- Like the above, but splices the contents of @var{lst} inside the
- containing list.
-
- @item #+@@@var{lst}
- @itemx (ungexp-native-splicing @var{lst})
- Like the above, but refers to native builds of the objects listed in
- @var{lst}.
-
- @end table
-
- G-expressions created by @code{gexp} or @code{#~} are run-time objects
- of the @code{gexp?} type (see below.)
- @end deffn
-
- @deffn {Scheme Procedure} gexp? @var{obj}
- Return @code{#t} if @var{obj} is a G-expression.
- @end deffn
-
- G-expressions are meant to be written to disk, either as code building
- some derivation, or as plain files in the store. The monadic procedures
- below allow you to do that (@pxref{The Store Monad}, for more
- information about monads.)
-
- @deffn {Monadic Procedure} gexp->derivation @var{name} @var{exp} @
- [#:system (%current-system)] [#:target #f] [#:graft? #t] @
- [#:hash #f] [#:hash-algo #f] @
- [#:recursive? #f] [#:env-vars '()] [#:modules '()] @
- [#:module-path @var{%load-path}] @
- [#:references-graphs #f] [#:allowed-references #f] @
- [#:leaked-env-vars #f] @
- [#:local-build? #f] [#:guile-for-build #f]
- Return a derivation @var{name} that runs @var{exp} (a gexp) with
- @var{guile-for-build} (a derivation) on @var{system}. When @var{target}
- is true, it is used as the cross-compilation target triplet for packages
- referred to by @var{exp}.
-
- Make @var{modules} available in the evaluation context of @var{exp};
- @var{modules} is a list of names of Guile modules searched in
- @var{module-path} to be copied in the store, compiled, and made available in
- the load path during the execution of @var{exp}---e.g., @code{((guix
- build utils) (guix build gnu-build-system))}.
-
- @var{graft?} determines whether packages referred to by @var{exp} should be grafted when
- applicable.
-
- When @var{references-graphs} is true, it must be a list of tuples of one of the
- following forms:
-
- @example
- (@var{file-name} @var{package})
- (@var{file-name} @var{package} @var{output})
- (@var{file-name} @var{derivation})
- (@var{file-name} @var{derivation} @var{output})
- (@var{file-name} @var{store-item})
- @end example
-
- The right-hand-side of each element of @var{references-graphs} is automatically made
- an input of the build process of @var{exp}. In the build environment, each
- @var{file-name} contains the reference graph of the corresponding item, in a simple
- text format.
-
- @var{allowed-references} must be either @code{#f} or a list of output names and packages.
- In the latter case, the list denotes store items that the result is allowed to
- refer to. Any reference to another store item will lead to a build error.
-
- The other arguments are as for @code{derivation} (@pxref{Derivations}).
- @end deffn
-
- @cindex file-like objects
- The @code{local-file} and @code{plain-file} procedures below return
- @dfn{file-like objects}. That is, when unquoted in a G-expression,
- these objects lead to a file in the store. Consider this G-expression:
-
- @example
- #~(system* (string-append #$glibc "/sbin/nscd") "-f"
- #$(local-file "/tmp/my-nscd.conf"))
- @end example
-
- The effect here is to ``intern'' @file{/tmp/my-nscd.conf} by copying it
- to the store. Once expanded, for instance @i{via}
- @code{gexp->derivation}, the G-expression refers to that copy under
- @file{/gnu/store}; thus, modifying or removing the file in @file{/tmp}
- does not have any effect on what the G-expression does.
- @code{plain-file} can be used similarly; it differs in that the file
- content is directly passed as a string.
-
- @deffn {Scheme Procedure} local-file @var{file} [@var{name}] @
- [#:recursive? #t]
- Return an object representing local file @var{file} to add to the store; this
- object can be used in a gexp. @var{file} will be added to the store under @var{name}--by
- default the base name of @var{file}.
-
- When @var{recursive?} is true, the contents of @var{file} are added recursively; if @var{file}
- designates a flat file and @var{recursive?} is true, its contents are added, and its
- permission bits are kept.
-
- This is the declarative counterpart of the @code{interned-file} monadic
- procedure (@pxref{The Store Monad, @code{interned-file}}).
- @end deffn
-
- @deffn {Scheme Procedure} plain-file @var{name} @var{content}
- Return an object representing a text file called @var{name} with the given
- @var{content} (a string) to be added to the store.
-
- This is the declarative counterpart of @code{text-file}.
- @end deffn
-
- @deffn {Monadic Procedure} gexp->script @var{name} @var{exp}
- Return an executable script @var{name} that runs @var{exp} using
- @var{guile} with @var{modules} in its search path.
-
- The example below builds a script that simply invokes the @command{ls}
- command:
-
- @example
- (use-modules (guix gexp) (gnu packages base))
-
- (gexp->script "list-files"
- #~(execl (string-append #$coreutils "/bin/ls")
- "ls"))
- @end example
-
- When ``running'' it through the store (@pxref{The Store Monad,
- @code{run-with-store}}), we obtain a derivation that produces an
- executable file @file{/gnu/store/@dots{}-list-files} along these lines:
-
- @example
- #!/gnu/store/@dots{}-guile-2.0.11/bin/guile -ds
- !#
- (execl (string-append "/gnu/store/@dots{}-coreutils-8.22"/bin/ls")
- "ls")
- @end example
- @end deffn
-
- @deffn {Monadic Procedure} gexp->file @var{name} @var{exp}
- Return a derivation that builds a file @var{name} containing @var{exp}.
-
- The resulting file holds references to all the dependencies of @var{exp}
- or a subset thereof.
- @end deffn
-
- @deffn {Monadic Procedure} text-file* @var{name} @var{text} @dots{}
- Return as a monadic value a derivation that builds a text file
- containing all of @var{text}. @var{text} may list, in addition to
- strings, objects of any type that can be used in a gexp: packages,
- derivations, local file objects, etc. The resulting store file holds
- references to all these.
-
- This variant should be preferred over @code{text-file} anytime the file
- to create will reference items from the store. This is typically the
- case when building a configuration file that embeds store file names,
- like this:
-
- @example
- (define (profile.sh)
- ;; Return the name of a shell script in the store that
- ;; initializes the 'PATH' environment variable.
- (text-file* "profile.sh"
- "export PATH=" coreutils "/bin:"
- grep "/bin:" sed "/bin\n"))
- @end example
-
- In this example, the resulting @file{/gnu/store/@dots{}-profile.sh} file
- will references @var{coreutils}, @var{grep}, and @var{sed}, thereby
- preventing them from being garbage-collected during its lifetime.
- @end deffn
-
- Of course, in addition to gexps embedded in ``host'' code, there are
- also modules containing build tools. To make it clear that they are
- meant to be used in the build stratum, these modules are kept in the
- @code{(guix build @dots{})} name space.
-
-
- @c *********************************************************************
- @node Utilities
- @chapter Utilities
-
- This section describes tools primarily targeted at developers and users
- who write new package definitions. They complement the Scheme
- programming interface of Guix in a convenient way.
-
- @menu
- * Invoking guix build:: Building packages from the command line.
- * Invoking guix download:: Downloading a file and printing its hash.
- * Invoking guix hash:: Computing the cryptographic hash of a file.
- * Invoking guix import:: Importing package definitions.
- * Invoking guix refresh:: Updating package definitions.
- * Invoking guix lint:: Finding errors in package definitions.
- * Invoking guix environment:: Setting up development environments.
- * Invoking guix publish:: Sharing substitutes.
- @end menu
-
- @node Invoking guix build
- @section Invoking @command{guix build}
-
- The @command{guix build} command builds packages or derivations and
- their dependencies, and prints the resulting store paths. Note that it
- does not modify the user's profile---this is the job of the
- @command{guix package} command (@pxref{Invoking guix package}). Thus,
- it is mainly useful for distribution developers.
-
- The general syntax is:
-
- @example
- guix build @var{options} @var{package-or-derivation}@dots{}
- @end example
-
- @var{package-or-derivation} may be either the name of a package found in
- the software distribution such as @code{coreutils} or
- @code{coreutils-8.20}, or a derivation such as
- @file{/gnu/store/@dots{}-coreutils-8.19.drv}. In the former case, a
- package with the corresponding name (and optionally version) is searched
- for among the GNU distribution modules (@pxref{Package Modules}).
-
- Alternatively, the @code{--expression} option may be used to specify a
- Scheme expression that evaluates to a package; this is useful when
- disambiguation among several same-named packages or package variants is
- needed.
-
- The @var{options} may be zero or more of the following:
-
- @table @code
-
- @item --expression=@var{expr}
- @itemx -e @var{expr}
- Build the package or derivation @var{expr} evaluates to.
-
- For example, @var{expr} may be @code{(@@ (gnu packages guile)
- guile-1.8)}, which unambiguously designates this specific variant of
- version 1.8 of Guile.
-
- Alternately, @var{expr} may be a G-expression, in which case it is used
- as a build program passed to @code{gexp->derivation}
- (@pxref{G-Expressions}).
-
- Lastly, @var{expr} may refer to a zero-argument monadic procedure
- (@pxref{The Store Monad}). The procedure must return a derivation as a
- monadic value, which is then passed through @code{run-with-store}.
-
- @item --source
- @itemx -S
- Build the packages' source derivations, rather than the packages
- themselves.
-
- For instance, @code{guix build -S gcc} returns something like
- @file{/gnu/store/@dots{}-gcc-4.7.2.tar.bz2}, which is GCC's source tarball.
-
- The returned source tarball is the result of applying any patches and
- code snippets specified in the package's @code{origin} (@pxref{Defining
- Packages}).
-
- @item --sources
- Fetch and return the source of @var{package-or-derivation} and all their
- dependencies, recursively. This is a handy way to obtain a local copy
- of all the source code needed to build @var{packages}, allowing you to
- eventually build them even without network access. It is an extension
- of the @code{--source} option and can accept one of the following
- optional argument values:
-
- @table @code
- @item package
- This value causes the @code{--sources} option to behave in the same way
- as the @code{--source} option.
-
- @item all
- Build all packages' source derivations, including any source that might
- be listed as @code{inputs}. This is the default value.
-
- @example
- $ guix build --sources tzdata
- The following derivations will be built:
- /gnu/store/@dots{}-tzdata2015b.tar.gz.drv
- /gnu/store/@dots{}-tzcode2015b.tar.gz.drv
- @end example
-
- @item transitive
- Build all packages' source derivations, as well as all source
- derivations for packages' transitive inputs. This can be used e.g. to
- prefetch package source for later offline building.
-
- @example
- $ guix build --sources=transitive tzdata
- The following derivations will be built:
- /gnu/store/@dots{}-tzcode2015b.tar.gz.drv
- /gnu/store/@dots{}-findutils-4.4.2.tar.xz.drv
- /gnu/store/@dots{}-grep-2.21.tar.xz.drv
- /gnu/store/@dots{}-coreutils-8.23.tar.xz.drv
- /gnu/store/@dots{}-make-4.1.tar.xz.drv
- /gnu/store/@dots{}-bash-4.3.tar.xz.drv
- @dots{}
- @end example
-
- @end table
-
- @item --system=@var{system}
- @itemx -s @var{system}
- Attempt to build for @var{system}---e.g., @code{i686-linux}---instead of
- the host's system type.
-
- An example use of this is on Linux-based systems, which can emulate
- different personalities. For instance, passing
- @code{--system=i686-linux} on an @code{x86_64-linux} system allows users
- to build packages in a complete 32-bit environment.
-
- @item --target=@var{triplet}
- @cindex cross-compilation
- Cross-build for @var{triplet}, which must be a valid GNU triplet, such
- as @code{"mips64el-linux-gnu"} (@pxref{Configuration Names, GNU
- configuration triplets,, configure, GNU Configure and Build System}).
-
- @item --with-source=@var{source}
- Use @var{source} as the source of the corresponding package.
- @var{source} must be a file name or a URL, as for @command{guix
- download} (@pxref{Invoking guix download}).
-
- The ``corresponding package'' is taken to be one specified on the
- command line whose name matches the base of @var{source}---e.g., if
- @var{source} is @code{/src/guile-2.0.10.tar.gz}, the corresponding
- package is @code{guile}. Likewise, the version string is inferred from
- @var{source}; in the previous example, it's @code{2.0.10}.
-
- This option allows users to try out versions of packages other than the
- one provided by the distribution. The example below downloads
- @file{ed-1.7.tar.gz} from a GNU mirror and uses that as the source for
- the @code{ed} package:
-
- @example
- guix build ed --with-source=mirror://gnu/ed/ed-1.7.tar.gz
- @end example
-
- As a developer, @code{--with-source} makes it easy to test release
- candidates:
-
- @example
- guix build guile --with-source=../guile-2.0.9.219-e1bb7.tar.xz
- @end example
-
- @dots{} or to build from a checkout in a pristine environment:
-
- @example
- $ git clone git://git.sv.gnu.org/guix.git
- $ guix build guix --with-source=./guix
- @end example
-
- @item --no-grafts
- Do not ``graft'' packages. In practice, this means that package updates
- available as grafts are not applied. @xref{Security Updates}, for more
- information on grafts.
-
- @item --derivations
- @itemx -d
- Return the derivation paths, not the output paths, of the given
- packages.
-
- @item --root=@var{file}
- @itemx -r @var{file}
- Make @var{file} a symlink to the result, and register it as a garbage
- collector root.
-
- @item --log-file
- Return the build log file names for the given
- @var{package-or-derivation}s, or raise an error if build logs are
- missing.
-
- This works regardless of how packages or derivations are specified. For
- instance, the following invocations are equivalent:
-
- @example
- guix build --log-file `guix build -d guile`
- guix build --log-file `guix build guile`
- guix build --log-file guile
- guix build --log-file -e '(@@ (gnu packages guile) guile-2.0)'
- @end example
-
-
- @end table
-
- @cindex common build options
- In addition, a number of options that control the build process are
- common to @command{guix build} and other commands that can spawn builds,
- such as @command{guix package} or @command{guix archive}. These are the
- following:
-
- @table @code
-
- @item --load-path=@var{directory}
- @itemx -L @var{directory}
- Add @var{directory} to the front of the package module search path
- (@pxref{Package Modules}).
-
- This allows users to define their own packages and make them visible to
- the command-line tools.
-
- @item --keep-failed
- @itemx -K
- Keep the build tree of failed builds. Thus, if a build fail, its build
- tree is kept under @file{/tmp}, in a directory whose name is shown at
- the end of the build log. This is useful when debugging build issues.
-
- @item --dry-run
- @itemx -n
- Do not build the derivations.
-
- @item --fallback
- When substituting a pre-built binary fails, fall back to building
- packages locally.
-
- @item --no-substitutes
- Do not use substitutes for build products. That is, always build things
- locally instead of allowing downloads of pre-built binaries
- (@pxref{Substitutes}).
-
- @item --no-build-hook
- Do not attempt to offload builds @i{via} the daemon's ``build hook''
- (@pxref{Daemon Offload Setup}). That is, always build things locally
- instead of offloading builds to remote machines.
-
- @item --max-silent-time=@var{seconds}
- When the build or substitution process remains silent for more than
- @var{seconds}, terminate it and report a build failure.
-
- @item --timeout=@var{seconds}
- Likewise, when the build or substitution process lasts for more than
- @var{seconds}, terminate it and report a build failure.
-
- By default there is no timeout. This behavior can be restored with
- @code{--timeout=0}.
-
- @item --verbosity=@var{level}
- Use the given verbosity level. @var{level} must be an integer between 0
- and 5; higher means more verbose output. Setting a level of 4 or more
- may be helpful when debugging setup issues with the build daemon.
-
- @item --cores=@var{n}
- @itemx -c @var{n}
- Allow the use of up to @var{n} CPU cores for the build. The special
- value @code{0} means to use as many CPU cores as available.
-
- @item --max-jobs=@var{n}
- @itemx -M @var{n}
- Allow at most @var{n} build jobs in parallel. @xref{Invoking
- guix-daemon, @code{--max-jobs}}, for details about this option and the
- equivalent @command{guix-daemon} option.
-
- @end table
-
- Behind the scenes, @command{guix build} is essentially an interface to
- the @code{package-derivation} procedure of the @code{(guix packages)}
- module, and to the @code{build-derivations} procedure of the @code{(guix
- derivations)} module.
-
- In addition to options explicitly passed on the command line,
- @command{guix build} and other @command{guix} commands that support
- building honor the @code{GUIX_BUILD_OPTIONS} environment variable.
-
- @defvr {Environment Variable} GUIX_BUILD_OPTIONS
- Users can define this variable to a list of command line options that
- will automatically be used by @command{guix build} and other
- @command{guix} commands that can perform builds, as in the example
- below:
-
- @example
- $ export GUIX_BUILD_OPTIONS="--no-substitutes -c 2 -L /foo/bar"
- @end example
-
- These options are parsed independently, and the result is appended to
- the parsed command-line options.
- @end defvr
-
-
- @node Invoking guix download
- @section Invoking @command{guix download}
-
- When writing a package definition, developers typically need to download
- the package's source tarball, compute its SHA256 hash, and write that
- hash in the package definition (@pxref{Defining Packages}). The
- @command{guix download} tool helps with this task: it downloads a file
- from the given URI, adds it to the store, and prints both its file name
- in the store and its SHA256 hash.
-
- The fact that the downloaded file is added to the store saves bandwidth:
- when the developer eventually tries to build the newly defined package
- with @command{guix build}, the source tarball will not have to be
- downloaded again because it is already in the store. It is also a
- convenient way to temporarily stash files, which may be deleted
- eventually (@pxref{Invoking guix gc}).
-
- The @command{guix download} command supports the same URIs as used in
- package definitions. In particular, it supports @code{mirror://} URIs.
- @code{https} URIs (HTTP over TLS) are supported @emph{provided} the
- Guile bindings for GnuTLS are available in the user's environment; when
- they are not available, an error is raised. @xref{Guile Preparations,
- how to install the GnuTLS bindings for Guile,, gnutls-guile,
- GnuTLS-Guile}, for more information.
-
- The following option is available:
-
- @table @code
- @item --format=@var{fmt}
- @itemx -f @var{fmt}
- Write the hash in the format specified by @var{fmt}. For more
- information on the valid values for @var{fmt}, @pxref{Invoking guix hash}.
- @end table
-
- @node Invoking guix hash
- @section Invoking @command{guix hash}
-
- The @command{guix hash} command computes the SHA256 hash of a file.
- It is primarily a convenience tool for anyone contributing to the
- distribution: it computes the cryptographic hash of a file, which can be
- used in the definition of a package (@pxref{Defining Packages}).
-
- The general syntax is:
-
- @example
- guix hash @var{option} @var{file}
- @end example
-
- @command{guix hash} has the following option:
-
- @table @code
-
- @item --format=@var{fmt}
- @itemx -f @var{fmt}
- Write the hash in the format specified by @var{fmt}.
-
- Supported formats: @code{nix-base32}, @code{base32}, @code{base16}
- (@code{hex} and @code{hexadecimal} can be used as well).
-
- If the @option{--format} option is not specified, @command{guix hash}
- will output the hash in @code{nix-base32}. This representation is used
- in the definitions of packages.
-
- @item --recursive
- @itemx -r
- Compute the hash on @var{file} recursively.
-
- In this case, the hash is computed on an archive containing @var{file},
- including its children if it is a directory. Some of @var{file}'s
- meta-data is part of the archive; for instance, when @var{file} is a
- regular file, the hash is different depending on whether @var{file} is
- executable or not. Meta-data such as time stamps has no impact on the
- hash (@pxref{Invoking guix archive}).
- @c FIXME: Replace xref above with xref to an ``Archive'' section when
- @c it exists.
-
- @end table
-
- @node Invoking guix import
- @section Invoking @command{guix import}
-
- @cindex importing packages
- @cindex package import
- @cindex package conversion
- The @command{guix import} command is useful for people willing to add a
- package to the distribution but who'd rather do as little work as
- possible to get there---a legitimate demand. The command knows of a few
- repositories from which it can ``import'' package meta-data. The result
- is a package definition, or a template thereof, in the format we know
- (@pxref{Defining Packages}).
-
- The general syntax is:
-
- @example
- guix import @var{importer} @var{options}@dots{}
- @end example
-
- @var{importer} specifies the source from which to import package
- meta-data, and @var{options} specifies a package identifier and other
- options specific to @var{importer}. Currently, the available
- ``importers'' are:
-
- @table @code
- @item gnu
- Import meta-data for the given GNU package. This provides a template
- for the latest version of that GNU package, including the hash of its
- source tarball, and its canonical synopsis and description.
-
- Additional information such as the package's dependencies and its
- license needs to be figured out manually.
-
- For example, the following command returns a package definition for
- GNU@tie{}Hello:
-
- @example
- guix import gnu hello
- @end example
-
- Specific command-line options are:
-
- @table @code
- @item --key-download=@var{policy}
- As for @code{guix refresh}, specify the policy to handle missing OpenPGP
- keys when verifying the package's signature. @xref{Invoking guix
- refresh, @code{--key-download}}.
- @end table
-
- @item pypi
- @cindex pypi
- Import meta-data from the @uref{https://pypi.python.org/, Python Package
- Index}@footnote{This functionality requires Guile-JSON to be installed.
- @xref{Requirements}.}. Information is taken from the JSON-formatted
- description available at @code{pypi.python.org} and usually includes all
- the relevant information, including package dependencies.
-
- The command below imports meta-data for the @code{itsdangerous} Python
- package:
-
- @example
- guix import pypi itsdangerous
- @end example
-
- @item cpan
- @cindex CPAN
- Import meta-data from @uref{https://www.metacpan.org/, MetaCPAN}.
- Information is taken from the JSON-formatted meta-data provided through
- @uref{https://api.metacpan.org/, MetaCPAN's API} and includes most
- relevant information, such as module dependencies. License information
- should be checked closely. If Perl is available in the store, then the
- @code{corelist} utility will be used to filter core modules out of the
- list of dependencies.
-
- The command command below imports meta-data for the @code{Acme::Boolean}
- Perl module:
-
- @example
- guix import cpan Acme::Boolean
- @end example
-
- @item nix
- Import meta-data from a local copy of the source of the
- @uref{http://nixos.org/nixpkgs/, Nixpkgs distribution}@footnote{This
- relies on the @command{nix-instantiate} command of
- @uref{http://nixos.org/nix/, Nix}.}. Package definitions in Nixpkgs are
- typically written in a mixture of Nix-language and Bash code. This
- command only imports the high-level package structure that is written in
- the Nix language. It normally includes all the basic fields of a
- package definition.
-
- When importing a GNU package, the synopsis and descriptions are replaced
- by their canonical upstream variant.
-
- As an example, the command below imports the package definition of
- LibreOffice (more precisely, it imports the definition of the package
- bound to the @code{libreoffice} top-level attribute):
-
- @example
- guix import nix ~/path/to/nixpkgs libreoffice
- @end example
-
- @item hackage
- @cindex hackage
- Import meta-data from Haskell community's central package archive
- @uref{https://hackage.haskell.org/, Hackage}. Information is taken from
- Cabal files and includes all the relevant information, including package
- dependencies.
-
- Specific command-line options are:
-
- @table @code
- @item --stdin
- @itemx -s
- Read a Cabal file from the standard input.
- @item --no-test-dependencies
- @itemx -t
- Do not include dependencies required by the test suites only.
- @item --cabal-environment=@var{alist}
- @itemx -e @var{alist}
- @var{alist} is a Scheme alist defining the environment in which the
- Cabal conditionals are evaluated. The accepted keys are: @code{os},
- @code{arch}, @code{impl} and a string representing the name of a flag.
- The value associated with a flag has to be either the symbol
- @code{true} or @code{false}. The value associated with other keys
- has to conform to the Cabal file format definition. The default value
- associated with the keys @code{os}, @code{arch} and @code{impl} is
- @samp{linux}, @samp{x86_64} and @samp{ghc} respectively.
- @end table
-
- The command below imports meta-data for the latest version of the
- @code{HTTP} Haskell package without including test dependencies and
- specifying the value of the flag @samp{network-uri} as @code{false}:
-
- @example
- guix import hackage -t -e "'((\"network-uri\" . false))" HTTP
- @end example
-
- A specific package version may optionally be specified by following the
- package name by a hyphen and a version number as in the following example:
-
- @example
- guix import hackage mtl-2.1.3.1
- @end example
- @end table
-
- The structure of the @command{guix import} code is modular. It would be
- useful to have more importers for other package formats, and your help
- is welcome here (@pxref{Contributing}).
-
- @node Invoking guix refresh
- @section Invoking @command{guix refresh}
-
- The primary audience of the @command{guix refresh} command is developers
- of the GNU software distribution. By default, it reports any packages
- provided by the distribution that are outdated compared to the latest
- upstream version, like this:
-
- @example
- $ guix refresh
- gnu/packages/gettext.scm:29:13: gettext would be upgraded from 0.18.1.1 to 0.18.2.1
- gnu/packages/glib.scm:77:12: glib would be upgraded from 2.34.3 to 2.37.0
- @end example
-
- It does so by browsing each package's FTP directory and determining the
- highest version number of the source tarballs
- therein@footnote{Currently, this only works for GNU packages.}.
-
- When passed @code{--update}, it modifies distribution source files to
- update the version numbers and source tarball hashes of those packages'
- recipes (@pxref{Defining Packages}). This is achieved by downloading
- each package's latest source tarball and its associated OpenPGP
- signature, authenticating the downloaded tarball against its signature
- using @command{gpg}, and finally computing its hash. When the public
- key used to sign the tarball is missing from the user's keyring, an
- attempt is made to automatically retrieve it from a public key server;
- when it's successful, the key is added to the user's keyring; otherwise,
- @command{guix refresh} reports an error.
-
- The following options are supported:
-
- @table @code
-
- @item --update
- @itemx -u
- Update distribution source files (package recipes) in place.
- @xref{Defining Packages}, for more information on package definitions.
-
- @item --select=[@var{subset}]
- @itemx -s @var{subset}
- Select all the packages in @var{subset}, one of @code{core} or
- @code{non-core}.
-
- The @code{core} subset refers to all the packages at the core of the
- distribution---i.e., packages that are used to build ``everything
- else''. This includes GCC, libc, Binutils, Bash, etc. Usually,
- changing one of these packages in the distribution entails a rebuild of
- all the others. Thus, such updates are an inconvenience to users in
- terms of build time or bandwidth used to achieve the upgrade.
-
- The @code{non-core} subset refers to the remaining packages. It is
- typically useful in cases where an update of the core packages would be
- inconvenient.
-
- @end table
-
- In addition, @command{guix refresh} can be passed one or more package
- names, as in this example:
-
- @example
- guix refresh -u emacs idutils gcc-4.8.4
- @end example
-
- @noindent
- The command above specifically updates the @code{emacs} and
- @code{idutils} packages. The @code{--select} option would have no
- effect in this case.
-
- When considering whether to upgrade a package, it is sometimes
- convenient to know which packages would be affected by the upgrade and
- should be checked for compatibility. For this the following option may
- be used when passing @command{guix refresh} one or more package names:
-
- @table @code
-
- @item --list-dependent
- @itemx -l
- List top-level dependent packages that would need to be rebuilt as a
- result of upgrading one or more packages.
-
- @end table
-
- Be aware that the @code{--list-dependent} option only
- @emph{approximates} the rebuilds that would be required as a result of
- an upgrade. More rebuilds might be required under some circumstances.
-
- @example
- $ guix refresh --list-dependent flex
- Building the following 120 packages would ensure 213 dependent packages are rebuilt:
- hop-2.4.0 geiser-0.4 notmuch-0.18 mu-0.9.9.5 cflow-1.4 idutils-4.6 @dots{}
- @end example
-
- The command above lists a set of packages that could be built to check
- for compatibility with an upgraded @code{flex} package.
-
- The following options can be used to customize GnuPG operation:
-
- @table @code
-
- @item --gpg=@var{command}
- Use @var{command} as the GnuPG 2.x command. @var{command} is searched
- for in @code{$PATH}.
-
- @item --key-download=@var{policy}
- Handle missing OpenPGP keys according to @var{policy}, which may be one
- of:
-
- @table @code
- @item always
- Always download missing OpenPGP keys from the key server, and add them
- to the user's GnuPG keyring.
-
- @item never
- Never try to download missing OpenPGP keys. Instead just bail out.
-
- @item interactive
- When a package signed with an unknown OpenPGP key is encountered, ask
- the user whether to download it or not. This is the default behavior.
- @end table
-
- @item --key-server=@var{host}
- Use @var{host} as the OpenPGP key server when importing a public key.
-
- @end table
-
- @node Invoking guix lint
- @section Invoking @command{guix lint}
- The @command{guix lint} is meant to help package developers avoid common
- errors and use a consistent style. It runs a number of checks on a
- given set of packages in order to find common mistakes in their
- definitions. Available @dfn{checkers} include (see
- @code{--list-checkers} for a complete list):
-
- @table @code
- @item synopsis
- @itemx description
- Validate certain typographical and stylistic rules about package
- descriptions and synopses.
-
- @item inputs-should-be-native
- Identify inputs that should most likely be native inputs.
-
- @item source
- @itemx home-page
- Probe @code{home-page} and @code{source} URLs and report those that are
- invalid.
- @end table
-
- The general syntax is:
-
- @example
- guix lint @var{options} @var{package}@dots{}
- @end example
-
- If no package is given on the command line, then all packages are checked.
- The @var{options} may be zero or more of the following:
-
- @table @code
-
- @item --checkers
- @itemx -c
- Only enable the checkers specified in a comma-separated list using the
- names returned by @code{--list-checkers}.
-
- @item --list-checkers
- @itemx -l
- List and describe all the available checkers that will be run on packages
- and exit.
-
- @end table
-
- @node Invoking guix environment
- @section Invoking @command{guix environment}
-
- @cindex reproducible build environments
- The purpose of @command{guix environment} is to assist hackers in
- creating reproducible development environments without polluting their
- package profile. The @command{guix environment} tool takes one or more
- packages, builds all of the necessary inputs, and creates a shell
- environment to use them.
-
- The general syntax is:
-
- @example
- guix environment @var{options} @var{package}@dots{}
- @end example
-
- The following examples spawns a new shell that is capable of building
- the GNU Guile source code:
-
- @example
- guix environment guile
- @end example
-
- If the specified packages are not built yet, @command{guix environment}
- automatically builds them. The new shell's environment is an augmented
- version of the environment that @command{guix environment} was run in.
- It contains the necessary search paths for building the given package
- added to the existing environment variables. To create a ``pure''
- environment in which the original environment variables have been unset,
- use the @code{--pure} option.
-
- Additionally, more than one package may be specified, in which case the
- union of the inputs for the given packages are used. For example, the
- command below spawns a shell where all of the dependencies of both Guile
- and Emacs are available:
-
- @example
- guix environment guile emacs
- @end example
-
- Sometimes an interactive shell session is not desired. The
- @code{--exec} option can be used to specify the command to run instead.
-
- @example
- guix environment guile --exec=make
- @end example
-
- The following options are available:
-
- @table @code
- @item --expression=@var{expr}
- @itemx -e @var{expr}
- Create an environment for the package that @var{expr} evaluates to.
-
- @item --load=@var{file}
- @itemx -l @var{file}
- Create an environment for the package that the code within @var{file}
- evaluates to.
-
- @item --exec=@var{command}
- @item -E @var{command}
- Execute @var{command} in the new environment.
-
- @item --ad-hoc
- Include all specified packages in the resulting environment, as if an
- @i{ad hoc} package were defined with them as inputs. This option is
- useful for quickly creating an environment without having to write a
- package expression to contain the desired inputs.
-
- For instance, the command:
-
- @example
- guix environment --ad-hoc guile guile-sdl -E guile
- @end example
-
- runs @command{guile} in an environment where Guile and Guile-SDL are
- available.
-
- @item --pure
- Unset existing environment variables when building the new environment.
- This has the effect of creating an environment in which search paths
- only contain package inputs.
-
- @item --search-paths
- Display the environment variable definitions that make up the
- environment.
- @end table
-
- It also supports all of the common build options that @command{guix
- build} supports (@pxref{Invoking guix build, common build options}).
-
- @node Invoking guix publish
- @section Invoking @command{guix publish}
-
- The purpose of @command{guix publish} is to enable users to easily share
- their store with others, which can then use it as a substitute server
- (@pxref{Substitutes}).
-
- When @command{guix publish} runs, it spawns an HTTP server which allows
- anyone with network access to obtain substitutes from it. This means
- that any machine running Guix can also act as if it were a build farm,
- since the HTTP interface is compatible with Hydra, the software behind
- the @code{hydra.gnu.org} build farm.
-
- For security, each substitute is signed, allowing recipients to check
- their authenticity and integrity (@pxref{Substitutes}). Because
- @command{guix publish} uses the system's signing key, which is only
- readable by the system administrator, it must be started as root; the
- @code{--user} option makes it drop root privileges early on.
-
- The general syntax is:
-
- @example
- guix publish @var{options}@dots{}
- @end example
-
- Running @command{guix publish} without any additional arguments will
- spawn an HTTP server on port 8080:
-
- @example
- guix publish
- @end example
-
- Once a publishing server has been authorized (@pxref{Invoking guix
- archive}), the daemon may download substitutes from it:
-
- @example
- guix-daemon --substitute-urls=http://example.org:8080
- @end example
-
- The following options are available:
-
- @table @code
- @item --port=@var{port}
- @itemx -p @var{port}
- Listen for HTTP requests on @var{port}.
-
- @item --listen=@var{host}
- Listen on the network interface for @var{host}. The default is to
- accept connections from any interface.
-
- @item --user=@var{user}
- @itemx -u @var{user}
- Change privileges to @var{user} as soon as possible---i.e., once the
- server socket is open and the signing key has been read.
-
- @item --repl[=@var{port}]
- @itemx -r [@var{port}]
- Spawn a Guile REPL server (@pxref{REPL Servers,,, guile, GNU Guile
- Reference Manual}) on @var{port} (37146 by default). This is used
- primarily for debugging a running @command{guix publish} server.
- @end table
-
- @c *********************************************************************
- @node GNU Distribution
- @chapter GNU Distribution
-
- @cindex Guix System Distribution
- @cindex GuixSD
- Guix comes with a distribution of the GNU system consisting entirely of
- free software@footnote{The term ``free'' here refers to the
- @url{http://www.gnu.org/philosophy/free-sw.html,freedom provided to
- users of that software}.}. The
- distribution can be installed on its own (@pxref{System Installation}),
- but it is also possible to install Guix as a package manager on top of
- an installed GNU/Linux system (@pxref{Installation}). To distinguish
- between the two, we refer to the standalone distribution as the Guix
- System Distribution, or GuixSD.
-
- The distribution provides core GNU packages such as GNU libc, GCC, and
- Binutils, as well as many GNU and non-GNU applications. The complete
- list of available packages can be browsed
- @url{http://www.gnu.org/software/guix/package-list.html,on-line} or by
- running @command{guix package} (@pxref{Invoking guix package}):
-
- @example
- guix package --list-available
- @end example
-
- Our goal has been to provide a practical 100% free software distribution of
- Linux-based and other variants of GNU, with a focus on the promotion and
- tight integration of GNU components, and an emphasis on programs and
- tools that help users exert that freedom.
-
- Packages are currently available on the following platforms:
-
- @table @code
-
- @item x86_64-linux
- Intel/AMD @code{x86_64} architecture, Linux-Libre kernel;
-
- @item i686-linux
- Intel 32-bit architecture (IA32), Linux-Libre kernel;
-
- @item armhf-linux
- ARMv7-A architecture with hard float, Thumb-2 and VFP3D16 coprocessor,
- using the EABI hard-float ABI, and Linux-Libre kernel.
-
- @item mips64el-linux
- little-endian 64-bit MIPS processors, specifically the Loongson series,
- n32 application binary interface (ABI), and Linux-Libre kernel.
-
- @end table
-
- GuixSD itself is currently only available on @code{i686} and @code{x86_64}.
-
- @noindent
- For information on porting to other architectures or kernels,
- @xref{Porting}.
-
- @menu
- * System Installation:: Installing the whole operating system.
- * System Configuration:: Configuring the operating system.
- * Installing Debugging Files:: Feeding the debugger.
- * Security Updates:: Deploying security fixes quickly.
- * Package Modules:: Packages from the programmer's viewpoint.
- * Packaging Guidelines:: Growing the distribution.
- * Bootstrapping:: GNU/Linux built from scratch.
- * Porting:: Targeting another platform or kernel.
- @end menu
-
- Building this distribution is a cooperative effort, and you are invited
- to join! @xref{Contributing}, for information about how you can help.
-
- @node System Installation
- @section System Installation
-
- @cindex Guix System Distribution
- This section explains how to install the Guix System Distribution
- on a machine. The Guix package manager can
- also be installed on top of a running GNU/Linux system,
- @pxref{Installation}.
-
- @ifinfo
- @c This paragraph is for people reading this from tty2 of the
- @c installation image.
- You're reading this documentation with an Info reader. For details on
- how to use it, hit the @key{RET} key (``return'' or ``enter'') on the
- link that follows: @pxref{Help,,, info, Info: An Introduction}. Hit
- @kbd{l} afterwards to come back here.
- @end ifinfo
-
- @subsection Limitations
-
- As of version @value{VERSION}, the Guix System Distribution (GuixSD) is
- not production-ready. It may contain bugs and lack important
- features. Thus, if you are looking for a stable production system that
- respects your freedom as a computer user, a good solution at this point
- is to consider @url{http://www.gnu.org/distros/free-distros.html, one of
- more established GNU/Linux distributions}. We hope you can soon switch
- to the GuixSD without fear, of course. In the meantime, you can
- also keep using your distribution and try out the package manager on top
- of it (@pxref{Installation}).
-
- Before you proceed with the installation, be aware of the following
- noteworthy limitations applicable to version @value{VERSION}:
-
- @itemize
- @item
- The installation process does not include a graphical user interface and
- requires familiarity with GNU/Linux (see the following subsections to
- get a feel of what that means.)
-
- @item
- The system does not yet provide GNOME and KDE; it provides Xfce, though,
- if graphical desktop environments are your thing.
-
- @item
- Support for the Logical Volume Manager (LVM) is missing.
-
- @item
- Few system services are currently supported out-of-the-box
- (@pxref{Services}).
-
- @item
- On the order of 1,900 packages are available, which means that you may
- occasionally find that a useful package is missing.
- @end itemize
-
- You've been warned. But more than a disclaimer, this is an invitation
- to report issues (and success stories!), and join us in improving it.
- @xref{Contributing}, for more info.
-
- @subsection USB Stick Installation
-
- An installation image for USB sticks can be downloaded from
- @indicateurl{ftp://alpha.gnu.org/gnu/guix/guixsd-usb-install-@value{VERSION}.@var{system}.xz},
- where @var{system} is one of:
-
- @table @code
- @item x86_64-linux
- for a GNU/Linux system on Intel/AMD-compatible 64-bit CPUs;
-
- @item i686-linux
- for a 32-bit GNU/Linux system on Intel-compatible CPUs.
- @end table
-
- This image contains a single partition with the tools necessary for an
- installation. It is meant to be copied @emph{as is} to a large-enough
- USB stick.
-
- To copy the image to a USB stick, follow these steps:
-
- @enumerate
- @item
- Decompress the image using the @command{xz} command:
-
- @example
- xz -d guixsd-usb-install-@value{VERSION}.@var{system}.xz
- @end example
-
- @item
- Insert a USB stick of 1@tie{}GiB or more in your machine, and determine
- its device name. Assuming that USB stick is known as @file{/dev/sdX},
- copy the image with:
-
- @example
- dd if=guixsd-usb-install-@value{VERSION}.x86_64 of=/dev/sdX
- @end example
-
- Access to @file{/dev/sdX} usually requires root privileges.
- @end enumerate
-
- Once this is done, you should be able to reboot the system and boot from
- the USB stick. The latter usually requires you to get in the BIOS' boot
- menu, where you can choose to boot from the USB stick.
-
- @subsection Preparing for Installation
-
- Once you have successfully booted the image on the USB stick, you should
- end up with a root prompt. Several console TTYs are configured and can
- be used to run commands as root. TTY2 shows this documentation,
- browsable using the Info reader commands (@pxref{Help,,, info, Info: An
- Introduction}).
-
- To install the system, you would:
-
- @enumerate
-
- @item
- Configure the network, by running @command{ifconfig eno1 up && dhclient
- eno1} (to get an automatically assigned IP address from the wired
- network interface controller@footnote{
- @c http://cgit.freedesktop.org/systemd/systemd/tree/src/udev/udev-builtin-net_id.c#n20
- The name @code{eno1} is for the first on-board Ethernet controller. The
- interface name for an Ethernet controller that is in the first slot of
- the first PCI bus, for instance, would be @code{enp1s0}. Use
- @command{ifconfig -a} to list all the available network interfaces.}),
- or using the @command{ifconfig} command.
-
- The system automatically loads drivers for your network interface
- controllers.
-
- Setting up network access is almost always a requirement because the
- image does not contain all the software and tools that may be needed.
-
- @item
- Unless this has already been done, you must partition and format the
- target partitions.
-
- Preferably, assign partitions a label so that you can easily and
- reliably refer to them in @code{file-system} declarations (@pxref{File
- Systems}). This is typically done using the @code{-L} option of
- @command{mkfs.ext4} and related commands.
-
- The installation image includes Parted (@pxref{Overview,,, parted, GNU
- Parted User Manual}), @command{fdisk}, Cryptsetup/LUKS for disk
- encryption, and e2fsprogs, the suite of tools to manipulate
- ext2/ext3/ext4 file systems.
-
- @item
- Once that is done, mount the target root partition under @file{/mnt}.
-
- @item
- Lastly, run @code{deco start cow-store /mnt}.
-
- This will make @file{/gnu/store} copy-on-write, such that packages added
- to it during the installation phase will be written to the target disk
- rather than kept in memory.
-
- @end enumerate
-
-
- @subsection Proceeding with the Installation
-
- With the target partitions ready, you now have to edit a file and
- provide the declaration of the operating system to be installed. To
- that end, the installation system comes with two text editors: GNU nano
- (@pxref{Top,,, nano, GNU nano Manual}), and GNU Zile, an Emacs clone.
- It is better to store that file on the target root file system, say, as
- @file{/mnt/etc/config.scm}.
-
- @xref{Using the Configuration System}, for examples of operating system
- configurations. These examples are available under
- @file{/etc/configuration} in the installation image, so you can copy
- them and use them as a starting point for your own configuration.
-
- Once you are done preparing the configuration file, the new system must
- be initialized (remember that the target root file system is mounted
- under @file{/mnt}):
-
- @example
- guix system init /mnt/etc/config.scm /mnt
- @end example
-
- @noindent
- This will copy all the necessary files, and install GRUB on
- @file{/dev/sdX}, unless you pass the @option{--no-grub} option. For
- more information, @pxref{Invoking guix system}. This command may trigger
- downloads or builds of missing packages, which can take some time.
-
- Once that command has completed---and hopefully succeeded!---you can
- run @command{reboot} and boot into the new system. Cross fingers, and
- join us on @code{#guix} on the Freenode IRC network or on
- @file{guix-devel@@gnu.org} to share your experience---good or not so
- good.
-
- @subsection Building the Installation Image
-
- The installation image described above was built using the @command{guix
- system} command, specifically:
-
- @example
- guix system disk-image --image-size=850MiB gnu/system/install.scm
- @end example
-
- @xref{Invoking guix system}, for more information. See
- @file{gnu/system/install.scm} in the source tree for more information
- about the installation image.
-
- @node System Configuration
- @section System Configuration
-
- @cindex system configuration
- The Guix System Distribution supports a consistent whole-system configuration
- mechanism. By that we mean that all aspects of the global system
- configuration---such as the available system services, timezone and
- locale settings, user accounts---are declared in a single place. Such
- a @dfn{system configuration} can be @dfn{instantiated}---i.e., effected.
-
- One of the advantages of putting all the system configuration under the
- control of Guix is that it supports transactional system upgrades, and
- makes it possible to roll-back to a previous system instantiation,
- should something go wrong with the new one (@pxref{Features}). Another
- one is that it makes it easy to replicate the exact same configuration
- across different machines, or at different points in time, without
- having to resort to additional administration tools layered on top of
- the system's own tools.
- @c Yes, we're talking of Puppet, Chef, & co. here. ↑
-
- This section describes this mechanism. First we focus on the system
- administrator's viewpoint---explaining how the system is configured and
- instantiated. Then we show how this mechanism can be extended, for
- instance to support new system services.
-
- @menu
- * Using the Configuration System:: Customizing your GNU system.
- * operating-system Reference:: Detail of operating-system declarations.
- * File Systems:: Configuring file system mounts.
- * Mapped Devices:: Block device extra processing.
- * User Accounts:: Specifying user accounts.
- * Locales:: Language and cultural convention settings.
- * Services:: Specifying system services.
- * Setuid Programs:: Programs running with root privileges.
- * X.509 Certificates:: Authenticating HTTPS servers.
- * Name Service Switch:: Configuring libc's name service switch.
- * Initial RAM Disk:: Linux-Libre bootstrapping.
- * GRUB Configuration:: Configuring the boot loader.
- * Invoking guix system:: Instantiating a system configuration.
- * Defining Services:: Adding new service definitions.
- @end menu
-
- @node Using the Configuration System
- @subsection Using the Configuration System
-
- The operating system is configured by providing an
- @code{operating-system} declaration in a file that can then be passed to
- the @command{guix system} command (@pxref{Invoking guix system}). A
- simple setup, with the default system services, the default Linux-Libre
- kernel, initial RAM disk, and boot loader looks like this:
-
- @findex operating-system
- @lisp
- @include os-config-bare-bones.texi
- @end lisp
-
- This example should be self-describing. Some of the fields defined
- above, such as @code{host-name} and @code{bootloader}, are mandatory.
- Others, such as @code{packages} and @code{services}, can be omitted, in
- which case they get a default value.
-
- @vindex %base-packages
- The @code{packages} field lists
- packages that will be globally visible on the system, for all user
- accounts---i.e., in every user's @code{PATH} environment variable---in
- addition to the per-user profiles (@pxref{Invoking guix package}). The
- @var{%base-packages} variable provides all the tools one would expect
- for basic user and administrator tasks---including the GNU Core
- Utilities, the GNU Networking Utilities, the GNU Zile lightweight text
- editor, @command{find}, @command{grep}, etc. The example above adds
- Emacs to those, taken from the @code{(gnu packages emacs)} module
- (@pxref{Package Modules}).
-
- @vindex %base-services
- The @code{services} field lists @dfn{system services} to be made
- available when the system starts (@pxref{Services}).
- The @code{operating-system} declaration above specifies that, in
- addition to the basic services, we want the @command{lshd} secure shell
- daemon listening on port 2222, and allowing remote @code{root} logins
- (@pxref{Invoking lshd,,, lsh, GNU lsh Manual}). Under the hood,
- @code{lsh-service} arranges so that @code{lshd} is started with the
- right command-line options, possibly with supporting configuration files
- generated as needed (@pxref{Defining Services}). @xref{operating-system
- Reference}, for details about the available @code{operating-system}
- fields.
-
- The configuration for a typical ``desktop'' usage, with the X11 display
- server, a desktop environment, network management, an SSH server, and
- more, would look like this:
-
- @lisp
- @include os-config-desktop.texi
- @end lisp
-
- @xref{Desktop Services}, for the exact list of services provided by
- @var{%desktop-services}. @xref{X.509 Certificates}, for background
- information about the @code{nss-certs} package that is used here.
-
- Assuming the above snippet is stored in the @file{my-system-config.scm}
- file, the @command{guix system reconfigure my-system-config.scm} command
- instantiates that configuration, and makes it the default GRUB boot
- entry (@pxref{Invoking guix system}). The normal way to change the
- system's configuration is by updating this file and re-running the
- @command{guix system} command.
-
- At the Scheme level, the bulk of an @code{operating-system} declaration
- is instantiated with the following monadic procedure (@pxref{The Store
- Monad}):
-
- @deffn {Monadic Procedure} operating-system-derivation os
- Return a derivation that builds @var{os}, an @code{operating-system}
- object (@pxref{Derivations}).
-
- The output of the derivation is a single directory that refers to all
- the packages, configuration files, and other supporting files needed to
- instantiate @var{os}.
- @end deffn
-
- @node operating-system Reference
- @subsection @code{operating-system} Reference
-
- This section summarizes all the options available in
- @code{operating-system} declarations (@pxref{Using the Configuration
- System}).
-
- @deftp {Data Type} operating-system
- This is the data type representing an operating system configuration.
- By that, we mean all the global system configuration, not per-user
- configuration (@pxref{Using the Configuration System}).
-
- @table @asis
- @item @code{kernel} (default: @var{linux-libre})
- The package object of the operating system kernel to use@footnote{Currently
- only the Linux-libre kernel is supported. In the future, it will be
- possible to use the GNU@tie{}Hurd.}.
-
- @item @code{bootloader}
- The system bootloader configuration object. @xref{GRUB Configuration}.
-
- @item @code{initrd} (default: @code{base-initrd})
- A two-argument monadic procedure that returns an initial RAM disk for
- the Linux kernel. @xref{Initial RAM Disk}.
-
- @item @code{firmware} (default: @var{%base-firmware})
- @cindex firmware
- List of firmware packages loadable by the operating system kernel.
-
- The default includes firmware needed for Atheros-based WiFi devices
- (Linux-libre module @code{ath9k}.)
-
- @item @code{host-name}
- The host name.
-
- @item @code{hosts-file}
- @cindex hosts file
- A file-like object (@pxref{G-Expressions, file-like objects}) for use as
- @file{/etc/hosts} (@pxref{Host Names,,, libc, The GNU C Library
- Reference Manual}). The default is a file with entries for
- @code{localhost} and @var{host-name}.
-
- @item @code{mapped-devices} (default: @code{'()})
- A list of mapped devices. @xref{Mapped Devices}.
-
- @item @code{file-systems}
- A list of file systems. @xref{File Systems}.
-
- @item @code{swap-devices} (default: @code{'()})
- @cindex swap devices
- A list of strings identifying devices to be used for ``swap space''
- (@pxref{Memory Concepts,,, libc, The GNU C Library Reference Manual}).
- For example, @code{'("/dev/sda3")}.
-
- @item @code{users} (default: @code{%base-user-accounts})
- @itemx @code{groups} (default: @var{%base-groups})
- List of user accounts and groups. @xref{User Accounts}.
-
- @item @code{skeletons} (default: @code{(default-skeletons)})
- A monadic list of pairs of target file name and files. These are the
- files that will be used as skeletons as new accounts are created.
-
- For instance, a valid value may look like this:
-
- @example
- (mlet %store-monad ((bashrc (text-file "bashrc" "\
- export PATH=$HOME/.guix-profile/bin")))
- (return `((".bashrc" ,bashrc))))
- @end example
-
- @item @code{issue} (default: @var{%default-issue})
- A string denoting the contents of the @file{/etc/issue} file, which is
- what displayed when users log in on a text console.
-
- @item @code{packages} (default: @var{%base-packages})
- The set of packages installed in the global profile, which is accessible
- at @file{/run/current-system/profile}.
-
- The default set includes core utilities, but it is good practice to
- install non-core utilities in user profiles (@pxref{Invoking guix
- package}).
-
- @item @code{timezone}
- A timezone identifying string---e.g., @code{"Europe/Paris"}.
-
- @item @code{locale} (default: @code{"en_US.utf8"})
- The name of the default locale (@pxref{Locale Names,,, libc, The GNU C
- Library Reference Manual}). @xref{Locales}, for more information.
-
- @item @code{locale-definitions} (default: @var{%default-locale-definitions})
- The list of locale definitions to be compiled and that may be used at
- run time. @xref{Locales}.
-
- @item @code{name-service-switch} (default: @var{%default-nss})
- Configuration of libc's name service switch (NSS)---a
- @code{<name-service-switch>} object. @xref{Name Service Switch}, for
- details.
-
- @item @code{services} (default: @var{%base-services})
- A list of monadic values denoting system services. @xref{Services}.
-
- @item @code{pam-services} (default: @code{(base-pam-services)})
- @cindex PAM
- @cindex pluggable authentication modules
- Linux @dfn{pluggable authentication module} (PAM) services.
- @c FIXME: Add xref to PAM services section.
-
- @item @code{setuid-programs} (default: @var{%setuid-programs})
- List of string-valued G-expressions denoting setuid programs.
- @xref{Setuid Programs}.
-
- @item @code{sudoers} (default: @var{%sudoers-specification})
- @cindex sudoers
- The contents of the @file{/etc/sudoers} file as a file-like object
- (@pxref{G-Expressions, @code{local-file} and @code{plain-file}}).
-
- This file specifies which users can use the @command{sudo} command, what
- they are allowed to do, and what privileges they may gain. The default
- is that only @code{root} and members of the @code{wheel} group may use
- @code{sudo}.
-
- @end table
- @end deftp
-
- @node File Systems
- @subsection File Systems
-
- The list of file systems to be mounted is specified in the
- @code{file-systems} field of the operating system's declaration
- (@pxref{Using the Configuration System}). Each file system is declared
- using the @code{file-system} form, like this:
-
- @example
- (file-system
- (mount-point "/home")
- (device "/dev/sda3")
- (type "ext4"))
- @end example
-
- As usual, some of the fields are mandatory---those shown in the example
- above---while others can be omitted. These are described below.
-
- @deftp {Data Type} file-system
- Objects of this type represent file systems to be mounted. They
- contain the following members:
-
- @table @asis
- @item @code{type}
- This is a string specifying the type of the file system---e.g.,
- @code{"ext4"}.
-
- @item @code{mount-point}
- This designates the place where the file system is to be mounted.
-
- @item @code{device}
- This names the ``source'' of the file system. By default it is the name
- of a node under @file{/dev}, but its meaning depends on the @code{title}
- field described below.
-
- @item @code{title} (default: @code{'device})
- This is a symbol that specifies how the @code{device} field is to be
- interpreted.
-
- When it is the symbol @code{device}, then the @code{device} field is
- interpreted as a file name; when it is @code{label}, then @code{device}
- is interpreted as a partition label name; when it is @code{uuid},
- @code{device} is interpreted as a partition unique identifier (UUID).
-
- The @code{label} and @code{uuid} options offer a way to refer to disk
- partitions without having to hard-code their actual device name.
-
- However, when a file system's source is a mapped device (@pxref{Mapped
- Devices}), its @code{device} field @emph{must} refer to the mapped
- device name---e.g., @file{/dev/mapper/root-partition}---and consequently
- @code{title} must be set to @code{'device}. This is required so that
- the system knows that mounting the file system depends on having the
- corresponding device mapping established.
-
- @item @code{flags} (default: @code{'()})
- This is a list of symbols denoting mount flags. Recognized flags
- include @code{read-only}, @code{bind-mount}, @code{no-dev} (disallow
- access to special files), @code{no-suid} (ignore setuid and setgid
- bits), and @code{no-exec} (disallow program execution.)
-
- @item @code{options} (default: @code{#f})
- This is either @code{#f}, or a string denoting mount options.
-
- @item @code{needed-for-boot?} (default: @code{#f})
- This Boolean value indicates whether the file system is needed when
- booting. If that is true, then the file system is mounted when the
- initial RAM disk (initrd) is loaded. This is always the case, for
- instance, for the root file system.
-
- @item @code{check?} (default: @code{#t})
- This Boolean indicates whether the file system needs to be checked for
- errors before being mounted.
-
- @item @code{create-mount-point?} (default: @code{#f})
- When true, the mount point is created if it does not exist yet.
-
- @end table
- @end deftp
-
- The @code{(gnu system file-systems)} exports the following useful
- variables.
-
- @defvr {Scheme Variable} %base-file-systems
- These are essential file systems that are required on normal systems,
- such as @var{%devtmpfs-file-system} and @var{%immutable-store} (see
- below.) Operating system declarations should always contain at least
- these.
- @end defvr
-
- @defvr {Scheme Variable} %devtmpfs-file-system
- The @code{devtmpfs} file system to be mounted on @file{/dev}. This is a
- requirement for udev (@pxref{Base Services, @code{udev-service}}).
- @end defvr
-
- @defvr {Scheme Variable} %pseudo-terminal-file-system
- This is the file system to be mounted as @file{/dev/pts}. It supports
- @dfn{pseudo-terminals} created @i{via} @code{openpty} and similar
- functions (@pxref{Pseudo-Terminals,,, libc, The GNU C Library Reference
- Manual}). Pseudo-terminals are used by terminal emulators such as
- @command{xterm}.
- @end defvr
-
- @defvr {Scheme Variable} %shared-memory-file-system
- This file system is mounted as @file{/dev/shm} and is used to support
- memory sharing across processes (@pxref{Memory-mapped I/O,
- @code{shm_open},, libc, The GNU C Library Reference Manual}).
- @end defvr
-
- @defvr {Scheme Variable} %immutable-store
- This file system performs a read-only ``bind mount'' of
- @file{/gnu/store}, making it read-only for all the users including
- @code{root}. This prevents against accidental modification by software
- running as @code{root} or by system administrators.
-
- The daemon itself is still able to write to the store: it remounts it
- read-write in its own ``name space.''
- @end defvr
-
- @defvr {Scheme Variable} %binary-format-file-system
- The @code{binfmt_misc} file system, which allows handling of arbitrary
- executable file types to be delegated to user space. This requires the
- @code{binfmt.ko} kernel module to be loaded.
- @end defvr
-
- @defvr {Scheme Variable} %fuse-control-file-system
- The @code{fusectl} file system, which allows unprivileged users to mount
- and unmount user-space FUSE file systems. This requires the
- @code{fuse.ko} kernel module to be loaded.
- @end defvr
-
- @node Mapped Devices
- @subsection Mapped Devices
-
- @cindex device mapping
- @cindex mapped devices
- The Linux kernel has a notion of @dfn{device mapping}: a block device,
- such as a hard disk partition, can be @dfn{mapped} into another device,
- with additional processing over the data that flows through
- it@footnote{Note that the GNU@tie{}Hurd makes no difference between the
- concept of a ``mapped device'' and that of a file system: both boil down
- to @emph{translating} input/output operations made on a file to
- operations on its backing store. Thus, the Hurd implements mapped
- devices, like file systems, using the generic @dfn{translator} mechanism
- (@pxref{Translators,,, hurd, The GNU Hurd Reference Manual}).}. A
- typical example is encryption device mapping: all writes to the mapped
- device are encrypted, and all reads are deciphered, transparently.
-
- Mapped devices are declared using the @code{mapped-device} form:
-
- @example
- (mapped-device
- (source "/dev/sda3")
- (target "home")
- (type luks-device-mapping))
- @end example
-
- @noindent
- @cindex disk encryption
- @cindex LUKS
- This example specifies a mapping from @file{/dev/sda3} to
- @file{/dev/mapper/home} using LUKS---the
- @url{http://code.google.com/p/cryptsetup,Linux Unified Key Setup}, a
- standard mechanism for disk encryption. The @file{/dev/mapper/home}
- device can then be used as the @code{device} of a @code{file-system}
- declaration (@pxref{File Systems}). The @code{mapped-device} form is
- detailed below.
-
- @deftp {Data Type} mapped-device
- Objects of this type represent device mappings that will be made when
- the system boots up.
-
- @table @code
- @item source
- This string specifies the name of the block device to be mapped, such as
- @code{"/dev/sda3"}.
-
- @item target
- This string specifies the name of the mapping to be established. For
- example, specifying @code{"my-partition"} will lead to the creation of
- the @code{"/dev/mapper/my-partition"} device.
-
- @item type
- This must be a @code{mapped-device-kind} object, which specifies how
- @var{source} is mapped to @var{target}.
- @end table
- @end deftp
-
- @defvr {Scheme Variable} luks-device-mapping
- This defines LUKS block device encryption using the @command{cryptsetup}
- command, from the same-named package. This relies on the
- @code{dm-crypt} Linux kernel module.
- @end defvr
-
- @node User Accounts
- @subsection User Accounts
-
- User accounts and groups are entirely managed through the
- @code{operating-system} declaration. They are specified with the
- @code{user-account} and @code{user-group} forms:
-
- @example
- (user-account
- (name "alice")
- (group "users")
- (supplementary-groups '("wheel" ;allow use of sudo, etc.
- "audio" ;sound card
- "video" ;video devices such as webcams
- "cdrom")) ;the good ol' CD-ROM
- (comment "Bob's sister")
- (home-directory "/home/alice"))
- @end example
-
- When booting or upon completion of @command{guix system reconfigure},
- the system ensures that only the user accounts and groups specified in
- the @code{operating-system} declaration exist, and with the specified
- properties. Thus, account or group creations or modifications made by
- directly invoking commands such as @command{useradd} are lost upon
- reconfiguration or reboot. This ensures that the system remains exactly
- as declared.
-
- @deftp {Data Type} user-account
- Objects of this type represent user accounts. The following members may
- be specified:
-
- @table @asis
- @item @code{name}
- The name of the user account.
-
- @item @code{group}
- This is the name (a string) or identifier (a number) of the user group
- this account belongs to.
-
- @item @code{supplementary-groups} (default: @code{'()})
- Optionally, this can be defined as a list of group names that this
- account belongs to.
-
- @item @code{uid} (default: @code{#f})
- This is the user ID for this account (a number), or @code{#f}. In the
- latter case, a number is automatically chosen by the system when the
- account is created.
-
- @item @code{comment} (default: @code{""})
- A comment about the account, such as the account's owner full name.
-
- @item @code{home-directory}
- This is the name of the home directory for the account.
-
- @item @code{shell} (default: Bash)
- This is a G-expression denoting the file name of a program to be used as
- the shell (@pxref{G-Expressions}).
-
- @item @code{system?} (default: @code{#f})
- This Boolean value indicates whether the account is a ``system''
- account. System accounts are sometimes treated specially; for instance,
- graphical login managers do not list them.
-
- @item @code{password} (default: @code{#f})
- You would normally leave this field to @code{#f}, initialize user
- passwords as @code{root} with the @command{passwd} command, and then let
- users change it with @command{passwd}. Passwords set with
- @command{passwd} are of course preserved across reboot and
- reconfiguration.
-
- If you @emph{do} want to have a preset password for an account, then
- this field must contain the encrypted password, as a string.
- @xref{crypt,,, libc, The GNU C Library Reference Manual}, for more information
- on password encryption, and @ref{Encryption,,, guile, GNU Guile Reference
- Manual}, for information on Guile's @code{crypt} procedure.
-
- @end table
- @end deftp
-
- User group declarations are even simpler:
-
- @example
- (user-group (name "students"))
- @end example
-
- @deftp {Data Type} user-group
- This type is for, well, user groups. There are just a few fields:
-
- @table @asis
- @item @code{name}
- The group's name.
-
- @item @code{id} (default: @code{#f})
- The group identifier (a number). If @code{#f}, a new number is
- automatically allocated when the group is created.
-
- @item @code{system?} (default: @code{#f})
- This Boolean value indicates whether the group is a ``system'' group.
- System groups have low numerical IDs.
-
- @item @code{password} (default: @code{#f})
- What, user groups can have a password? Well, apparently yes. Unless
- @code{#f}, this field specifies the group's password.
-
- @end table
- @end deftp
-
- For convenience, a variable lists all the basic user groups one may
- expect:
-
- @defvr {Scheme Variable} %base-groups
- This is the list of basic user groups that users and/or packages expect
- to be present on the system. This includes groups such as ``root'',
- ``wheel'', and ``users'', as well as groups used to control access to
- specific devices such as ``audio'', ``disk'', and ``cdrom''.
- @end defvr
-
- @defvr {Scheme Variable} %base-user-accounts
- This is the list of basic system accounts that programs may expect to
- find on a GNU/Linux system, such as the ``nobody'' account.
-
- Note that the ``root'' account is not included here. It is a
- special-case and is automatically added whether or not it is specified.
- @end defvr
-
- @node Locales
- @subsection Locales
-
- @cindex locale
- A @dfn{locale} defines cultural conventions for a particular language
- and region of the world (@pxref{Locales,,, libc, The GNU C Library
- Reference Manual}). Each locale has a name that typically has the form
- @code{@var{language}_@var{territory}.@var{charset}}---e.g.,
- @code{fr_LU.utf8} designates the locale for the French language, with
- cultural conventions from Luxembourg, and using the UTF-8 encoding.
-
- @cindex locale definition
- Usually, you will want to specify the default locale for the machine
- using the @code{locale} field of the @code{operating-system} declaration
- (@pxref{operating-system Reference, @code{locale}}).
-
- That locale must be among the @dfn{locale definitions} that are known to
- the system---and these are specified in the @code{locale-definitions}
- slot of @code{operating-system}. The default value includes locale
- definition for some widely used locales, but not for all the available
- locales, in order to save space.
-
- If the locale specified in the @code{locale} field is not among the
- definitions listed in @code{locale-definitions}, @command{guix system}
- raises an error. In that case, you should add the locale definition to
- the @code{locale-definitions} field. For instance, to add the North
- Frisian locale for Germany, the value of that field may be:
-
- @example
- (cons (locale-definition
- (name "fy_DE.utf8") (source "fy_DE"))
- %default-locale-definitions)
- @end example
-
- Likewise, to save space, one might want @code{locale-definitions} to
- list only the locales that are actually used, as in:
-
- @example
- (list (locale-definition
- (name "ja_JP.eucjp") (source "ja_JP")
- (charset "EUC-JP")))
- @end example
-
- The @code{locale-definition} form is provided by the @code{(gnu system
- locale)} module. Details are given below.
-
- @deftp {Data Type} locale-definition
- This is the data type of a locale definition.
-
- @table @asis
-
- @item @code{name}
- The name of the locale. @xref{Locale Names,,, libc, The GNU C Library
- Reference Manual}, for more information on locale names.
-
- @item @code{source}
- The name of the source for that locale. This is typically the
- @code{@var{language}_@var{territory}} part of the locale name.
-
- @item @code{charset} (default: @code{"UTF-8"})
- The ``character set'' or ``code set'' for that locale,
- @uref{http://www.iana.org/assignments/character-sets, as defined by
- IANA}.
-
- @end table
- @end deftp
-
- @defvr {Scheme Variable} %default-locale-definitions
- An arbitrary list of commonly used locales, used as the default value of
- the @code{locale-definitions} field of @code{operating-system}
- declarations.
- @end defvr
-
- @node Services
- @subsection Services
-
- @cindex system services
- An important part of preparing an @code{operating-system} declaration is
- listing @dfn{system services} and their configuration (@pxref{Using the
- Configuration System}). System services are typically daemons launched
- when the system boots, or other actions needed at that time---e.g.,
- configuring network access.
-
- Services are managed by GNU@tie{}dmd (@pxref{Introduction,,, dmd, GNU
- dmd Manual}). On a running system, the @command{deco} command allows
- you to list the available services, show their status, start and stop
- them, or do other specific operations (@pxref{Jump Start,,, dmd, GNU dmd
- Manual}). For example:
-
- @example
- # deco status dmd
- @end example
-
- The above command, run as @code{root}, lists the currently defined
- services. The @command{deco doc} command shows a synopsis of the given
- service:
-
- @example
- # deco doc nscd
- Run libc's name service cache daemon (nscd).
- @end example
-
- The @command{start}, @command{stop}, and @command{restart} sub-commands
- have the effect you would expect. For instance, the commands below stop
- the nscd service and restart the Xorg display server:
-
- @example
- # deco stop nscd
- Service nscd has been stopped.
- # deco restart xorg-server
- Service xorg-server has been stopped.
- Service xorg-server has been started.
- @end example
-
- The following sections document the available services, starting with
- the core services, that may be used in an @code{operating-system}
- declaration.
-
- @menu
- * Base Services:: Essential system services.
- * Networking Services:: Network setup, SSH daemon, etc.
- * X Window:: Graphical display.
- * Desktop Services:: D-Bus and desktop services.
- * Database Services:: SQL databases.
- * Various Services:: Other services.
- @end menu
-
- @node Base Services
- @subsubsection Base Services
-
- The @code{(gnu services base)} module provides definitions for the basic
- services that one expects from the system. The services exported by
- this module are listed below.
-
- @defvr {Scheme Variable} %base-services
- This variable contains a list of basic services@footnote{Technically,
- this is a list of monadic services. @xref{The Store Monad}.} one would
- expect from the system: a login service (mingetty) on each tty, syslogd,
- libc's name service cache daemon (nscd), the udev device manager, and
- more.
-
- This is the default value of the @code{services} field of
- @code{operating-system} declarations. Usually, when customizing a
- system, you will want to append services to @var{%base-services}, like
- this:
-
- @example
- (cons* (avahi-service) (lsh-service) %base-services)
- @end example
- @end defvr
-
- @deffn {Monadic Procedure} host-name-service @var{name}
- Return a service that sets the host name to @var{name}.
- @end deffn
-
- @deffn {Monadic Procedure} mingetty-service @var{tty} [#:motd] @
- [#:auto-login #f] [#:login-program] [#:login-pause? #f] @
- [#:allow-empty-passwords? #f]
- Return a service to run mingetty on @var{tty}.
-
- When @var{allow-empty-passwords?} is true, allow empty log-in password. When
- @var{auto-login} is true, it must be a user name under which to log-in
- automatically. @var{login-pause?} can be set to @code{#t} in conjunction with
- @var{auto-login}, in which case the user will have to press a key before the
- login shell is launched.
-
- When true, @var{login-program} is a gexp or a monadic gexp denoting the name
- of the log-in program (the default is the @code{login} program from the Shadow
- tool suite.)
-
- @var{motd} is a monadic value containing a text file to use as
- the ``message of the day''.
- @end deffn
-
- @cindex name service cache daemon
- @cindex nscd
- @deffn {Monadic Procedure} nscd-service [@var{config}] [#:glibc glibc] @
- [#:name-services '()]
- Return a service that runs libc's name service cache daemon (nscd) with
- the given @var{config}---an @code{<nscd-configuration>} object.
- Optionally, @code{#:name-services} is a list of packages that provide
- name service switch (NSS) modules needed by nscd. @xref{Name Service
- Switch}, for an example.
- @end deffn
-
- @defvr {Scheme Variable} %nscd-default-configuration
- This is the default @code{<nscd-configuration>} value (see below) used
- by @code{nscd-service}. This uses the caches defined by
- @var{%nscd-default-caches}; see below.
- @end defvr
-
- @deftp {Data Type} nscd-configuration
- This is the type representing the name service cache daemon (nscd)
- configuration.
-
- @table @asis
-
- @item @code{log-file} (default: @code{"/var/log/nscd.log"})
- Name of nscd's log file. This is where debugging output goes when
- @code{debug-level} is strictly positive.
-
- @item @code{debug-level} (default: @code{0})
- Integer denoting the debugging levels. Higher numbers mean more
- debugging output is logged.
-
- @item @code{caches} (default: @var{%nscd-default-caches})
- List of @code{<nscd-cache>} objects denoting things to be cached; see
- below.
-
- @end table
- @end deftp
-
- @deftp {Data Type} nscd-cache
- Data type representing a cache database of nscd and its parameters.
-
- @table @asis
-
- @item @code{database}
- This is a symbol representing the name of the database to be cached.
- Valid values are @code{passwd}, @code{group}, @code{hosts}, and
- @code{services}, which designate the corresponding NSS database
- (@pxref{NSS Basics,,, libc, The GNU C Library Reference Manual}).
-
- @item @code{positive-time-to-live}
- @itemx @code{negative-time-to-live} (default: @code{20})
- A number representing the number of seconds during which a positive or
- negative lookup result remains in cache.
-
- @item @code{check-files?} (default: @code{#t})
- Whether to check for updates of the files corresponding to
- @var{database}.
-
- For instance, when @var{database} is @code{hosts}, setting this flag
- instructs nscd to check for updates in @file{/etc/hosts} and to take
- them into account.
-
- @item @code{persistent?} (default: @code{#t})
- Whether the cache should be stored persistently on disk.
-
- @item @code{shared?} (default: @code{#t})
- Whether the cache should be shared among users.
-
- @item @code{max-database-size} (default: 32@tie{}MiB)
- Maximum size in bytes of the database cache.
-
- @c XXX: 'suggested-size' and 'auto-propagate?' seem to be expert
- @c settings, so leave them out.
-
- @end table
- @end deftp
-
- @defvr {Scheme Variable} %nscd-default-caches
- List of @code{<nscd-cache>} objects used by default by
- @code{nscd-configuration} (see above.)
-
- It enables persistent and aggressive caching of service and host name
- lookups. The latter provides better host name lookup performance,
- resilience in the face of unreliable name servers, and also better
- privacy---often the result of host name lookups is in local cache, so
- external name servers do not even need to be queried.
- @end defvr
-
-
- @deffn {Monadic Procedure} syslog-service [#:config-file #f]
- Return a service that runs @code{syslogd}. If configuration file name
- @var{config-file} is not specified, use some reasonable default
- settings.
- @end deffn
-
- @deffn {Monadic Procedure} guix-service [#:guix guix] @
- [#:builder-group "guixbuild"] [#:build-accounts 10] @
- [#:authorize-hydra-key? #t] [#:use-substitutes? #t] @
- [#:extra-options '()]
- Return a service that runs the build daemon from @var{guix}, and has
- @var{build-accounts} user accounts available under @var{builder-group}.
-
- When @var{authorize-hydra-key?} is true, the @code{hydra.gnu.org} public key
- provided by @var{guix} is authorized upon activation, meaning that substitutes
- from @code{hydra.gnu.org} are used by default.
-
- If @var{use-substitutes?} is false, the daemon is run with
- @option{--no-substitutes} (@pxref{Invoking guix-daemon,
- @option{--no-substitutes}}).
-
- Finally, @var{extra-options} is a list of additional command-line options
- passed to @command{guix-daemon}.
- @end deffn
-
- @deffn {Monadic Procedure} udev-service [#:udev udev]
- Run @var{udev}, which populates the @file{/dev} directory dynamically.
- @end deffn
-
- @deffn {Monadic Procedure} console-keymap-service @var{file}
- Return a service to load console keymap from @var{file} using
- @command{loadkeys} command.
- @end deffn
-
-
- @node Networking Services
- @subsubsection Networking Services
-
- The @code{(gnu services networking)} module provides services to configure
- the network interface.
-
- @cindex DHCP, networking service
- @deffn {Monadic Procedure} dhcp-client-service [#:dhcp @var{isc-dhcp}]
- Return a service that runs @var{dhcp}, a Dynamic Host Configuration
- Protocol (DHCP) client, on all the non-loopback network interfaces.
- @end deffn
-
- @deffn {Monadic Procedure} static-networking-service @var{interface} @var{ip} @
- [#:gateway #f] [#:name-services @code{'()}]
- Return a service that starts @var{interface} with address @var{ip}. If
- @var{gateway} is true, it must be a string specifying the default network
- gateway.
- @end deffn
-
- @cindex wicd
- @deffn {Monadic Procedure} wicd-service [#:wicd @var{wicd}]
- Return a service that runs @url{https://launchpad.net/wicd,Wicd}, a
- network manager that aims to simplify wired and wireless networking.
- @end deffn
-
- @deffn {Monadic Procedure} ntp-service [#:ntp @var{ntp}] @
- [#:name-service @var{%ntp-servers}]
- Return a service that runs the daemon from @var{ntp}, the
- @uref{http://www.ntp.org, Network Time Protocol package}. The daemon will
- keep the system clock synchronized with that of @var{servers}.
- @end deffn
-
- @defvr {Scheme Variable} %ntp-servers
- List of host names used as the default NTP servers.
- @end defvr
-
- @deffn {Monadic Procedure} tor-service [#:tor tor]
- Return a service to run the @uref{https://torproject.org,Tor} daemon.
-
- The daemon runs with the default settings (in particular the default exit
- policy) as the @code{tor} unprivileged user.
- @end deffn
-
- @deffn {Monadic Procedure} bitlbee-service [#:bitlbee bitlbee] @
- [#:interface "127.0.0.1"] [#:port 6667] @
- [#:extra-settings ""]
- Return a service that runs @url{http://bitlbee.org,BitlBee}, a daemon that
- acts as a gateway between IRC and chat networks.
-
- The daemon will listen to the interface corresponding to the IP address
- specified in @var{interface}, on @var{port}. @code{127.0.0.1} means that only
- local clients can connect, whereas @code{0.0.0.0} means that connections can
- come from any networking interface.
-
- In addition, @var{extra-settings} specifies a string to append to the
- configuration file.
- @end deffn
-
- Furthermore, @code{(gnu services ssh)} provides the following service.
-
- @deffn {Monadic Procedure} lsh-service [#:host-key "/etc/lsh/host-key"] @
- [#:daemonic? #t] [#:interfaces '()] [#:port-number 22] @
- [#:allow-empty-passwords? #f] [#:root-login? #f] @
- [#:syslog-output? #t] [#:x11-forwarding? #t] @
- [#:tcp/ip-forwarding? #t] [#:password-authentication? #t] @
- [#:public-key-authentication? #t] [#:initialize? #t]
- Run the @command{lshd} program from @var{lsh} to listen on port @var{port-number}.
- @var{host-key} must designate a file containing the host key, and readable
- only by root.
-
- When @var{daemonic?} is true, @command{lshd} will detach from the
- controlling terminal and log its output to syslogd, unless one sets
- @var{syslog-output?} to false. Obviously, it also makes lsh-service
- depend on existence of syslogd service. When @var{pid-file?} is true,
- @command{lshd} writes its PID to the file called @var{pid-file}.
-
- When @var{initialize?} is true, automatically create the seed and host key
- upon service activation if they do not exist yet. This may take long and
- require interaction.
-
- When @var{initialize?} is false, it is up to the user to initialize the
- randomness generator (@pxref{lsh-make-seed,,, lsh, LSH Manual}), and to create
- a key pair with the private key stored in file @var{host-key} (@pxref{lshd
- basics,,, lsh, LSH Manual}).
-
- When @var{interfaces} is empty, lshd listens for connections on all the
- network interfaces; otherwise, @var{interfaces} must be a list of host names
- or addresses.
-
- @var{allow-empty-passwords?} specifies whether to accept log-ins with empty
- passwords, and @var{root-login?} specifies whether to accept log-ins as
- root.
-
- The other options should be self-descriptive.
- @end deffn
-
- @defvr {Scheme Variable} %facebook-host-aliases
- This variable contains a string for use in @file{/etc/hosts}
- (@pxref{Host Names,,, libc, The GNU C Library Reference Manual}). Each
- line contains a entry that maps a known server name of the Facebook
- on-line service---e.g., @code{www.facebook.com}---to the local
- host---@code{127.0.0.1} or its IPv6 equivalent, @code{::1}.
-
- This variable is typically used in the @code{hosts-file} field of an
- @code{operating-system} declaration (@pxref{operating-system Reference,
- @file{/etc/hosts}}):
-
- @example
- (use-modules (gnu) (guix))
-
- (operating-system
- (host-name "mymachine")
- ;; ...
- (hosts-file
- ;; Create a /etc/hosts file with aliases for "localhost"
- ;; and "mymachine", as well as for Facebook servers.
- (plain-file "hosts"
- (string-append (local-host-aliases host-name)
- %facebook-host-aliases))))
- @end example
-
- This mechanism can prevent programs running locally, such as Web
- browsers, from accessing Facebook.
- @end defvr
-
- The @code{(gnu services avahi)} provides the following definition.
-
- @deffn {Monadic Procedure} avahi-service [#:avahi @var{avahi}] @
- [#:host-name #f] [#:publish? #t] [#:ipv4? #t] @
- [#:ipv6? #t] [#:wide-area? #f] @
- [#:domains-to-browse '()]
- Return a service that runs @command{avahi-daemon}, a system-wide
- mDNS/DNS-SD responder that allows for service discovery and
- "zero-configuration" host name lookups (see @uref{http://avahi.org/}).
-
- If @var{host-name} is different from @code{#f}, use that as the host name to
- publish for this machine; otherwise, use the machine's actual host name.
-
- When @var{publish?} is true, publishing of host names and services is allowed;
- in particular, avahi-daemon will publish the machine's host name and IP
- address via mDNS on the local network.
-
- When @var{wide-area?} is true, DNS-SD over unicast DNS is enabled.
-
- Boolean values @var{ipv4?} and @var{ipv6?} determine whether to use IPv4/IPv6
- sockets.
- @end deffn
-
-
- @node X Window
- @subsubsection X Window
-
- Support for the X Window graphical display system---specifically
- Xorg---is provided by the @code{(gnu services xorg)} module. Note that
- there is no @code{xorg-service} procedure. Instead, the X server is
- started by the @dfn{login manager}, currently SLiM.
-
- @deffn {Monadic Procedure} slim-service [#:allow-empty-passwords? #f] @
- [#:auto-login? #f] [#:default-user ""] [#:startx] @
- [#:theme @var{%default-slim-theme}] @
- [#:theme-name @var{%default-slim-theme-name}]
- Return a service that spawns the SLiM graphical login manager, which in
- turn starts the X display server with @var{startx}, a command as returned by
- @code{xorg-start-command}.
-
- @cindex X session
-
- SLiM automatically looks for session types described by the @file{.desktop}
- files in @file{/run/current-system/profile/share/xsessions} and allows users
- to choose a session from the log-in screen using @kbd{F1}. Packages such as
- @var{xfce}, @var{sawfish}, and @var{ratpoison} provide @file{.desktop} files;
- adding them to the system-wide set of packages automatically makes them
- available at the log-in screen.
-
- In addition, @file{~/.xsession} files are honored. When available,
- @file{~/.xsession} must be an executable that starts a window manager
- and/or other X clients.
-
- When @var{allow-empty-passwords?} is true, allow logins with an empty
- password. When @var{auto-login?} is true, log in automatically as
- @var{default-user}.
-
- If @var{theme} is @code{#f}, the use the default log-in theme; otherwise
- @var{theme} must be a gexp denoting the name of a directory containing the
- theme to use. In that case, @var{theme-name} specifies the name of the
- theme.
- @end deffn
-
- @defvr {Scheme Variable} %default-theme
- @defvrx {Scheme Variable} %default-theme-name
- The G-Expression denoting the default SLiM theme and its name.
- @end defvr
-
- @deffn {Monadic Procedure} xorg-start-command [#:guile] @
- [#:configuration-file #f] [#:xorg-server @var{xorg-server}]
- Return a derivation that builds a @var{guile} script to start the X server
- from @var{xorg-server}. @var{configuration-file} is the server configuration
- file or a derivation that builds it; when omitted, the result of
- @code{xorg-configuration-file} is used.
-
- Usually the X server is started by a login manager.
- @end deffn
-
- @deffn {Monadic Procedure} xorg-configuration-file @
- [#:drivers '()] [#:resolutions '()] [#:extra-config '()]
- Return a configuration file for the Xorg server containing search paths for
- all the common drivers.
-
- @var{drivers} must be either the empty list, in which case Xorg chooses a
- graphics driver automatically, or a list of driver names that will be tried in
- this order---e.g., @code{(\"modesetting\" \"vesa\")}.
-
- Likewise, when @var{resolutions} is the empty list, Xorg chooses an
- appropriate screen resolution; otherwise, it must be a list of
- resolutions---e.g., @code{((1024 768) (640 480))}.
-
- Last, @var{extra-config} is a list of strings or objects appended to the
- @code{text-file*} argument list. It is used to pass extra text to be added
- verbatim to the configuration file.
- @end deffn
-
- @node Desktop Services
- @subsubsection Desktop Services
-
- The @code{(gnu services desktop)} module provides services that are
- usually useful in the context of a ``desktop'' setup---that is, on a
- machine running a graphical display server, possibly with graphical user
- interfaces, etc.
-
- To simplify things, the module defines a variable containing the set of
- services that users typically expect on a machine with a graphical
- environment and networking:
-
- @defvr {Scheme Variable} %desktop-services
- This is a list of services that builds upon @var{%base-services} and
- adds or adjust services for a typical ``desktop'' setup.
-
- In particular, it adds a graphical login manager (@pxref{X Window,
- @code{slim-service}}), a network management tool (@pxref{Networking
- Services, @code{wicd-service}}), energy and color management services,
- an NTP client and an SSH server (@pxref{Networking Services}), the Avahi
- daemon, and has the name service switch service configured to be able to
- use @code{nss-mdns} (@pxref{Name Service Switch, mDNS}).
- @end defvr
-
- The @var{%desktop-services} variable can be used as the @code{services}
- field of an @code{operating-system} declaration (@pxref{operating-system
- Reference, @code{services}}).
-
- The actual service definitions provided by @code{(gnu services desktop)}
- are described below.
-
- @deffn {Monadic Procedure} dbus-service @var{services} @
- [#:dbus @var{dbus}]
- Return a service that runs the ``system bus'', using @var{dbus}, with
- support for @var{services}.
-
- @uref{http://dbus.freedesktop.org/, D-Bus} is an inter-process communication
- facility. Its system bus is used to allow system services to communicate
- and be notified of system-wide events.
-
- @var{services} must be a list of packages that provide an
- @file{etc/dbus-1/system.d} directory containing additional D-Bus configuration
- and policy files. For example, to allow avahi-daemon to use the system bus,
- @var{services} must be equal to @code{(list avahi)}.
- @end deffn
-
- @deffn {Monadic Procedure} upower-service [#:upower @var{upower}] @
- [#:watts-up-pro? #f] @
- [#:poll-batteries? #t] @
- [#:ignore-lid? #f] @
- [#:use-percentage-for-policy? #f] @
- [#:percentage-low 10] @
- [#:percentage-critical 3] @
- [#:percentage-action 2] @
- [#:time-low 1200] @
- [#:time-critical 300] @
- [#:time-action 120] @
- [#:critical-power-action 'hybrid-sleep]
- Return a service that runs @uref{http://upower.freedesktop.org/,
- @command{upowerd}}, a system-wide monitor for power consumption and battery
- levels, with the given configuration settings. It implements the
- @code{org.freedesktop.UPower} D-Bus interface, and is notably used by
- GNOME.
- @end deffn
-
- @deffn {Monadic Procedure} colord-service [#:colord @var{colord}]
- Return a service that runs @command{colord}, a system service with a D-Bus
- interface to manage the color profiles of input and output devices such as
- screens and scanners. It is notably used by the GNOME Color Manager graphical
- tool. See @uref{http://www.freedesktop.org/software/colord/, the colord web
- site} for more information.
- @end deffn
-
- @node Database Services
- @subsubsection Database Services
-
- The @code{(gnu services databases)} module provides the following service.
-
- @deffn {Monadic Procedure} postgresql-service [#:postgresql postgresql] @
- [#:config-file] [#:data-directory ``/var/lib/postgresql/data'']
- Return a service that runs @var{postgresql}, the PostgreSQL database
- server.
-
- The PostgreSQL daemon loads its runtime configuration from
- @var{config-file} and stores the database cluster in
- @var{data-directory}.
- @end deffn
-
- @node Various Services
- @subsubsection Various Services
-
- The @code{(gnu services lirc)} module provides the following service.
-
- @deffn {Monadic Procedure} lirc-service [#:lirc lirc] @
- [#:device #f] [#:driver #f] [#:config-file #f] @
- [#:extra-options '()]
- Return a service that runs @url{http://www.lirc.org,LIRC}, a daemon that
- decodes infrared signals from remote controls.
-
- Optionally, @var{device}, @var{driver} and @var{config-file}
- (configuration file name) may be specified. See @command{lircd} manual
- for details.
-
- Finally, @var{extra-options} is a list of additional command-line options
- passed to @command{lircd}.
- @end deffn
-
-
- @node Setuid Programs
- @subsection Setuid Programs
-
- @cindex setuid programs
- Some programs need to run with ``root'' privileges, even when they are
- launched by unprivileged users. A notorious example is the
- @command{passwd} programs, which can users can run to change their
- password, and which requires write access to the @file{/etc/passwd} and
- @file{/etc/shadow} files---something normally restricted to root, for
- obvious security reasons. To address that, these executables are
- @dfn{setuid-root}, meaning that they always run with root privileges
- (@pxref{How Change Persona,,, libc, The GNU C Library Reference Manual},
- for more info about the setuid mechanisms.)
-
- The store itself @emph{cannot} contain setuid programs: that would be a
- security issue since any user on the system can write derivations that
- populate the store (@pxref{The Store}). Thus, a different mechanism is
- used: instead of changing the setuid bit directly on files that are in
- the store, we let the system administrator @emph{declare} which programs
- should be setuid root.
-
- The @code{setuid-programs} field of an @code{operating-system}
- declaration contains a list of G-expressions denoting the names of
- programs to be setuid-root (@pxref{Using the Configuration System}).
- For instance, the @command{passwd} program, which is part of the Shadow
- package, can be designated by this G-expression (@pxref{G-Expressions}):
-
- @example
- #~(string-append #$shadow "/bin/passwd")
- @end example
-
- A default set of setuid programs is defined by the
- @code{%setuid-programs} variable of the @code{(gnu system)} module.
-
- @defvr {Scheme Variable} %setuid-programs
- A list of G-expressions denoting common programs that are setuid-root.
-
- The list includes commands such as @command{passwd}, @command{ping},
- @command{su}, and @command{sudo}.
- @end defvr
-
- Under the hood, the actual setuid programs are created in the
- @file{/run/setuid-programs} directory at system activation time. The
- files in this directory refer to the ``real'' binaries, which are in the
- store.
-
- @node X.509 Certificates
- @subsection X.509 Certificates
-
- @cindex HTTPS, certificates
- @cindex X.509 certificates
- @cindex TLS
- Web servers available over HTTPS (that is, HTTP over the transport-layer
- security mechanism, TLS) send client programs an @dfn{X.509 certificate}
- that the client can then use to @emph{authenticate} the server. To do
- that, clients verify that the server's certificate is signed by a
- so-called @dfn{certificate authority} (CA). But to verify the CA's
- signature, clients must have first acquired the CA's certificate.
-
- Web browsers such as GNU@tie{}IceCat include their own set of CA
- certificates, such that they are able to verify CA signatures
- out-of-the-box.
-
- However, most other programs that can talk HTTPS---@command{wget},
- @command{git}, @command{w3m}, etc.---need to be told where CA
- certificates can be found.
-
- @cindex @code{nss-certs}
- In GuixSD, this is done by adding a package that provides certificates
- to the @code{packages} field of the @code{operating-system} declaration
- (@pxref{operating-system Reference}). GuixSD includes one such package,
- @code{nss-certs}, which is a set of CA certificates provided as part of
- Mozilla's Network Security Services.
-
- Note that it is @emph{not} part of @var{%base-packages}, so you need to
- explicitly add it. The @file{/etc/ssl/certs} directory, which is where
- most applications and libraries look for certificates by default, points
- to the certificates installed globally.
-
- Unprivileged users can also install their own certificate package in
- their profile. A number of environment variables need to be defined so
- that applications and libraries know where to find them. Namely, the
- OpenSSL library honors the @code{SSL_CERT_DIR} and @code{SSL_CERT_FILE}
- variables. Some applications add their own environment variables; for
- instance, the Git version control system honors the certificate bundle
- pointed to by the @code{GIT_SSL_CAINFO} environment variable.
-
-
- @node Name Service Switch
- @subsection Name Service Switch
-
- @cindex name service switch
- @cindex NSS
- The @code{(gnu system nss)} module provides bindings to the
- configuration file of libc's @dfn{name service switch} or @dfn{NSS}
- (@pxref{NSS Configuration File,,, libc, The GNU C Library Reference
- Manual}). In a nutshell, the NSS is a mechanism that allows libc to be
- extended with new ``name'' lookup methods for system databases, which
- includes host names, service names, user accounts, and more (@pxref{Name
- Service Switch, System Databases and Name Service Switch,, libc, The GNU
- C Library Reference Manual}).
-
- The NSS configuration specifies, for each system database, which lookup
- method is to be used, and how the various methods are chained
- together---for instance, under which circumstances NSS should try the
- next method in the list. The NSS configuration is given in the
- @code{name-service-switch} field of @code{operating-system} declarations
- (@pxref{operating-system Reference, @code{name-service-switch}}).
-
- @cindex nss-mdns
- @cindex .local, host name lookup
- As an example, the declaration below configures the NSS to use the
- @uref{http://0pointer.de/lennart/projects/nss-mdns/, @code{nss-mdns}
- back-end}, which supports host name lookups over multicast DNS (mDNS)
- for host names ending in @code{.local}:
-
- @example
- (name-service-switch
- (hosts (list %files ;first, check /etc/hosts
-
- ;; If the above did not succeed, try
- ;; with 'mdns_minimal'.
- (name-service
- (name "mdns_minimal")
-
- ;; 'mdns_minimal' is authoritative for
- ;; '.local'. When it returns "not found",
- ;; no need to try the next methods.
- (reaction (lookup-specification
- (not-found => return))))
-
- ;; Then fall back to DNS.
- (name-service
- (name "dns"))
-
- ;; Finally, try with the "full" 'mdns'.
- (name-service
- (name "mdns")))))
- @end example
-
- Don't worry: the @code{%mdns-host-lookup-nss} variable (see below)
- contains this configuration, so you won't have to type it if all you
- want is to have @code{.local} host lookup working.
-
- Note that, in this case, in addition to setting the
- @code{name-service-switch} of the @code{operating-system} declaration,
- @code{nscd-service} must be told where to find the @code{nss-mdns}
- shared library (@pxref{Base Services, @code{nscd-service}}). Since the
- @code{nscd} service is part of @var{%base-services}, you may want to
- customize it by adding this snippet in the operating system
- configuration file:
-
- @example
- (use-modules (guix) (gnu))
-
- (define %my-base-services
- ;; Replace the default nscd service with one that knows
- ;; about nss-mdns.
- (map (lambda (mservice)
- ;; "Bind" the MSERVICE monadic value to inspect it.
- (mlet %store-monad ((service mservice))
- (if (member 'nscd (service-provision service))
- (nscd-service (nscd-configuration)
- #:name-services (list nss-mdns))
- mservice)))
- %base-services))
- @end example
-
- @noindent
- @dots{} and then refer to @var{%my-base-services} instead of
- @var{%base-services} in the @code{operating-system} declaration.
- Lastly, this relies on the availability of the Avahi service
- (@pxref{Networking Services, @code{avahi-service}}).
-
- For convenience, the following variables provide typical NSS
- configurations.
-
- @defvr {Scheme Variable} %default-nss
- This is the default name service switch configuration, a
- @code{name-service-switch} object.
- @end defvr
-
- @defvr {Scheme Variable} %mdns-host-lookup-nss
- This is the name service switch configuration with support for host name
- lookup over multicast DNS (mDNS) for host names ending in @code{.local}.
- @end defvr
-
- The reference for name service switch configuration is given below. It
- is a direct mapping of the C library's configuration file format, so
- please refer to the C library manual for more information (@pxref{NSS
- Configuration File,,, libc, The GNU C Library Reference Manual}).
- Compared to libc's NSS configuration file format, it has the advantage
- not only of adding this warm parenthetic feel that we like, but also
- static checks: you'll know about syntax errors and typos as soon as you
- run @command{guix system}.
-
- @deftp {Data Type} name-service-switch
-
- This is the data type representation the configuration of libc's name
- service switch (NSS). Each field below represents one of the supported
- system databases.
-
- @table @code
- @item aliases
- @itemx ethers
- @itemx group
- @itemx gshadow
- @itemx hosts
- @itemx initgroups
- @itemx netgroup
- @itemx networks
- @itemx password
- @itemx public-key
- @itemx rpc
- @itemx services
- @itemx shadow
- The system databases handled by the NSS. Each of these fields must be a
- list of @code{<name-service>} objects (see below.)
- @end table
- @end deftp
-
- @deftp {Data Type} name-service
-
- This is the data type representing an actual name service and the
- associated lookup action.
-
- @table @code
- @item name
- A string denoting the name service (@pxref{Services in the NSS
- configuration,,, libc, The GNU C Library Reference Manual}).
-
- Note that name services listed here must be visible to nscd. This is
- achieved by passing the @code{#:name-services} argument to
- @code{nscd-service} the list of packages providing the needed name
- services (@pxref{Base Services, @code{nscd-service}}).
-
- @item reaction
- An action specified using the @code{lookup-specification} macro
- (@pxref{Actions in the NSS configuration,,, libc, The GNU C Library
- Reference Manual}). For example:
-
- @example
- (lookup-specification (unavailable => continue)
- (success => return))
- @end example
- @end table
- @end deftp
-
- @node Initial RAM Disk
- @subsection Initial RAM Disk
-
- @cindex initial RAM disk (initrd)
- @cindex initrd (initial RAM disk)
- For bootstrapping purposes, the Linux-Libre kernel is passed an
- @dfn{initial RAM disk}, or @dfn{initrd}. An initrd contains a temporary
- root file system, as well as an initialization script. The latter is
- responsible for mounting the real root file system, and for loading any
- kernel modules that may be needed to achieve that.
-
- The @code{initrd} field of an @code{operating-system} declaration allows
- you to specify which initrd you would like to use. The @code{(gnu
- system linux-initrd)} module provides two ways to build an initrd: the
- high-level @code{base-initrd} procedure, and the low-level
- @code{expression->initrd} procedure.
-
- The @code{base-initrd} procedure is intended to cover most common uses.
- For example, if you want to add a bunch of kernel modules to be loaded
- at boot time, you can define the @code{initrd} field of the operating
- system declaration like this:
-
- @example
- (initrd (lambda (file-systems . rest)
- ;; Create a standard initrd that has modules "foo.ko"
- ;; and "bar.ko", as well as their dependencies, in
- ;; addition to the modules available by default.
- (apply base-initrd file-systems
- #:extra-modules '("foo" "bar")
- rest)))
- @end example
-
- The @code{base-initrd} procedure also handles common use cases that
- involves using the system as a QEMU guest, or as a ``live'' system whose
- root file system is volatile.
-
- @deffn {Monadic Procedure} base-initrd @var{file-systems} @
- [#:qemu-networking? #f] [#:virtio? #f] [#:volatile-root? #f] @
- [#:extra-modules '()] [#:mapped-devices '()]
- Return a monadic derivation that builds a generic initrd. @var{file-systems} is
- a list of file-systems to be mounted by the initrd, possibly in addition to
- the root file system specified on the kernel command line via @code{--root}.
- @var{mapped-devices} is a list of device mappings to realize before
- @var{file-systems} are mounted (@pxref{Mapped Devices}).
-
- When @var{qemu-networking?} is true, set up networking with the standard QEMU
- parameters. When @var{virtio?} is true, load additional modules so the initrd can
- be used as a QEMU guest with para-virtualized I/O drivers.
-
- When @var{volatile-root?} is true, the root file system is writable but any changes
- to it are lost.
-
- The initrd is automatically populated with all the kernel modules necessary
- for @var{file-systems} and for the given options. However, additional kernel
- modules can be listed in @var{extra-modules}. They will be added to the initrd, and
- loaded at boot time in the order in which they appear.
- @end deffn
-
- Needless to say, the initrds we produce and use embed a
- statically-linked Guile, and the initialization program is a Guile
- program. That gives a lot of flexibility. The
- @code{expression->initrd} procedure builds such an initrd, given the
- program to run in that initrd.
-
- @deffn {Monadic Procedure} expression->initrd @var{exp} @
- [#:guile %guile-static-stripped] [#:name "guile-initrd"] @
- [#:modules '()]
- Return a derivation that builds a Linux initrd (a gzipped cpio archive)
- containing @var{guile} and that evaluates @var{exp}, a G-expression,
- upon booting. All the derivations referenced by @var{exp} are
- automatically copied to the initrd.
-
- @var{modules} is a list of Guile module names to be embedded in the
- initrd.
- @end deffn
-
- @node GRUB Configuration
- @subsection GRUB Configuration
-
- @cindex GRUB
- @cindex boot loader
-
- The operating system uses GNU@tie{}GRUB as its boot loader
- (@pxref{Overview, overview of GRUB,, grub, GNU GRUB Manual}). It is
- configured using @code{grub-configuration} declarations. This data type
- is exported by the @code{(gnu system grub)} module, and described below.
-
- @deftp {Data Type} grub-configuration
- The type of a GRUB configuration declaration.
-
- @table @asis
-
- @item @code{device}
- This is a string denoting the boot device. It must be a device name
- understood by the @command{grub-install} command, such as
- @code{/dev/sda} or @code{(hd0)} (@pxref{Invoking grub-install,,, grub,
- GNU GRUB Manual}).
-
- @item @code{menu-entries} (default: @code{()})
- A possibly empty list of @code{menu-entry} objects (see below), denoting
- entries to appear in the GRUB boot menu, in addition to the current
- system entry and the entry pointing to previous system generations.
-
- @item @code{default-entry} (default: @code{0})
- The index of the default boot menu entry. Index 0 is for the current
- system's entry.
-
- @item @code{timeout} (default: @code{5})
- The number of seconds to wait for keyboard input before booting. Set to
- 0 to boot immediately, and to -1 to wait indefinitely.
-
- @item @code{theme} (default: @var{%default-theme})
- The @code{grub-theme} object describing the theme to use.
- @end table
-
- @end deftp
-
- Should you want to list additional boot menu entries @i{via} the
- @code{menu-entries} field above, you will need to create them with the
- @code{menu-entry} form:
-
- @deftp {Data Type} menu-entry
- The type of an entry in the GRUB boot menu.
-
- @table @asis
-
- @item @code{label}
- The label to show in the menu---e.g., @code{"GNU"}.
-
- @item @code{linux}
- The Linux kernel to boot.
-
- @item @code{linux-arguments} (default: @code{()})
- The list of extra Linux kernel command-line arguments---e.g.,
- @code{("console=ttyS0")}.
-
- @item @code{initrd}
- A G-Expression or string denoting the file name of the initial RAM disk
- to use (@pxref{G-Expressions}).
-
- @end table
- @end deftp
-
- @c FIXME: Write documentation once it's stable.
- Themes are created using the @code{grub-theme} form, which is not
- documented yet.
-
- @defvr {Scheme Variable} %default-theme
- This is the default GRUB theme used by the operating system, with a
- fancy background image displaying the GNU and Guix logos.
- @end defvr
-
-
- @node Invoking guix system
- @subsection Invoking @code{guix system}
-
- Once you have written an operating system declaration, as seen in the
- previous section, it can be @dfn{instantiated} using the @command{guix
- system} command. The synopsis is:
-
- @example
- guix system @var{options}@dots{} @var{action} @var{file}
- @end example
-
- @var{file} must be the name of a file containing an
- @code{operating-system} declaration. @var{action} specifies how the
- operating system is instantiate. Currently the following values are
- supported:
-
- @table @code
- @item reconfigure
- Build the operating system described in @var{file}, activate it, and
- switch to it@footnote{This action is usable only on systems already
- running GNU.}.
-
- This effects all the configuration specified in @var{file}: user
- accounts, system services, global package list, setuid programs, etc.
-
- It also adds a GRUB menu entry for the new OS configuration, and moves
- entries for older configurations to a submenu---unless
- @option{--no-grub} is passed.
-
- @c The paragraph below refers to the problem discussed at
- @c <http://lists.gnu.org/archive/html/guix-devel/2014-08/msg00057.html>.
- It is highly recommended to run @command{guix pull} once before you run
- @command{guix system reconfigure} for the first time (@pxref{Invoking
- guix pull}). Failing to do that you would see an older version of Guix
- once @command{reconfigure} has completed.
-
- @item build
- Build the operating system's derivation, which includes all the
- configuration files and programs needed to boot and run the system.
- This action does not actually install anything.
-
- @item init
- Populate the given directory with all the files necessary to run the
- operating system specified in @var{file}. This is useful for first-time
- installations of GuixSD. For instance:
-
- @example
- guix system init my-os-config.scm /mnt
- @end example
-
- copies to @file{/mnt} all the store items required by the configuration
- specified in @file{my-os-config.scm}. This includes configuration
- files, packages, and so on. It also creates other essential files
- needed for the system to operate correctly---e.g., the @file{/etc},
- @file{/var}, and @file{/run} directories, and the @file{/bin/sh} file.
-
- This command also installs GRUB on the device specified in
- @file{my-os-config}, unless the @option{--no-grub} option was passed.
-
- @item vm
- @cindex virtual machine
- @cindex VM
- Build a virtual machine that contain the operating system declared in
- @var{file}, and return a script to run that virtual machine (VM).
- Arguments given to the script are passed as is to QEMU.
-
- The VM shares its store with the host system.
-
- Additional file systems can be shared between the host and the VM using
- the @code{--share} and @code{--expose} command-line options: the former
- specifies a directory to be shared with write access, while the latter
- provides read-only access to the shared directory.
-
- The example below creates a VM in which the user's home directory is
- accessible read-only, and where the @file{/exchange} directory is a
- read-write mapping of the host's @file{$HOME/tmp}:
-
- @example
- guix system vm my-config.scm \
- --expose=$HOME --share=$HOME/tmp=/exchange
- @end example
-
- On GNU/Linux, the default is to boot directly to the kernel; this has
- the advantage of requiring only a very tiny root disk image since the
- host's store can then be mounted.
-
- The @code{--full-boot} option forces a complete boot sequence, starting
- with the bootloader. This requires more disk space since a root image
- containing at least the kernel, initrd, and bootloader data files must
- be created. The @code{--image-size} option can be used to specify the
- image's size.
-
- @item vm-image
- @itemx disk-image
- Return a virtual machine or disk image of the operating system declared
- in @var{file} that stands alone. Use the @option{--image-size} option
- to specify the size of the image.
-
- When using @code{vm-image}, the returned image is in qcow2 format, which
- the QEMU emulator can efficiently use.
-
- When using @code{disk-image}, a raw disk image is produced; it can be
- copied as is to a USB stick, for instance. Assuming @code{/dev/sdc} is
- the device corresponding to a USB stick, one can copy the image on it
- using the following command:
-
- @example
- # dd if=$(guix system disk-image my-os.scm) of=/dev/sdc
- @end example
-
- @end table
-
- @var{options} can contain any of the common build options provided by
- @command{guix build} (@pxref{Invoking guix build}). In addition,
- @var{options} can contain one of the following:
-
- @table @option
- @item --system=@var{system}
- @itemx -s @var{system}
- Attempt to build for @var{system} instead of the host's system type.
- This works as per @command{guix build} (@pxref{Invoking guix build}).
-
- @item --image-size=@var{size}
- For the @code{vm-image} and @code{disk-image} actions, create an image
- of the given @var{size}. @var{size} may be a number of bytes, or it may
- include a unit as a suffix (@pxref{Block size, size specifications,,
- coreutils, GNU Coreutils}).
-
- @item --on-error=@var{strategy}
- Apply @var{strategy} when an error occurs when reading @var{file}.
- @var{strategy} may be one of the following:
-
- @table @code
- @item nothing-special
- Report the error concisely and exit. This is the default strategy.
-
- @item backtrace
- Likewise, but also display a backtrace.
-
- @item debug
- Report the error and enter Guile's debugger. From there, you can run
- commands such as @code{,bt} to get a backtrace, @code{,locals} to
- display local variable values, and more generally inspect the program's
- state. @xref{Debug Commands,,, guile, GNU Guile Reference Manual}, for
- a list of available debugging commands.
- @end table
- @end table
-
- Note that all the actions above, except @code{build} and @code{init},
- rely on KVM support in the Linux-Libre kernel. Specifically, the
- machine should have hardware virtualization support, the corresponding
- KVM kernel module should be loaded, and the @file{/dev/kvm} device node
- must exist and be readable and writable by the user and by the daemon's
- build users.
-
- @node Defining Services
- @subsection Defining Services
-
- The @code{(gnu services @dots{})} modules define several procedures that allow
- users to declare the operating system's services (@pxref{Using the
- Configuration System}). These procedures are @emph{monadic
- procedures}---i.e., procedures that return a monadic value in the store
- monad (@pxref{The Store Monad}). For examples of such procedures,
- @xref{Services}.
-
- @cindex service definition
- The monadic value returned by those procedures is a @dfn{service
- definition}---a structure as returned by the @code{service} form.
- Service definitions specifies the inputs the service depends on, and an
- expression to start and stop the service. Behind the scenes, service
- definitions are ``translated'' into the form suitable for the
- configuration file of dmd, the init system (@pxref{Services,,, dmd, GNU
- dmd Manual}).
-
- As an example, here is what the @code{nscd-service} procedure looks
- like:
-
- @lisp
- (define (nscd-service)
- (with-monad %store-monad
- (return (service
- (documentation "Run libc's name service cache daemon.")
- (provision '(nscd))
- (activate #~(begin
- (use-modules (guix build utils))
- (mkdir-p "/var/run/nscd")))
- (start #~(make-forkexec-constructor
- (string-append #$glibc "/sbin/nscd")
- "-f" "/dev/null" "--foreground"))
- (stop #~(make-kill-destructor))
- (respawn? #f)))))
- @end lisp
-
- @noindent
- The @code{activate}, @code{start}, and @code{stop} fields are G-expressions
- (@pxref{G-Expressions}). The @code{activate} field contains a script to
- run at ``activation'' time; it makes sure that the @file{/var/run/nscd}
- directory exists before @command{nscd} is started.
-
- The @code{start} and @code{stop} fields refer to dmd's facilities to
- start and stop processes (@pxref{Service De- and Constructors,,, dmd,
- GNU dmd Manual}). The @code{provision} field specifies the name under
- which this service is known to dmd, and @code{documentation} specifies
- on-line documentation. Thus, the commands @command{deco start ncsd},
- @command{deco stop nscd}, and @command{deco doc nscd} will do what you
- would expect (@pxref{Invoking deco,,, dmd, GNU dmd Manual}).
-
-
- @node Installing Debugging Files
- @section Installing Debugging Files
-
- @cindex debugging files
- Program binaries, as produced by the GCC compilers for instance, are
- typically written in the ELF format, with a section containing
- @dfn{debugging information}. Debugging information is what allows the
- debugger, GDB, to map binary code to source code; it is required to
- debug a compiled program in good conditions.
-
- The problem with debugging information is that is takes up a fair amount
- of disk space. For example, debugging information for the GNU C Library
- weighs in at more than 60 MiB. Thus, as a user, keeping all the
- debugging info of all the installed programs is usually not an option.
- Yet, space savings should not come at the cost of an impediment to
- debugging---especially in the GNU system, which should make it easier
- for users to exert their computing freedom (@pxref{GNU Distribution}).
-
- Thankfully, the GNU Binary Utilities (Binutils) and GDB provide a
- mechanism that allows users to get the best of both worlds: debugging
- information can be stripped from the binaries and stored in separate
- files. GDB is then able to load debugging information from those files,
- when they are available (@pxref{Separate Debug Files,,, gdb, Debugging
- with GDB}).
-
- The GNU distribution takes advantage of this by storing debugging
- information in the @code{lib/debug} sub-directory of a separate package
- output unimaginatively called @code{debug} (@pxref{Packages with
- Multiple Outputs}). Users can choose to install the @code{debug} output
- of a package when they need it. For instance, the following command
- installs the debugging information for the GNU C Library and for GNU
- Guile:
-
- @example
- guix package -i glibc:debug guile:debug
- @end example
-
- GDB must then be told to look for debug files in the user's profile, by
- setting the @code{debug-file-directory} variable (consider setting it
- from the @file{~/.gdbinit} file, @pxref{Startup,,, gdb, Debugging with
- GDB}):
-
- @example
- (gdb) set debug-file-directory ~/.guix-profile/lib/debug
- @end example
-
- From there on, GDB will pick up debugging information from the
- @code{.debug} files under @file{~/.guix-profile/lib/debug}.
-
- In addition, you will most likely want GDB to be able to show the source
- code being debugged. To do that, you will have to unpack the source
- code of the package of interest (obtained with @code{guix build
- --source}, @pxref{Invoking guix build}), and to point GDB to that source
- directory using the @code{directory} command (@pxref{Source Path,
- @code{directory},, gdb, Debugging with GDB}).
-
- @c XXX: keep me up-to-date
- The @code{debug} output mechanism in Guix is implemented by the
- @code{gnu-build-system} (@pxref{Build Systems}). Currently, it is
- opt-in---debugging information is available only for those packages
- whose definition explicitly declares a @code{debug} output. This may be
- changed to opt-out in the future, if our build farm servers can handle
- the load. To check whether a package has a @code{debug} output, use
- @command{guix package --list-available} (@pxref{Invoking guix package}).
-
-
- @node Security Updates
- @section Security Updates
-
- @quotation Note
- As of version @value{VERSION}, the feature described in this section is
- experimental.
- @end quotation
-
- @cindex security updates
- Occasionally, important security vulnerabilities are discovered in core
- software packages and must be patched. Guix follows a functional
- package management discipline (@pxref{Introduction}), which implies
- that, when a package is changed, @emph{every package that depends on it}
- must be rebuilt. This can significantly slow down the deployment of
- fixes in core packages such as libc or Bash, since basically the whole
- distribution would need to be rebuilt. Using pre-built binaries helps
- (@pxref{Substitutes}), but deployment may still take more time than
- desired.
-
- @cindex grafts
- To address that, Guix implements @dfn{grafts}, a mechanism that allows
- for fast deployment of critical updates without the costs associated
- with a whole-distribution rebuild. The idea is to rebuild only the
- package that needs to be patched, and then to ``graft'' it onto packages
- explicitly installed by the user and that were previously referring to
- the original package. The cost of grafting is typically very low, and
- order of magnitudes lower than a full rebuild of the dependency chain.
-
- @cindex replacements of packages, for grafts
- For instance, suppose a security update needs to be applied to Bash.
- Guix developers will provide a package definition for the ``fixed''
- Bash, say @var{bash-fixed}, in the usual way (@pxref{Defining
- Packages}). Then, the original package definition is augmented with a
- @code{replacement} field pointing to the package containing the bug fix:
-
- @example
- (define bash
- (package
- (name "bash")
- ;; @dots{}
- (replacement bash-fixed)))
- @end example
-
- From there on, any package depending directly or indirectly on Bash that
- is installed will automatically be ``rewritten'' to refer to
- @var{bash-fixed} instead of @var{bash}. This grafting process takes
- time proportional to the size of the package, but expect less than a
- minute for an ``average'' package on a recent machine.
-
- Currently, the graft and the package it replaces (@var{bash-fixed} and
- @var{bash} in the example above) must have the exact same @code{name}
- and @code{version} fields. This restriction mostly comes from the fact
- that grafting works by patching files, including binary files, directly.
- Other restrictions may apply: for instance, when adding a graft to a
- package providing a shared library, the original shared library and its
- replacement must have the same @code{SONAME} and be binary-compatible.
-
-
- @node Package Modules
- @section Package Modules
-
- From a programming viewpoint, the package definitions of the
- GNU distribution are provided by Guile modules in the @code{(gnu packages
- @dots{})} name space@footnote{Note that packages under the @code{(gnu
- packages @dots{})} module name space are not necessarily ``GNU
- packages''. This module naming scheme follows the usual Guile module
- naming convention: @code{gnu} means that these modules are distributed
- as part of the GNU system, and @code{packages} identifies modules that
- define packages.} (@pxref{Modules, Guile modules,, guile, GNU Guile
- Reference Manual}). For instance, the @code{(gnu packages emacs)}
- module exports a variable named @code{emacs}, which is bound to a
- @code{<package>} object (@pxref{Defining Packages}).
-
- The @code{(gnu packages @dots{})} module name space is
- automatically scanned for packages by the command-line tools. For
- instance, when running @code{guix package -i emacs}, all the @code{(gnu
- packages @dots{})} modules are scanned until one that exports a package
- object whose name is @code{emacs} is found. This package search
- facility is implemented in the @code{(gnu packages)} module.
-
- @cindex customization, of packages
- @cindex package module search path
- Users can store package definitions in modules with different
- names---e.g., @code{(my-packages emacs)}@footnote{Note that the file
- name and module name must match. For instance, the @code{(my-packages
- emacs)} module must be stored in a @file{my-packages/emacs.scm} file
- relative to the load path specified with @option{--load-path} or
- @code{GUIX_PACKAGE_PATH}. @xref{Modules and the File System,,,
- guile, GNU Guile Reference Manual}, for details.}. These package definitions
- will not be visible by default. Thus, users can invoke commands such as
- @command{guix package} and @command{guix build} have to be used with the
- @code{-e} option so that they know where to find the package. Better
- yet, they can use the
- @code{-L} option of these commands to make those modules visible
- (@pxref{Invoking guix build, @code{--load-path}}), or define the
- @code{GUIX_PACKAGE_PATH} environment variable. This environment
- variable makes it easy to extend or customize the distribution and is
- honored by all the user interfaces.
-
- @defvr {Environment Variable} GUIX_PACKAGE_PATH
- This is a colon-separated list of directories to search for package
- modules. Directories listed in this variable take precedence over the
- distribution's own modules.
- @end defvr
-
- The distribution is fully @dfn{bootstrapped} and @dfn{self-contained}:
- each package is built based solely on other packages in the
- distribution. The root of this dependency graph is a small set of
- @dfn{bootstrap binaries}, provided by the @code{(gnu packages
- bootstrap)} module. For more information on bootstrapping,
- @pxref{Bootstrapping}.
-
- @node Packaging Guidelines
- @section Packaging Guidelines
-
- The GNU distribution is nascent and may well lack some of your favorite
- packages. This section describes how you can help make the distribution
- grow. @xref{Contributing}, for additional information on how you can
- help.
-
- Free software packages are usually distributed in the form of
- @dfn{source code tarballs}---typically @file{tar.gz} files that contain
- all the source files. Adding a package to the distribution means
- essentially two things: adding a @dfn{recipe} that describes how to
- build the package, including a list of other packages required to build
- it, and adding @dfn{package meta-data} along with that recipe, such as a
- description and licensing information.
-
- In Guix all this information is embodied in @dfn{package definitions}.
- Package definitions provide a high-level view of the package. They are
- written using the syntax of the Scheme programming language; in fact,
- for each package we define a variable bound to the package definition,
- and export that variable from a module (@pxref{Package Modules}).
- However, in-depth Scheme knowledge is @emph{not} a prerequisite for
- creating packages. For more information on package definitions,
- @pxref{Defining Packages}.
-
- Once a package definition is in place, stored in a file in the Guix
- source tree, it can be tested using the @command{guix build} command
- (@pxref{Invoking guix build}). For example, assuming the new package is
- called @code{gnew}, you may run this command from the Guix build tree
- (@pxref{Running Guix Before It Is Installed}):
-
- @example
- ./pre-inst-env guix build gnew --keep-failed
- @end example
-
- Using @code{--keep-failed} makes it easier to debug build failures since
- it provides access to the failed build tree. Another useful
- command-line option when debugging is @code{--log-file}, to access the
- build log.
-
- If the package is unknown to the @command{guix} command, it may be that
- the source file contains a syntax error, or lacks a @code{define-public}
- clause to export the package variable. To figure it out, you may load
- the module from Guile to get more information about the actual error:
-
- @example
- ./pre-inst-env guile -c '(use-modules (gnu packages gnew))'
- @end example
-
- Once your package builds correctly, please send us a patch
- (@pxref{Contributing}). Well, if you need help, we will be happy to
- help you too. Once the patch is committed in the Guix repository, the
- new package automatically gets built on the supported platforms by
- @url{http://hydra.gnu.org/jobset/gnu/master, our continuous integration
- system}.
-
- @cindex substituter
- Users can obtain the new package definition simply by running
- @command{guix pull} (@pxref{Invoking guix pull}). When
- @code{hydra.gnu.org} is done building the package, installing the
- package automatically downloads binaries from there
- (@pxref{Substitutes}). The only place where human intervention is
- needed is to review and apply the patch.
-
-
- @menu
- * Software Freedom:: What may go into the distribution.
- * Package Naming:: What's in a name?
- * Version Numbers:: When the name is not enough.
- * Python Modules:: Taming the snake.
- * Perl Modules:: Little pearls.
- * Fonts:: Fond of fonts.
- @end menu
-
- @node Software Freedom
- @subsection Software Freedom
-
- @c Adapted from http://www.gnu.org/philosophy/philosophy.html.
-
- The GNU operating system has been developed so that users can have
- freedom in their computing. GNU is @dfn{free software}, meaning that
- users have the @url{http://www.gnu.org/philosophy/free-sw.html,four
- essential freedoms}: to run the program, to study and change the program
- in source code form, to redistribute exact copies, and to distribute
- modified versions. Packages found in the GNU distribution provide only
- software that conveys these four freedoms.
-
- In addition, the GNU distribution follow the
- @url{http://www.gnu.org/distros/free-system-distribution-guidelines.html,free
- software distribution guidelines}. Among other things, these guidelines
- reject non-free firmware, recommendations of non-free software, and
- discuss ways to deal with trademarks and patents.
-
- Some packages contain a small and optional subset that violates the
- above guidelines, for instance because this subset is itself non-free
- code. When that happens, the offending items are removed with
- appropriate patches or code snippets in the package definition's
- @code{origin} form (@pxref{Defining Packages}). That way, @code{guix
- build --source} returns the ``freed'' source rather than the unmodified
- upstream source.
-
-
- @node Package Naming
- @subsection Package Naming
-
- A package has actually two names associated with it:
- First, there is the name of the @emph{Scheme variable}, the one following
- @code{define-public}. By this name, the package can be made known in the
- Scheme code, for instance as input to another package. Second, there is
- the string in the @code{name} field of a package definition. This name
- is used by package management commands such as
- @command{guix package} and @command{guix build}.
-
- Both are usually the same and correspond to the lowercase conversion of
- the project name chosen upstream, with underscores replaced with
- hyphens. For instance, GNUnet is available as @code{gnunet}, and
- SDL_net as @code{sdl-net}.
-
- We do not add @code{lib} prefixes for library packages, unless these are
- already part of the official project name. But @pxref{Python
- Modules} and @ref{Perl Modules} for special rules concerning modules for
- the Python and Perl languages.
-
- Font package names are handled differently, @pxref{Fonts}.
-
-
- @node Version Numbers
- @subsection Version Numbers
-
- We usually package only the latest version of a given free software
- project. But sometimes, for instance for incompatible library versions,
- two (or more) versions of the same package are needed. These require
- different Scheme variable names. We use the name as defined
- in @ref{Package Naming}
- for the most recent version; previous versions use the same name, suffixed
- by @code{-} and the smallest prefix of the version number that may
- distinguish the two versions.
-
- The name inside the package definition is the same for all versions of a
- package and does not contain any version number.
-
- For instance, the versions 2.24.20 and 3.9.12 of GTK+ may be packaged as follows:
-
- @example
- (define-public gtk+
- (package
- (name "gtk+")
- (version "3.9.12")
- ...))
- (define-public gtk+-2
- (package
- (name "gtk+")
- (version "2.24.20")
- ...))
- @end example
- If we also wanted GTK+ 3.8.2, this would be packaged as
- @example
- (define-public gtk+-3.8
- (package
- (name "gtk+")
- (version "3.8.2")
- ...))
- @end example
-
-
- @node Python Modules
- @subsection Python Modules
-
- We currently package Python 2 and Python 3, under the Scheme variable names
- @code{python-2} and @code{python} as explained in @ref{Version Numbers}.
- To avoid confusion and naming clashes with other programming languages, it
- seems desirable that the name of a package for a Python module contains
- the word @code{python}.
-
- Some modules are compatible with only one version of Python, others with both.
- If the package Foo compiles only with Python 3, we name it
- @code{python-foo}; if it compiles only with Python 2, we name it
- @code{python2-foo}. If it is compatible with both versions, we create two
- packages with the corresponding names.
-
- If a project already contains the word @code{python}, we drop this;
- for instance, the module python-dateutil is packaged under the names
- @code{python-dateutil} and @code{python2-dateutil}.
-
-
- @node Perl Modules
- @subsection Perl Modules
-
- Perl programs standing for themselves are named as any other package,
- using the lowercase upstream name.
- For Perl packages containing a single class, we use the lowercase class name,
- replace all occurrences of @code{::} by dashes and prepend the prefix
- @code{perl-}.
- So the class @code{XML::Parser} becomes @code{perl-xml-parser}.
- Modules containing several classes keep their lowercase upstream name and
- are also prepended by @code{perl-}. Such modules tend to have the word
- @code{perl} somewhere in their name, which gets dropped in favor of the
- prefix. For instance, @code{libwww-perl} becomes @code{perl-libwww}.
-
-
- @node Fonts
- @subsection Fonts
-
- For fonts that are in general not installed by a user for typesetting
- purposes, or that are distributed as part of a larger software package,
- we rely on the general packaging rules for software; for instance, this
- applies to the fonts delivered as part of the X.Org system or fonts that
- are part of TeX Live.
-
- To make it easier for a user to search for fonts, names for other packages
- containing only fonts are constructed as follows, independently of the
- upstream package name.
-
- The name of a package containing only one font family starts with
- @code{font-}; it is followed by the foundry name and a dash @code{-}
- if the foundry is known, and the font family name, in which spaces are
- replaced by dashes (and as usual, all upper case letters are transformed
- to lower case).
- For example, the Gentium font family by SIL is packaged under the name
- @code{font-sil-gentium}.
-
- For a package containing several font families, the name of the collection
- is used in the place of the font family name.
- For instance, the Liberation fonts consist of three families,
- Liberation Sans, Liberation Serif and Liberation Mono.
- These could be packaged separately under the names
- @code{font-liberation-sans} and so on; but as they are distributed together
- under a common name, we prefer to package them together as
- @code{font-liberation}.
-
- In the case where several formats of the same font family or font collection
- are packaged separately, a short form of the format, prepended by a dash,
- is added to the package name. We use @code{-ttf} for TrueType fonts,
- @code{-otf} for OpenType fonts and @code{-type1} for PostScript Type 1
- fonts.
-
-
-
- @node Bootstrapping
- @section Bootstrapping
-
- @c Adapted from the ELS 2013 paper.
-
- @cindex bootstrapping
-
- Bootstrapping in our context refers to how the distribution gets built
- ``from nothing''. Remember that the build environment of a derivation
- contains nothing but its declared inputs (@pxref{Introduction}). So
- there's an obvious chicken-and-egg problem: how does the first package
- get built? How does the first compiler get compiled? Note that this is
- a question of interest only to the curious hacker, not to the regular
- user, so you can shamelessly skip this section if you consider yourself
- a ``regular user''.
-
- @cindex bootstrap binaries
- The GNU system is primarily made of C code, with libc at its core. The
- GNU build system itself assumes the availability of a Bourne shell and
- command-line tools provided by GNU Coreutils, Awk, Findutils, `sed', and
- `grep'. Furthermore, build programs---programs that run
- @code{./configure}, @code{make}, etc.---are written in Guile Scheme
- (@pxref{Derivations}). Consequently, to be able to build anything at
- all, from scratch, Guix relies on pre-built binaries of Guile, GCC,
- Binutils, libc, and the other packages mentioned above---the
- @dfn{bootstrap binaries}.
-
- These bootstrap binaries are ``taken for granted'', though we can also
- re-create them if needed (more on that later).
-
- @unnumberedsubsec Preparing to Use the Bootstrap Binaries
-
- @c As of Emacs 24.3, Info-mode displays the image, but since it's a
- @c large image, it's hard to scroll. Oh well.
- @image{images/bootstrap-graph,6in,,Dependency graph of the early bootstrap derivations}
-
- The figure above shows the very beginning of the dependency graph of the
- distribution, corresponding to the package definitions of the @code{(gnu
- packages bootstrap)} module. At this level of detail, things are
- slightly complex. First, Guile itself consists of an ELF executable,
- along with many source and compiled Scheme files that are dynamically
- loaded when it runs. This gets stored in the @file{guile-2.0.7.tar.xz}
- tarball shown in this graph. This tarball is part of Guix's ``source''
- distribution, and gets inserted into the store with @code{add-to-store}
- (@pxref{The Store}).
-
- But how do we write a derivation that unpacks this tarball and adds it
- to the store? To solve this problem, the @code{guile-bootstrap-2.0.drv}
- derivation---the first one that gets built---uses @code{bash} as its
- builder, which runs @code{build-bootstrap-guile.sh}, which in turn calls
- @code{tar} to unpack the tarball. Thus, @file{bash}, @file{tar},
- @file{xz}, and @file{mkdir} are statically-linked binaries, also part of
- the Guix source distribution, whose sole purpose is to allow the Guile
- tarball to be unpacked.
-
- Once @code{guile-bootstrap-2.0.drv} is built, we have a functioning
- Guile that can be used to run subsequent build programs. Its first task
- is to download tarballs containing the other pre-built binaries---this
- is what the @code{.tar.xz.drv} derivations do. Guix modules such as
- @code{ftp-client.scm} are used for this purpose. The
- @code{module-import.drv} derivations import those modules in a directory
- in the store, using the original layout. The
- @code{module-import-compiled.drv} derivations compile those modules, and
- write them in an output directory with the right layout. This
- corresponds to the @code{#:modules} argument of
- @code{build-expression->derivation} (@pxref{Derivations}).
-
- Finally, the various tarballs are unpacked by the
- derivations @code{gcc-bootstrap-0.drv}, @code{glibc-bootstrap-0.drv},
- etc., at which point we have a working C tool chain.
-
-
- @unnumberedsubsec Building the Build Tools
-
- @c TODO: Add a package-level dependency graph generated from (gnu
- @c packages base).
-
- Bootstrapping is complete when we have a full tool chain that does not
- depend on the pre-built bootstrap tools discussed above. This
- no-dependency requirement is verified by checking whether the files of
- the final tool chain contain references to the @file{/gnu/store}
- directories of the bootstrap inputs. The process that leads to this
- ``final'' tool chain is described by the package definitions found in
- the @code{(gnu packages commencement)} module.
-
- @c See <http://lists.gnu.org/archive/html/gnu-system-discuss/2012-10/msg00000.html>.
- The first tool that gets built with the bootstrap binaries is
- GNU Make, which is a prerequisite for all the following packages.
- From there Findutils and Diffutils get built.
-
- Then come the first-stage Binutils and GCC, built as pseudo cross
- tools---i.e., with @code{--target} equal to @code{--host}. They are
- used to build libc. Thanks to this cross-build trick, this libc is
- guaranteed not to hold any reference to the initial tool chain.
-
- From there the final Binutils and GCC are built. GCC uses @code{ld}
- from the final Binutils, and links programs against the just-built libc.
- This tool chain is used to build the other packages used by Guix and by
- the GNU Build System: Guile, Bash, Coreutils, etc.
-
- And voilà! At this point we have the complete set of build tools that
- the GNU Build System expects. These are in the @code{%final-inputs}
- variable of the @code{(gnu packages commencement)} module, and are
- implicitly used by any package that uses @code{gnu-build-system}
- (@pxref{Build Systems, @code{gnu-build-system}}).
-
-
- @unnumberedsubsec Building the Bootstrap Binaries
-
- Because the final tool chain does not depend on the bootstrap binaries,
- those rarely need to be updated. Nevertheless, it is useful to have an
- automated way to produce them, should an update occur, and this is what
- the @code{(gnu packages make-bootstrap)} module provides.
-
- The following command builds the tarballs containing the bootstrap
- binaries (Guile, Binutils, GCC, libc, and a tarball containing a mixture
- of Coreutils and other basic command-line tools):
-
- @example
- guix build bootstrap-tarballs
- @end example
-
- The generated tarballs are those that should be referred to in the
- @code{(gnu packages bootstrap)} module mentioned at the beginning of
- this section.
-
- Still here? Then perhaps by now you've started to wonder: when do we
- reach a fixed point? That is an interesting question! The answer is
- unknown, but if you would like to investigate further (and have
- significant computational and storage resources to do so), then let us
- know.
-
- @node Porting
- @section Porting to a New Platform
-
- As discussed above, the GNU distribution is self-contained, and
- self-containment is achieved by relying on pre-built ``bootstrap
- binaries'' (@pxref{Bootstrapping}). These binaries are specific to an
- operating system kernel, CPU architecture, and application binary
- interface (ABI). Thus, to port the distribution to a platform that is
- not yet supported, one must build those bootstrap binaries, and update
- the @code{(gnu packages bootstrap)} module to use them on that platform.
-
- Fortunately, Guix can @emph{cross compile} those bootstrap binaries.
- When everything goes well, and assuming the GNU tool chain supports the
- target platform, this can be as simple as running a command like this
- one:
-
- @example
- guix build --target=armv5tel-linux-gnueabi bootstrap-tarballs
- @end example
-
- For this to work, the @code{glibc-dynamic-linker} procedure in
- @code{(gnu packages bootstrap)} must be augmented to return the right
- file name for libc's dynamic linker on that platform; likewise,
- @code{system->linux-architecture} in @code{(gnu packages linux)} must be
- taught about the new platform.
-
- Once these are built, the @code{(gnu packages bootstrap)} module needs
- to be updated to refer to these binaries on the target platform. That
- is, the hashes and URLs of the bootstrap tarballs for the new platform
- must be added alongside those of the currently supported platforms. The
- bootstrap Guile tarball is treated specially: it is expected to be
- available locally, and @file{gnu-system.am} has rules do download it for
- the supported architectures; a rule for the new platform must be added
- as well.
-
- In practice, there may be some complications. First, it may be that the
- extended GNU triplet that specifies an ABI (like the @code{eabi} suffix
- above) is not recognized by all the GNU tools. Typically, glibc
- recognizes some of these, whereas GCC uses an extra @code{--with-abi}
- configure flag (see @code{gcc.scm} for examples of how to handle this).
- Second, some of the required packages could fail to build for that
- platform. Lastly, the generated binaries could be broken for some
- reason.
-
- @c *********************************************************************
- @include contributing.texi
-
- @c *********************************************************************
- @node Acknowledgments
- @chapter Acknowledgments
-
- Guix is based on the Nix package manager, which was designed and
- implemented by Eelco Dolstra, with contributions from other people (see
- the @file{nix/AUTHORS} file in Guix.) Nix pioneered functional package
- management, and promoted unprecedented features, such as transactional
- package upgrades and rollbacks, per-user profiles, and referentially
- transparent build processes. Without this work, Guix would not exist.
-
- The Nix-based software distributions, Nixpkgs and NixOS, have also been
- an inspiration for Guix.
-
- GNU@tie{}Guix itself is a collective work with contributions from a
- number of people. See the @file{AUTHORS} file in Guix for more
- information on these fine people. The @file{THANKS} file lists people
- who have helped by reporting bugs, taking care of the infrastructure,
- providing artwork and themes, making suggestions, and more---thank you!
-
-
- @c *********************************************************************
- @node GNU Free Documentation License
- @appendix GNU Free Documentation License
-
- @include fdl-1.3.texi
-
- @c *********************************************************************
- @node Concept Index
- @unnumbered Concept Index
- @printindex cp
-
- @node Programming Index
- @unnumbered Programming Index
- @syncodeindex tp fn
- @syncodeindex vr fn
- @printindex fn
-
- @bye
-
- @c Local Variables:
- @c ispell-local-dictionary: "american";
- @c End:
|