In some places, "<n> bits" is used when more appropriate.
sd_bus_emit_signal_tov(), and sd_bus_message_new_signal_to().
* sd-id128 functions now return -EUCLEAN (instead of -EIO) when the
- 128bit ID in files such as /etc/machine-id has an invalid
+ 128-bit ID in files such as /etc/machine-id has an invalid
format. They also accept NULL as output parameter in more places,
which is useful when the caller only wants to validate the inputs and
does not need the output value.
* libsystemd now exports sd_bus_error_setfv() (a convenience function
for setting bus errors), sd_id128_string_equal (a convenience
- function for 128bit ID string comparisons), and
+ function for 128-bit ID string comparisons), and
sd_bus_message_read_strv_extend() (a function to incrementally read
string arrays).
of activated home directories it manages (if the kernel and selected
file systems support it). So far it mapped three UID ranges: the
range from 0…60000, the user's own UID, and the range 60514…65534,
- leaving everything else unmapped (in other words, the 16bit UID range
+ leaving everything else unmapped (in other words, the 16-bit UID range
is mapped almost fully, with the exception of the UID subrange used
for systemd-homed users, with one exception: the user's own UID).
Unmapped UIDs may not be used for file ownership in the home
systemd-timedated.
* The systemd-id128 tool gained a new "show" verb for listing or
- resolving a number of well-known UUIDs/128bit IDs, currently mostly
+ resolving a number of well-known UUIDs/128-bit IDs, currently mostly
GPT partition table types.
* The Discoverable Partitions Specification has been updated to support
path as the system manager.
* The systemd-id128 tool gained a new switch "-u" (or "--uuid") for
- outputting the 128bit IDs in UUID format (i.e. in the "canonical
+ outputting the 128-bit IDs in UUID format (i.e. in the "canonical
representation").
* Service units gained a new sandboxing option ProtectKernelLogs= which
* On 64 bit systems, the "kernel.pid_max" sysctl is now bumped to
4194304 by default, i.e. the full 22bit range the kernel allows, up
- from the old 16bit range. This should improve security and
+ from the old 16-bit range. This should improve security and
robustness, as PID collisions are made less likely (though certainly
still possible). There are rumours this might create compatibility
problems, though at this moment no practical ones are known to
with gcc's cleanup extension.
* The sd-id128.h public API gained a new definition
- SD_ID128_UUID_FORMAT_STR for formatting a 128bit ID in UUID format
+ SD_ID128_UUID_FORMAT_STR for formatting a 128-bit ID in UUID format
with printf().
* "busctl introspect" gained a new switch --xml-interface for dumping
ID.
* A new tool systemd-id128 has been added that can be used to determine
- and generate various 128bit IDs.
+ and generate various 128-bit IDs.
* /etc/os-release gained two new standardized fields DOCUMENTATION_URL=
and LOGO=.
is improved.
* sd-id128.h learnt two new auxiliary helpers: sd_id128_is_allf() and
- SD_ID128_ALLF to test if a 128bit ID is set to all 0xFF bytes, and to
+ SD_ID128_ALLF to test if a 128-bit ID is set to all 0xFF bytes, and to
initialize one to all 0xFF.
* After loading the SELinux policy systemd will now recursively relabel
Verity root partitions when systemd boots up. In order to make use of
this your partition setup should follow the Discoverable Partitions
Specification, and the GPT partition ID of the root file system
- partition should be identical to the upper 128bit of the Verity root
+ partition should be identical to the upper 128-bit of the Verity root
hash. The GPT partition ID of the Verity partition protecting it
- should be the lower 128bit of the Verity root hash. If the partition
+ should be the lower 128-bit of the Verity root hash. If the partition
image follows this model it is sufficient to specify a single
"roothash=" kernel command line argument to both configure which root
image and verity partition to use as well as the root hash for
* The service manager learnt a new "invocation ID" concept for invoked
services. Each runtime cycle of a service will get a new invocation
- ID (a 128bit random UUID) assigned that identifies the current
+ ID (a 128-bit random UUID) assigned that identifies the current
run of the service uniquely and globally. A new invocation ID
is generated each time a service starts up. The journal will store
the invocation ID of a service along with any logged messages, thus
identifier that was booted. It is set by the boot loader and read by
the OS in order to identify which entry has been used for the current boot.
-* The EFI variable `LoaderFeatures` contains a 64bit unsigned integer with a
+* The EFI variable `LoaderFeatures` contains a 64-bit unsigned integer with a
number of flags bits that are set by the boot loader and passed to the OS and
indicate the features the boot loader supports. Specifically, the following
bits are defined:
1. Remove the
[`/etc/machine-id`](https://www.freedesktop.org/software/systemd/man/machine-id.html)
file or write the string `uninitialized\n` into it. This file is supposed to
- carry a 128bit identifier unique to the system. Only when it is reset it
+ carry a 128-bit identifier unique to the system. Only when it is reset it
will be auto-generated on first boot and thus be truly unique. If this file
is not reset, and carries a valid ID every instance of the system will come
up with the same ID and that will likely lead to problems sooner or later,
compatibility. Since we typically want to allow adding new enum values to an
existing enum type with later API versions, please use the
`_SD_ENUM_FORCE_S64()` macro in the enum definition, which forces the size of
- the enum to be signed 64bit wide.
+ the enum to be signed 64-bit wide.
- Empty lines to separate code blocks are a good thing, please add them
abundantly. However, please stick to one at a time, i.e. multiple empty lines
When it comes to JSON numbers, this specification assumes that JSON parsers
processing this information are capable of reproducing the full signed 53bit
-integer range (i.e. -2⁵³+1…+2⁵³-1) as well as the full 64bit IEEE floating
+integer range (i.e. -2⁵³+1…+2⁵³-1) as well as the full 64-bit IEEE floating
point number range losslessly (with the exception of NaN/-inf/+inf, since JSON
cannot encode that), as per recommendations of
[RFC8259](https://datatracker.ietf.org/doc/html/rfc8259#page-8). Fields in
`service` → A string, an identifier for the service managing this group record
(this field is typically in reverse domain name syntax.)
-`lastChangeUSec` → An unsigned 64bit integer, a timestamp (in µs since the UNIX
+`lastChangeUSec` → An unsigned 64-bit integer, a timestamp (in µs since the UNIX
epoch 1970) of the last time the group record has been modified. (Covers only
the `regular`, `perMachine` and `privileged` sections).
* Two journal entries that follow each other are separated by a double newline.
* Journal fields consisting only of valid non-control UTF-8 codepoints are serialized as they are (i.e. the field name, followed by '=', followed by field data), followed by a newline as separator to the next field. Note that fields containing newlines cannot be formatted like this. Non-control UTF-8 codepoints are the codepoints with value at or above 32 (' '), or equal to 9 (TAB).
-* Other journal fields are serialized in a special binary safe way: field name, followed by newline, followed by a binary 64bit little endian size value, followed by the binary field data, followed by a newline as separator to the next field.
+* Other journal fields are serialized in a special binary safe way: field name, followed by newline, followed by a binary 64-bit little endian size value, followed by the binary field data, followed by a newline as separator to the next field.
* Entry metadata that is not actually a field is serialized like it was a field, but beginning with two underscores. More specifically, `__CURSOR=`, `__REALTIME_TIMESTAMP=`, `__MONOTONIC_TIMESTAMP=`, `__SEQNUM=`, `__SEQNUM_ID` are introduced this way. Note that these meta-fields are only generated when actual journal files are serialized. They are omitted for entries that do not originate from a journal file (for example because they are transferred for the first time to be stored in one). Or in other words: if you are generating this format you shouldn't care about these special double-underscore fields. But you might find them usable when you deserialize the format generated by us. Additional fields prefixed with two underscores might be added later on, your parser should skip over the fields it does not know.
* The order in which fields appear in an entry is undefined and might be different for each entry that is serialized.
And that's already it.
## Basics
-* All offsets, sizes, time values, hashes (and most other numeric values) are 32bit/64bit unsigned integers in LE format.
+* All offsets, sizes, time values, hashes (and most other numeric values) are 32-bit/64-bit unsigned integers in LE format.
* Offsets are always relative to the beginning of the file.
-* The 64bit hash function siphash24 is used for newer journal files. For older files [Jenkins lookup3](https://en.wikipedia.org/wiki/Jenkins_hash_function) is used, more specifically `jenkins_hashlittle2()` with the first 32bit integer it returns as higher 32bit part of the 64bit value, and the second one uses as lower 32bit part.
-* All structures are aligned to 64bit boundaries and padded to multiples of 64bit
+* The 64-bit hash function siphash24 is used for newer journal files. For older files [Jenkins lookup3](https://en.wikipedia.org/wiki/Jenkins_hash_function) is used, more specifically `jenkins_hashlittle2()` with the first 32-bit integer it returns as higher 32-bit part of the 64-bit value, and the second one uses as lower 32-bit part.
+* All structures are aligned to 64-bit boundaries and padded to multiples of 64-bit
* The format is designed to be read and written via memory mapping using multiple mapped windows.
* All time values are stored in usec since the respective epoch.
* Wall clock time values are relative to the Unix time epoch, i.e. January 1st, 1970. (`CLOCK_REALTIME`)
* Monotonic time values are always stored jointly with the kernel boot ID value (i.e. `/proc/sys/kernel/random/boot_id`) they belong to. They tend to be relative to the start of the boot, but aren't for containers. (`CLOCK_MONOTONIC`)
-* Randomized, unique 128bit IDs are used in various locations. These are generally UUID v4 compatible, but this is not a requirement.
+* Randomized, unique 128-bit IDs are used in various locations. These are generally UUID v4 compatible, but this is not a requirement.
## General Rules
objects, i.e. keyed by the file ID).
If the `HEADER_INCOMPATIBLE_COMPACT` flag is set, DATA object offsets are stored
-as 32-bit integers instead of 64bit and the unused hash field per data object is
+as 32-bit integers instead of 64-bit and the unused hash field per data object is
not stored anymore.
In the file ENTRY objects are written ordered monotonically by sequence
and sequence numbers (with some restrictions, see above).
If the `HEADER_INCOMPATIBLE_COMPACT` flag is set, offsets are stored as 32-bit
-integers instead of 64bit.
+integers instead of 64-bit.
Entry Arrays are chained up. If one entry array is full another one is
allocated and the **next_entry_array_offset** field of the old one pointed to
* The second method should be used if the value of a field contains a `\n`
byte. In this case, the key name is serialized as is, followed by a `\n`
-character, followed by a (non-aligned) little-endian unsigned 64bit integer
+character, followed by a (non-aligned) little-endian unsigned 64-bit integer
encoding the size of the value, followed by the literal value data, followed by
`\n`. Example: a key `FOO` with a value `BAR` may be serialized using this
second method as: `F`, `O`, `O`, `\n`, `\003`, `\000`, `\000`, `\000`, `\000`,
## Special Linux UIDs
-In theory, the range of the C type `uid_t` is 32bit wide on Linux,
+In theory, the range of the C type `uid_t` is 32-bit wide on Linux,
i.e. 0…4294967295. However, four UIDs are special on Linux:
1. 0 → The `root` super-user
2. 65534 → The `nobody` UID, also called the "overflow" UID or similar. It's
where various subsystems map unmappable users to, for example file systems
- only supporting 16bit UIDs, NFS or user namespacing. (The latter can be
+ only supporting 16-bit UIDs, NFS or user namespacing. (The latter can be
changed with a sysctl during runtime, but that's not supported on
`systemd`. If you do change it you void your warranty.) Because Fedora is a
bit confused the `nobody` user is called `nfsnobody` there (and they have a
though. (Also, some distributions call the `nobody` group `nogroup`. I wish
they didn't.)
-3. 4294967295, aka "32bit `(uid_t) -1`" → This UID is not a valid user ID, as
+3. 4294967295, aka "32-bit `(uid_t) -1`" → This UID is not a valid user ID, as
`setresuid()`, `chown()` and friends treat -1 as a special request to not
change the UID of the process/file. This UID is hence not available for
assignment to users in the user database.
-4. 65535, aka "16bit `(uid_t) -1`" → Before Linux kernel 2.4 `uid_t` used to be
- 16bit, and programs compiled for that would hence assume that `(uid_t) -1`
+4. 65535, aka "16-bit `(uid_t) -1`" → Before Linux kernel 2.4 `uid_t` used to be
+ 16-bit, and programs compiled for that would hence assume that `(uid_t) -1`
is 65535. This UID is hence not usable either.
The `nss-systemd` glibc NSS module will synthesize user database records for
2. 61184…65519 → UIDs for dynamic users are allocated from this range (see the
`DynamicUser=` documentation in
[`systemd.exec(5)`](https://www.freedesktop.org/software/systemd/man/systemd.exec.html)). This
- range has been chosen so that it is below the 16bit boundary (i.e. below
+ range has been chosen so that it is below the 16-bit boundary (i.e. below
65535), in order to provide compatibility with container environments that
assign a 64K range of UIDs to containers using user namespacing. This range
is above the 60000 boundary, so that its allocations are unlikely to be
3. 524288…1879048191 → UID range for `systemd-nspawn`'s automatic allocation of
per-container UID ranges. When the `--private-users=pick` switch is used (or
- `-U`) then it will automatically find a so far unused 16bit subrange of this
+ `-U`) then it will automatically find a so far unused 16-bit subrange of this
range and assign it to the container. The range is picked so that the upper
- 16bit of the 32bit UIDs are constant for all users of the container, while
- the lower 16bit directly encode the 65536 UIDs assigned to the
- container. This mode of allocation means that the upper 16bit of any UID
- assigned to a container are kind of a "container ID", while the lower 16bit
+ 16-bit of the 32-bit UIDs are constant for all users of the container, while
+ the lower 16-bit directly encode the 65536 UIDs assigned to the
+ container. This mode of allocation means that the upper 16-bit of any UID
+ assigned to a container are kind of a "container ID", while the lower 16-bit
directly expose the container's own UID numbers. If you wonder why precisely
these numbers, consider them in hexadecimal: 0x00080000…0x6FFFFFFF. This
- range is above the 16bit boundary. Moreover it's below the 31bit boundary,
+ range is above the 16-bit boundary. Moreover it's below the 31-bit boundary,
as some broken code (specifically: the kernel's `devpts` file system)
erroneously considers UIDs signed integers, and hence can't deal with values
above 2^31. The `systemd-machined.service` service will synthesize user
1. Definitely, don't assign less than 65536 UIDs/GIDs. After all the `nobody`
user has magic properties, and hence should be available in your container, and
-given that it's assigned the UID 65534, you should really cover the full 16bit
+given that it's assigned the UID 65534, you should really cover the full 16-bit
range in your container. Note that systemd will — as mentioned — synthesize
user records for the `nobody` user, and assumes its availability in various
other parts of its codebase, too, hence assigning fewer users means you lose
2. While it's fine to assign more than 65536 UIDs/GIDs to a container, there's
most likely not much value in doing so, as Linux distributions won't use the
higher ranges by default (as mentioned neither `adduser` nor `systemd`'s
-dynamic user concept allocate from above the 16bit range). Unless you actively
+dynamic user concept allocate from above the 16-bit range). Unless you actively
care for nested containers, it's hence probably a good idea to allocate exactly
65536 UIDs per container, and neither less nor more. A pretty side-effect is
that by doing so, you expose the same number of UIDs per container as Linux 2.2
supported for the whole system, back in the days.
3. Consider allocating UID ranges for containers so that the first UID you
-assign has the lower 16bits all set to zero. That way, the upper 16bits become
-a container ID of some kind, while the lower 16bits directly encode the
+assign has the lower 16-bits all set to zero. That way, the upper 16-bits become
+a container ID of some kind, while the lower 16-bits directly encode the
internal container UID. This is the way `systemd-nspawn` allocates UID ranges
(see above). Following this allocation logic ensures best compatibility with
`systemd-nspawn` and all other container managers following the scheme, as it
system trees nicely robust to interruptions: as the external UID encodes the
internal UID in a fixed way, it's very easy to adjust the container's base UID
without the need to know the original base UID: to change the container base,
-just mask away the upper 16bit, and insert the upper 16bit of the new container
+just mask away the upper 16-bit, and insert the upper 16-bit of the new container
base instead. Here are the easy conversions to derive the internal UID, the
external UID, and the container base UID from each other:
| 6…999 | System users | Distributions | `/etc/passwd` |
| 1000…60000 | Regular users | Distributions | `/etc/passwd` + LDAP/NIS/… |
| 60001…60513 | Human users (homed) | `systemd` | `nss-systemd` |
-| 60514…60577 | Host users mapped into containers | `systemd` | `systemd-nspawn` |
+| 60514…60577 | Host users mapped into containers | `systemd` | `systemd-nspawn` |
| 60578…61183 | Unused | | |
| 61184…65519 | Dynamic service users | `systemd` | `nss-systemd` |
| 65520…65533 | Unused | | |
| 65534 | `nobody` user | Linux | `/etc/passwd` + `nss-systemd` |
-| 65535 | 16bit `(uid_t) -1` | Linux | |
+| 65535 | 16-bit `(uid_t) -1` | Linux | |
| 65536…524287 | Unused | | |
| 524288…1879048191 | Container UID ranges | `systemd` | `nss-systemd` |
| 1879048192…2147483647 | Unused | | |
| 2147483648…4294967294 | HIC SVNT LEONES | | |
-| 4294967295 | 32bit `(uid_t) -1` | Linux | |
+| 4294967295 | 32-bit `(uid_t) -1` | Linux | |
Note that "Unused" in the table above doesn't mean that these ranges are
really unused. It just means that these ranges have no well-established
Note that the range 2147483648…4294967294 (i.e. 2^31…2^32-2) should be handled
with care. Various programs (including kernel file systems — see `devpts` — or
even kernel syscalls – see `setfsuid()`) have trouble with UIDs outside of the
-signed 32bit range, i.e any UIDs equal to or above 2147483648. It is thus
+signed 32-bit range, i.e any UIDs equal to or above 2147483648. It is thus
strongly recommended to stay away from this range in order to avoid
complications. This range should be considered reserved for future, special
purposes.
field, based on other fields, for example the numeric UID. By setting this
field explicitly applications can override this default determination.
-`lastChangeUSec` → An unsigned 64bit integer value, referring to a timestamp in µs
+`lastChangeUSec` → An unsigned 64-bit integer value, referring to a timestamp in µs
since the epoch 1970, indicating when the user record (specifically, any of the
`regular`, `privileged`, `perMachine` sections) was last changed. This field is
used when comparing two records of the same user to identify the newer one, and
is used for example for automatic updating of user records, where appropriate.
-`lastPasswordChangeUSec` → Similar, also an unsigned 64bit integer value,
+`lastPasswordChangeUSec` → Similar, also an unsigned 64-bit integer value,
indicating the point in time the password (or any authentication token) of the
user was last changed. This corresponds to the `sp_lstchg` field of `struct
spwd`, i.e. the matching field in the user shadow database `/etc/shadow`,
`struct spwd` (i.e. the `/etc/shadow` data for a user) being set to zero or
one.
-`notBeforeUSec` → An unsigned 64bit integer value, indicating a time in µs since
+`notBeforeUSec` → An unsigned 64-bit integer value, indicating a time in µs since
the UNIX epoch (1970) before which the record should be considered invalid for
the purpose of logging in.
`systemd-homed` when managing home directories, but may be used if other
managers are used too. If this is not set, `classic` is the implied default.
-`diskSize` → An unsigned 64bit integer, indicating the intended home directory
+`diskSize` → An unsigned 64-bit integer, indicating the intended home directory
disk space in bytes to assign to the user. Depending on the selected storage
type this might be implemented differently: for `luks` this is the intended size
of the file system and LUKS volume, while for the others this likely translates
`accessMode` → Takes an unsigned integer in the range 0…511 indicating the UNIX
access mask for the home directory when it is first created.
-`tasksMax` → Takes an unsigned 64bit integer indicating the maximum number of
+`tasksMax` → Takes an unsigned 64-bit integer indicating the maximum number of
tasks the user may start in parallel during system runtime. This counts
all tasks (i.e. threads, where each process is at least one thread) the user starts or that are
forked from these processes even if the user identity is changed (for example
enforces this by setting the `TasksMax` slice property for the user's slice
`user-$UID.slice`.
-`memoryHigh`/`memoryMax` → These take unsigned 64bit integers indicating upper
+`memoryHigh`/`memoryMax` → These take unsigned 64-bit integers indicating upper
memory limits for all processes of the user (plus all processes forked off them
that might have changed user identity), in bytes. Enforced by
[`systemd-logind.service`](https://www.freedesktop.org/software/systemd/man/systemd-logind.service.html),
`luksPbkdfType` → A string, indicating the PBKDF type to use for the LUKS storage mechanism.
-`luksPbkdfForceIterations` → An unsigned 64bit integer, indicating the intended
+`luksPbkdfForceIterations` → An unsigned 64-bit integer, indicating the intended
number of iterations for the PBKDF operation, when LUKS storage is used.
-`luksPbkdfTimeCostUSec` → An unsigned 64bit integer, indicating the intended
+`luksPbkdfTimeCostUSec` → An unsigned 64-bit integer, indicating the intended
time cost for the PBKDF operation, when the LUKS storage mechanism is used, in
µs. Ignored when `luksPbkdfForceIterations` is set.
-`luksPbkdfMemoryCost` → An unsigned 64bit integer, indicating the intended
+`luksPbkdfMemoryCost` → An unsigned 64-bit integer, indicating the intended
memory cost for the PBKDF operation, when LUKS storage is used, in bytes.
-`luksPbkdfParallelThreads` → An unsigned 64bit integer, indicating the intended
+`luksPbkdfParallelThreads` → An unsigned 64-bit integer, indicating the intended
required parallel threads for the PBKDF operation, when LUKS storage is used.
-`luksSectorSize` → An unsigned 64bit integer, indicating the sector size to
+`luksSectorSize` → An unsigned 64-bit integer, indicating the sector size to
use for the LUKS storage mechanism, in bytes. Must be a power of two between
512 and 4096.
example, if `systemd-homed` manages a user a string of `io.systemd.Home` is
used for this.
-`rateLimitIntervalUSec` → An unsigned 64bit integer that configures the
+`rateLimitIntervalUSec` → An unsigned 64-bit integer that configures the
authentication rate limiting enforced on the user account. This specifies a
timer interval (in µs) within which to count authentication attempts. When the
counter goes above the value configured n `rateLimitIntervalBurst` log-ins are
temporarily refused until the interval passes.
-`rateLimitIntervalBurst` → An unsigned 64bit integer, closely related to
+`rateLimitIntervalBurst` → An unsigned 64-bit integer, closely related to
`rateLimitIntervalUSec`, that puts a limit on authentication attempts within
the configured time interval.
auto-login. Systems are supposed to automatically log in a user marked this way
during boot, if there's exactly one user on it defined this way.
-`stopDelayUSec` → An unsigned 64bit integer, indicating the time in µs the
+`stopDelayUSec` → An unsigned 64-bit integer, indicating the time in µs the
per-user service manager is kept around after the user fully logged out. This
value is honored by
[`systemd-logind.service`](https://www.freedesktop.org/software/systemd/man/systemd-logind.service.html). If
[`systemd-logind.service`](https://www.freedesktop.org/software/systemd/man/systemd-logind.service.html). If
false any processes left around when the user logs out are left running.
-`passwordChangeMinUSec`/`passwordChangeMaxUSec` → An unsigned 64bit integer,
+`passwordChangeMinUSec`/`passwordChangeMaxUSec` → An unsigned 64-bit integer,
encoding how much time has to pass at least/at most between password changes of
the user. This corresponds with the `sp_min` and `sp_max` fields of `struct
spwd` (i.e. the `/etc/shadow` entries of the user), but offers finer
granularity.
-`passwordChangeWarnUSec` → An unsigned 64bit integer, encoding how much time to
+`passwordChangeWarnUSec` → An unsigned 64-bit integer, encoding how much time to
warn the user before their password expires, in µs. This corresponds with the
`sp_warn` field of `struct spwd`.
-`passwordChangeInactiveUSec` → An unsigned 64bit integer, encoding how much
+`passwordChangeInactiveUSec` → An unsigned 64-bit integer, encoding how much
time has to pass after the password expired that the account is
deactivated. This corresponds with the `sp_inact` field of `struct spwd`.
The following fields are defined in this section:
-`matchMachineId` → An array of strings that are formatted 128bit IDs in
+`matchMachineId` → An array of strings that are formatted 128-bit IDs in
hex. If any of the specified IDs match the system's local machine ID
(i.e. matches `/etc/machine-id`) the fields in this object are honored.
which points to the object with the fields defined here. The following fields
are defined:
-`diskUsage` → An unsigned 64bit integer. The currently used disk space of the
+`diskUsage` → An unsigned 64-bit integer. The currently used disk space of the
home directory in bytes. This value might be determined in different ways,
depending on the selected storage mechanism. For LUKS storage this is the file
size of the loopback file or block device size. For the
directory/subvolume/fscrypt storage this is the current disk space used as
reported by the file system quota subsystem.
-`diskFree` → An unsigned 64bit integer, denoting the number of "free" bytes in
+`diskFree` → An unsigned 64-bit integer, denoting the number of "free" bytes in
the disk space allotment, i.e. usually the difference between the disk size as
reported by `diskSize` and the used already as reported in `diskFree`, but
possibly skewed by metadata sizes, disk compression and similar.
-`diskSize` → An unsigned 64bit integer, denoting the disk space currently
+`diskSize` → An unsigned 64-bit integer, denoting the disk space currently
allotted to the user, in bytes. Depending on the storage mechanism this can mean
different things (see above). In contrast to the top-level field of the same
(or the one in the `perMachine` section), this field reports the current size
allotted to the user, not the intended one. The values may differ when user
records are updated without the home directory being re-sized.
-`diskCeiling`/`diskFloor` → Unsigned 64bit integers indicating upper and lower
+`diskCeiling`/`diskFloor` → Unsigned 64-bit integers indicating upper and lower
bounds when changing the `diskSize` value, in bytes. These values are typically
derived from the underlying data storage, and indicate in which range the home
directory may be re-sized in, i.e. in which sensible range the `diskSize` value
locally. This means the user record cannot be modified locally as it couldn't
be signed afterwards.
-`goodAuthenticationCounter` → An unsigned 64bit integer. This counter is
+`goodAuthenticationCounter` → An unsigned 64-bit integer. This counter is
increased by one on every successful authentication attempt, i.e. an
authentication attempt where a security token of some form was presented and it
was correct.
-`badAuthenticationCounter` → An unsigned 64bit integer. This counter is
+`badAuthenticationCounter` → An unsigned 64-bit integer. This counter is
increased by one on every unsuccessfully authentication attempt, i.e. an
authentication attempt where a security token of some form was presented and it
was incorrect.
-`lastGoodAuthenticationUSec` → An unsigned 64bit integer, indicating the time
+`lastGoodAuthenticationUSec` → An unsigned 64-bit integer, indicating the time
of the last successful authentication attempt in µs since the UNIX epoch (1970).
`lastBadAuthenticationUSec` → Similar, but the timestamp of the last
unsuccessfully authentication attempt.
-`rateLimitBeginUSec` → An unsigned 64bit integer: the µs timestamp since the
+`rateLimitBeginUSec` → An unsigned 64-bit integer: the µs timestamp since the
UNIX epoch (1970) where the most recent rate limiting interval has been
started, as configured with `rateLimitIntervalUSec`.
-`rateLimitCount` → An unsigned 64bit integer, counting the authentication
+`rateLimitCount` → An unsigned 64-bit integer, counting the authentication
attempts in the current rate limiting interval, see above. If this counter
grows beyond the value configured in `rateLimitBurst` authentication attempts
are temporarily refused.
<listitem><para>The maximum size in bytes of a core which will be processed. Core dumps exceeding
this size may be stored, but the backtrace will not be generated. Like other sizes in this same
config file, the usual suffixes to the base of 1024 are allowed (B, K, M, G, T, P, and E). Defaults
- to 1G on 32bit systems, 32G on 64bit systems.</para>
+ to 1G on 32-bit systems, 32G on 64-bit systems.</para>
<para>Setting <varname>Storage=none</varname> and <varname>ProcessSizeMax=0</varname>
disables all coredump handling except for a log entry.</para>
<listitem><para>The GPT partition type UUID to match. This may be a GPT partition type UUID such as
<constant>4f68bce3-e8cd-4db1-96e7-fbcaf984b709</constant>, or an identifier.
Architecture specific partition types can use one of these architecture identifiers:
- <constant>alpha</constant>, <constant>arc</constant>, <constant>arm</constant> (32bit),
- <constant>arm64</constant> (64bit, aka aarch64), <constant>ia64</constant>,
+ <constant>alpha</constant>, <constant>arc</constant>, <constant>arm</constant> (32-bit),
+ <constant>arm64</constant> (64-bit, aka aarch64), <constant>ia64</constant>,
<constant>loongarch64</constant>, <constant>mips-le</constant>, <constant>mips64-le</constant>,
<constant>parisc</constant>, <constant>ppc</constant>, <constant>ppc64</constant>,
<constant>ppc64-le</constant>, <constant>riscv32</constant>, <constant>riscv64</constant>,
<constant>s390</constant>, <constant>s390x</constant>, <constant>tilegx</constant>,
- <constant>x86</constant> (32bit, aka i386) and <constant>x86-64</constant> (64bit, aka amd64).
+ <constant>x86</constant> (32-bit, aka i386) and <constant>x86-64</constant> (64-bit, aka amd64).
The supported identifiers are:</para>
<row>
<entry><constant>root-secondary</constant></entry>
- <entry>Root file system partition of the secondary architecture of the local architecture (usually the matching 32bit architecture for the local 64bit architecture)</entry>
+ <entry>Root file system partition of the secondary architecture of the local architecture (usually the matching 32-bit architecture for the local 64-bit architecture)</entry>
</row>
<row>
<row>
<entry><constant>usr-secondary</constant></entry>
- <entry><filename>/usr/</filename> file system partition of the secondary architecture of the local architecture (usually the matching 32bit architecture for the local 64bit architecture)</entry>
+ <entry><filename>/usr/</filename> file system partition of the secondary architecture of the local architecture (usually the matching 32-bit architecture for the local 64-bit architecture)</entry>
</row>
<row>
<varlistentry>
<term><varname>Flags=</varname></term>
- <listitem><para>Configures the 64bit GPT partition flags field to set for the partition when creating
+ <listitem><para>Configures the 64-bit GPT partition flags field to set for the partition when creating
it. This option has no effect if the partition already exists. If not specified the flags values is
set to all zeroes, except for the three bits that can also be configured via
<varname>NoAuto=</varname>, <varname>ReadOnly=</varname> and <varname>GrowFileSystem=</varname>; see
other event sources or at event loop termination. See
<citerefentry><refentrytitle>sd_event_add_defer</refentrytitle><manvolnum>3</manvolnum></citerefentry>.</para></listitem>
- <listitem><para>Event sources may be assigned a 64bit priority
+ <listitem><para>Event sources may be assigned a 64-bit priority
value, that controls the order in which event sources are
dispatched if multiple are pending simultaneously. See
<citerefentry><refentrytitle>sd_event_source_set_priority</refentrytitle><manvolnum>3</manvolnum></citerefentry>.</para></listitem>
<function>sd_bus_get_n_queued_read()</function> may be used to query the number of bus messages in the read queue
of a bus connection object. The read queue contains all messages read from the transport medium (e.g. network
socket) but not yet processed locally. The function expects two arguments: the bus object to query, and a pointer
- to a 64bit counter variable to write the current queue size to. Use <function>sd_bus_process()</function> in
+ to a 64-bit counter variable to write the current queue size to. Use <function>sd_bus_process()</function> in
order to process queued messages, i.e. to reduce the size of the read queue (as well as, in fact, the write
queue, see below).
</para>
<row>
<entry><literal>y</literal></entry>
<entry><constant>SD_BUS_TYPE_BYTE</constant></entry>
- <entry>8bit unsigned integer</entry>
+ <entry>8-bit unsigned integer</entry>
<entry><type>uint8_t *</type></entry>
</row>
<row>
<entry><literal>n</literal></entry>
<entry><constant>SD_BUS_TYPE_INT16</constant></entry>
- <entry>16bit signed integer</entry>
+ <entry>16-bit signed integer</entry>
<entry><type>int16_t *</type></entry>
</row>
<row>
<entry><literal>q</literal></entry>
<entry><constant>SD_BUS_TYPE_UINT16</constant></entry>
- <entry>16bit unsigned integer</entry>
+ <entry>16-bit unsigned integer</entry>
<entry><type>uint16_t *</type></entry>
</row>
<row>
<entry><literal>i</literal></entry>
<entry><constant>SD_BUS_TYPE_INT32</constant></entry>
- <entry>32bit signed integer</entry>
+ <entry>32-bit signed integer</entry>
<entry><type>int32_t *</type></entry>
</row>
<row>
<entry><literal>u</literal></entry>
<entry><constant>SD_BUS_TYPE_UINT32</constant></entry>
- <entry>32bit unsigned integer</entry>
+ <entry>32-bit unsigned integer</entry>
<entry><type>uint32_t *</type></entry>
</row>
<row>
<entry><literal>x</literal></entry>
<entry><constant>SD_BUS_TYPE_INT64</constant></entry>
- <entry>64bit signed integer</entry>
+ <entry>64-bit signed integer</entry>
<entry><type>int64_t *</type></entry>
</row>
<row>
<entry><literal>t</literal></entry>
<entry><constant>SD_BUS_TYPE_UINT64</constant></entry>
- <entry>64bit unsigned integer</entry>
+ <entry>64-bit unsigned integer</entry>
<entry><type>uint64_t *</type></entry>
</row>
<para><function>sd_event_source_set_priority()</function> may be
used to set the priority for the event source object specified as
<parameter>source</parameter>. The priority is specified as an
- arbitrary signed 64bit integer. The priority is initialized to
+ arbitrary signed 64-bit integer. The priority is initialized to
<constant>SD_EVENT_PRIORITY_NORMAL</constant> (0) when the event
source is allocated with a call such as
<citerefentry><refentrytitle>sd_event_add_io</refentrytitle><manvolnum>3</manvolnum></citerefentry>
<constant>SD_EVENT_PRIORITY_IDLE</constant> (100) may be used to
indicate event sources that shall be dispatched early, normally or
late. It is recommended to specify priorities based on these
- definitions, and relative to them — however, the full 64bit
+ definitions, and relative to them — however, the full 64-bit
signed integer range is available for ordering event
sources.</para>
of the states described below.</para>
<para><function>sd_event_get_iteration()</function> may be used to determine the current iteration of the event
- loop. It returns an unsigned 64bit integer containing a counter that increases monotonically with each iteration of
+ loop. It returns an unsigned 64-bit integer containing a counter that increases monotonically with each iteration of
the event loop, starting with 0. The counter is increased at the time of the
<function>sd_event_prepare()</function> invocation.</para>
a string representation of a 128-bit ID in a buffer that is valid in the current code block.</para>
<para><function>sd_id128_to_uuid_string()</function> and <function>SD_ID128_TO_UUID_STRING()</function>
- are similar to these two functions/macros, but format the 128bit values as RFC4122 UUIDs, i.e. a series
+ are similar to these two functions/macros, but format the 128-bit values as RFC4122 UUIDs, i.e. a series
of 36 lowercase hexadeciaml digits and dashes, terminated by a <constant>NUL</constant> byte.</para>
<para><function>sd_id128_from_string()</function> implements the reverse operation: it takes a 33
<para><function>sd_journal_get_seqnum()</function> returns the sequence number of the current journal
entry. It takes three arguments: the journal context object, a pointer to a 64-bit unsigned integer to
- store the sequence number in, and a buffer to return the 128bit sequence number ID in.</para>
+ store the sequence number in, and a buffer to return the 128-bit sequence number ID in.</para>
<para>When writing journal entries to disk each <command>systemd-journald</command> instance will number
them sequentially, starting from 1 for the first entry written after subsystem initialization. Each such
- series of sequence numbers is associated with a 128bit sequence number ID which is initialized randomly,
+ series of sequence numbers is associated with a 128-bit sequence number ID which is initialized randomly,
once at <command>systemd-journal</command> initialization. Thus, while multiple instances of
<command>systemd-journald</command> will assign the same sequence numbers to their written journal
entries, they will have a distinct sequence number IDs. The sequence number is assigned at the moment of
project='man-pages'><refentrytitle>sigqueue</refentrytitle><manvolnum>3</manvolnum></citerefentry>
system call, rather than <citerefentry
project='man-pages'><refentrytitle>kill</refentrytitle><manvolnum>3</manvolnum></citerefentry>. The
- specified value must be a 32bit signed integer, and may be specified either in decimal, in
+ specified value must be a 32-bit signed integer, and may be specified either in decimal, in
hexadecimal (if prefixed with <literal>0x</literal>), octal (if prefixed with <literal>0o</literal>)
or binary (if prefixed with <literal>0b</literal>)</para>
characters of the appropriate length (i.e. most likely 256 bit/64 characters, or longer). If not specified via
<varname>systemd.verity_root_data=</varname> and <varname>systemd.verity_root_hash=</varname>, the hash and
data devices to use are automatically derived from the specified hash value. Specifically, the data partition
- device is looked for under a GPT partition UUID derived from the first 128bit of the root hash, the hash
- partition device is looked for under a GPT partition UUID derived from the last 128bit of the root hash. Hence
+ device is looked for under a GPT partition UUID derived from the first 128-bit of the root hash, the hash
+ partition device is looked for under a GPT partition UUID derived from the last 128-bit of the root hash. Hence
it is usually sufficient to specify the root hash to boot from a verity protected root file system, as
device paths are automatically determined from it — as long as the partition table is properly set up.</para>
</listitem>
<constant>ppc</constant>, <constant>ppc-le</constant>, <constant>ppc64</constant>,
<constant>ppc64-le</constant>, <constant>s390</constant> or <constant>s390x</constant>. Which
personality architectures are supported depends on the kernel's native architecture. Usually the
- 64bit versions of the various system architectures support their immediate 32bit personality
+ 64-bit versions of the various system architectures support their immediate 32-bit personality
architecture counterpart, but no others. For example, <constant>x86-64</constant> systems support the
<constant>x86-64</constant> and <constant>x86</constant> personalities but no others. The personality
feature is useful when running 32-bit services on a 64-bit host system. If not specified, the
personality is left unmodified and thus reflects the personality of the host system's kernel. This
option is not useful on architectures for which only one native word width was ever available, such
- as <constant>m68k</constant> (32bit only) or <constant>alpha</constant> (64bit only).</para></listitem>
+ as <constant>m68k</constant> (32-bit only) or <constant>alpha</constant> (64-bit only).</para></listitem>
</varlistentry>
<varlistentry>
<varlistentry>
<term><varname>$INVOCATION_ID</varname></term>
- <listitem><para>Contains a randomized, unique 128bit ID identifying each runtime cycle of the unit, formatted
+ <listitem><para>Contains a randomized, unique 128-bit ID identifying each runtime cycle of the unit, formatted
as 32 character hexadecimal string. A new ID is assigned each time the unit changes from an inactive state into
an activating or active state, and may be used to identify this specific runtime cycle, in particular in data
stored offline, such as the journal. The same ID is passed to all processes run as part of the
<varlistentry>
<term><varname>_STREAM_ID=</varname></term>
<listitem>
- <para>Only applies to <literal>_TRANSPORT=stdout</literal> records: specifies a randomized 128bit ID assigned
+ <para>Only applies to <literal>_TRANSPORT=stdout</literal> records: specifies a randomized 128-bit ID assigned
to the stream connection when it was first created. This ID is useful to reconstruct individual log streams
from the log records: all log records carrying the same stream ID originate from the same stream.</para>
</listitem>
<varlistentry>
<term><varname>Backlog=</varname></term>
- <listitem><para>Takes an unsigned 32bit integer argument. Specifies the number of connections to
+ <listitem><para>Takes an unsigned 32-bit integer argument. Specifies the number of connections to
queue that have not been accepted yet. This setting matters only for stream and sequential packet
sockets. See
<citerefentry><refentrytitle>listen</refentrytitle><manvolnum>2</manvolnum></citerefentry> for
/* Maximum space one dirent structure might require at most */
#define DIRENT_SIZE_MAX CONST_MAX(sizeof(struct dirent), offsetof(struct dirent, d_name) + NAME_MAX + 1)
-/* Only if 64bit off_t is enabled struct dirent + struct dirent64 are actually the same. We require this, and
+/* Only if 64-bit off_t is enabled struct dirent + struct dirent64 are actually the same. We require this, and
* we want them to be interchangeable to make getdents64() work, hence verify that. */
assert_cc(_FILE_OFFSET_BITS == 64);
#if HAVE_STRUCT_DIRENT64
}
case 'u': {
- /* C++11 style 16bit unicode */
+ /* C++11 style 16-bit unicode */
int a[4];
size_t i;
}
case 'U': {
- /* C++11 style 32bit unicode */
+ /* C++11 style 32-bit unicode */
int a[8];
size_t i;
extern const struct hash_ops trivial_hash_ops_free;
extern const struct hash_ops trivial_hash_ops_free_free;
-/* 32bit values we can always just embed in the pointer itself, but in order to support 32bit archs we need store 64bit
+/* 32-bit values we can always just embed in the pointer itself, but in order to support 32-bit archs we need store 64-bit
* values indirectly, since they don't fit in a pointer. */
void uint64_hash_func(const uint64_t *p, struct siphash *state);
int uint64_compare_func(const uint64_t *a, const uint64_t *b) _pure_;
extern const struct hash_ops uint64_hash_ops;
-/* On some archs dev_t is 32bit, and on others 64bit. And sometimes it's 64bit on 32bit archs, and sometimes 32bit on
- * 64bit archs. Yuck! */
+/* On some archs dev_t is 32-bit, and on others 64-bit. And sometimes it's 64-bit on 32-bit archs, and sometimes 32-bit on
+ * 64-bit archs. Yuck! */
#if SIZEOF_DEV_T != 8
void devt_hash_func(const dev_t *p, struct siphash *state);
#else
};
struct direct_storage {
- /* This gives us 39 bytes on 64bit, or 35 bytes on 32bit.
- * That's room for 4 set_entries + 4 DIB bytes + 3 unused bytes on 64bit,
- * or 7 set_entries + 7 DIB bytes + 0 unused bytes on 32bit. */
+ /* This gives us 39 bytes on 64-bit, or 35 bytes on 32-bit.
+ * That's room for 4 set_entries + 4 DIB bytes + 3 unused bytes on 64-bit,
+ * or 7 set_entries + 7 DIB bytes + 0 unused bytes on 32-bit. */
uint8_t storage[sizeof(struct indirect_storage)];
};
long sc;
int r;
- /* We return this as uint64_t in case we are running as 32bit process on a 64bit kernel with huge amounts of
+ /* We return this as uint64_t in case we are running as 32-bit process on a 64-bit kernel with huge amounts of
* memory.
*
* In order to support containers nicely that have a configured memory limit we'll take the minimum of the
*
* This limits the numeric range PIDs can take, and thus indirectly also limits the number of
* concurrent threads. It's primarily a compatibility concept: some crappy old code used a signed
- * 16bit type for PIDs, hence the kernel provides a way to ensure the PIDs never go beyond
+ * 16-bit type for PIDs, hence the kernel provides a way to ensure the PIDs never go beyond
* INT16_MAX by default.
*
* Also note the weird definition: PIDs assigned will be kept below this value, which means
return 0;
}
- /* setrlimit(2) suggests rlim_t is always 64bit on Linux. */
+ /* setrlimit(2) suggests rlim_t is always 64-bit on Linux. */
assert_cc(sizeof(rlim_t) == sizeof(uint64_t));
r = safe_atou64(val, &u);
assert(buf_len > 0);
/* This is similar to cmsg_find_data(), but copy the found data to buf. This should be typically used
- * when reading possibly unaligned data such as timestamp, as time_t is 64bit and size_t is 32bit on
+ * when reading possibly unaligned data such as timestamp, as time_t is 64-bit and size_t is 32-bit on
* RISCV32. See issue #27241. */
cmsg = cmsg_find(mh, level, type, CMSG_LEN(buf_len));
* at compile time, that the requested type has a smaller or same alignment as 'struct cmsghdr', and one
* during runtime, that the actual pointer matches the alignment too. This is supposed to catch cases such as
* 'struct timeval' is embedded into 'struct cmsghdr' on architectures where the alignment of the former is 8
- * bytes (because of a 64bit time_t), but of the latter is 4 bytes (because size_t is 32bit), such as
+ * bytes (because of a 64-bit time_t), but of the latter is 4 bytes (because size_t is 32 bits), such as
* riscv32. */
#define CMSG_TYPED_DATA(cmsg, type) \
({ \
int socket_bind_to_ifname(int fd, const char *ifname);
int socket_bind_to_ifindex(int fd, int ifindex);
-/* Define a 64bit version of timeval/timespec in any case, even on 32bit userspace. */
+/* Define a 64-bit version of timeval/timespec in any case, even on 32-bit userspace. */
struct timeval_large {
uint64_t tvl_sec, tvl_usec;
};
uint64_t tvl_sec, tvl_nsec;
};
-/* glibc duplicates timespec/timeval on certain 32bit archs, once in 32bit and once in 64bit.
+/* glibc duplicates timespec/timeval on certain 32-bit arches, once in 32-bit and once in 64-bit.
* See __convert_scm_timestamps() in glibc source code. Hence, we need additional buffer space for them
* to prevent from recvmsg_safe() returning -EXFULL. */
#define CMSG_SPACE_TIMEVAL \
if (timerfd_settime(fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) >= 0)
return TAKE_FD(fd);
- /* So apparently there are systems where time_t is 64bit, but the kernel actually doesn't support
- * 64bit time_t. In that case configuring a timer to TIME_T_MAX will fail with EOPNOTSUPP or a
+ /* So apparently there are systems where time_t is 64-bit, but the kernel actually doesn't support
+ * 64-bit time_t. In that case configuring a timer to TIME_T_MAX will fail with EOPNOTSUPP or a
* similar error. If that's the case let's try with INT32_MAX instead, maybe that works. It's a bit
* of a black magic thing though, but what can we do?
*
- * We don't want this code on x86-64, hence let's conditionalize this for systems with 64bit time_t
- * but where "long" is shorter than 64bit, i.e. 32bit archs.
+ * We don't want this code on x86-64, hence let's conditionalize this for systems with 64-bit time_t
+ * but where "long" is shorter than 64-bit, i.e. 32-bit archs.
*
* See: https://github.com/systemd/systemd/issues/14362 */
/* The last second we can format is 31. Dec 9999, 1s before midnight, because otherwise we'd enter 5 digit
* year territory. However, since we want to stay away from this in all timezones we take one day off. */
#define USEC_TIMESTAMP_FORMATTABLE_MAX_64BIT ((usec_t) 253402214399000000) /* Thu 9999-12-30 23:59:59 UTC */
-/* With a 32bit time_t we can't go beyond 2038...
+/* With a 32-bit time_t we can't go beyond 2038...
* We parse timestamp with RFC-822/ISO 8601 (e.g. +06, or -03:00) as UTC, hence the upper bound must be off
* by USEC_PER_DAY. See parse_timestamp() for more details. */
#define USEC_TIMESTAMP_FORMATTABLE_MAX_32BIT (((usec_t) INT32_MAX) * USEC_PER_SEC - USEC_PER_DAY)
if (uid == (uid_t) UINT32_C(0xFFFFFFFF))
return false;
- /* A long time ago UIDs where 16bit, hence explicitly avoid the 16bit -1 too */
+ /* A long time ago UIDs where 16 bit, hence explicitly avoid the 16-bit -1 too */
if (uid == (uid_t) UINT32_C(0xFFFF))
return false;
if (in_charset(u, "0123456789")) /* Don't allow fully numeric strings, they might be confused
* with UIDs (note that this test is more broad than
* the parse_uid() test above, as it will cover more than
- * the 32bit range, and it will detect 65535 (which is in
+ * the 32-bit range, and it will detect 65535 (which is in
* invalid UID, even though in the unsigned 32 bit range) */
return false;
if (u[0] == '-' && in_charset(u + 1, "0123456789")) /* Don't allow negative fully numeric
* strings either. After all some people
* write 65535 as -1 (even though that's
- * not even true on 32bit uid_t
+ * not even true on 32-bit uid_t
* anyway) */
return false;
/* If REMOUNT_IDMAPPING_HOST_ROOT is set for remount_idmap() we'll include a mapping here that maps the host
* root user accessing the idmapped mount to the this user ID on the backing fs. This is the last valid UID in
- * the *signed* 32bit range. You might wonder why precisely use this specific UID for this purpose? Well, we
+ * the *signed* 32-bit range. You might wonder why precisely use this specific UID for this purpose? Well, we
* definitely cannot use the first 0…65536 UIDs for that, since in most cases that's precisely the file range
* we intend to map to some high UID range, and since UID mappings have to be bijective we thus cannot use
- * them at all. Furthermore the UID range beyond INT32_MAX (i.e. the range above the signed 32bit range) is
+ * them at all. Furthermore the UID range beyond INT32_MAX (i.e. the range above the signed 32-bit range) is
* icky, since many APIs cannot use it (example: setfsuid() returns the old UID as signed integer). Following
- * our usual logic of assigning a 16bit UID range to each container, so that the upper 16bit of a 32bit UID
- * value indicate kind of a "container ID" and the lower 16bit map directly to the intended user you can read
+ * our usual logic of assigning a 16-bit UID range to each container, so that the upper 16-bit of a 32-bit UID
+ * value indicate kind of a "container ID" and the lower 16-bit map directly to the intended user you can read
* this specific UID as the "nobody" user of the container with ID 0x7FFF, which is kinda nice. */
#define UID_MAPPED_ROOT ((uid_t) (INT32_MAX-1))
#define GID_MAPPED_ROOT ((gid_t) (INT32_MAX-1))
char *utf16_to_utf8(const char16_t *s, size_t length /* bytes! */);
char16_t *utf8_to_utf16(const char *s, size_t length);
-size_t char16_strlen(const char16_t *s); /* returns the number of 16bit words in the string (not bytes!) */
+size_t char16_strlen(const char16_t *s); /* returns the number of 16-bit words in the string (not bytes!) */
int utf8_encoded_valid_unichar(const char *str, size_t length);
int utf8_encoded_to_unichar(const char *str, char32_t *ret_unichar);
}
const char *get_efi_arch(void) {
- /* Detect EFI firmware architecture of the running system. On mixed mode systems, it could be 32bit
- * while the kernel is running in 64bit. */
+ /* Detect EFI firmware architecture of the running system. On mixed mode systems, it could be 32-bit
+ * while the kernel is running in 64-bit. */
#ifdef __x86_64__
_cleanup_free_ char *platform_size = NULL;
*
* See: https://docs.kernel.org/driver-api/early-userspace/buffer-format.html */
- if (contents_size > UINT32_MAX) /* cpio cannot deal with > 32bit file sizes */
+ if (contents_size > UINT32_MAX) /* cpio cannot deal with > 32-bit file sizes */
return EFI_LOAD_ERROR;
if (*inode_counter == UINT32_MAX) /* more than 2^32-1 inodes? yikes. cpio doesn't support that either */
/* Parses one item from the format specifier in ctx and put the info into sp. If we are done with
* this specifier returns true, otherwise this function should be called again. */
- /* This implementation assumes 32bit ints. Also note that all types smaller than int are promoted to
+ /* This implementation assumes 32-bit ints. Also note that all types smaller than int are promoted to
* int in vararg functions, which is why we fetch only ints for any such types. The compiler would
* otherwise warn about fetching smaller types. */
assert_cc(sizeof(int) == 4);
static void linux_efi_handover(EFI_HANDLE parent, uintptr_t kernel, BootParams *params) {
assert(params);
- kernel += (params->hdr.setup_sects + 1) * KERNEL_SECTOR_SIZE; /* 32bit entry address. */
+ kernel += (params->hdr.setup_sects + 1) * KERNEL_SECTOR_SIZE; /* 32-bit entry address. */
/* Old kernels needs this set, while newer ones seem to ignore this. */
params->hdr.code32_start = kernel;
#ifdef __x86_64__
- kernel += KERNEL_SECTOR_SIZE; /* 64bit entry address. */
+ kernel += KERNEL_SECTOR_SIZE; /* 64-bit entry address. */
#endif
- kernel += params->hdr.handover_offset; /* 32/64bit EFI handover address. */
+ kernel += params->hdr.handover_offset; /* 32/64-bit EFI handover address. */
- /* Note in EFI mixed mode this now points to the correct 32bit handover entry point, allowing a 64bit
- * kernel to be booted from a 32bit sd-stub. */
+ /* Note in EFI mixed mode this now points to the correct 32-bit handover entry point, allowing a 64-bit
+ * kernel to be booted from a 32-bit sd-stub. */
handover_f handover = (handover_f) kernel;
handover(parent, ST, params);
static const char *sections[] = { ".compat", NULL };
/* The kernel may provide alternative PE entry points for different PE architectures. This allows
- * booting a 64bit kernel on 32bit EFI that is otherwise running on a 64bit CPU. The locations of any
+ * booting a 64-bit kernel on 32-bit EFI that is otherwise running on a 64-bit CPU. The locations of any
* such compat entry points are located in a special PE section. */
locate_sections((const PeSectionHeader *) ((const uint8_t *) dos + section_table_offset(dos, pe)),
uint64_t ticks_end = ticks_read_arch();
if (ticks_end < ticks_start) /* Check for an overflow (which is not that unlikely, given on some
- * archs the value is 32bit) */
+ * archs the value is 32-bit) */
return 0;
cache = (ticks_end - ticks_start) * 1000UL;
EFI_STATUS open_directory(EFI_FILE *root_dir, const char16_t *path, EFI_FILE **ret);
-/* Conversion between EFI_PHYSICAL_ADDRESS and pointers is not obvious. The former is always 64bit, even on
- * 32bit archs. And gcc complains if we cast a pointer to an integer of a different size. Hence let's do the
+/* Conversion between EFI_PHYSICAL_ADDRESS and pointers is not obvious. The former is always 64-bit, even on
+ * 32-bit archs. And gcc complains if we cast a pointer to an integer of a different size. Hence let's do the
* conversion indirectly: first into uintptr_t and then extended to EFI_PHYSICAL_ADDRESS. */
static inline EFI_PHYSICAL_ADDRESS POINTER_TO_PHYSICAL_ADDRESS(const void *p) {
return (EFI_PHYSICAL_ADDRESS) (uintptr_t) p;
}
static inline void *PHYSICAL_ADDRESS_TO_POINTER(EFI_PHYSICAL_ADDRESS addr) {
- /* On 32bit systems the address might not be convertible (as pointers are 32bit but
- * EFI_PHYSICAL_ADDRESS 64bit) */
+ /* On 32-bit systems the address might not be convertible (as pointers are 32-bit but
+ * EFI_PHYSICAL_ADDRESS 64-bit) */
assert(addr <= UINTPTR_MAX);
return (void *) (uintptr_t) addr;
}
r = safe_atou8(v, &z);
if (r < 0)
- return log_error_errno(r, "Failed to parse '%s' as byte (unsigned 8bit integer): %m", v);
+ return log_error_errno(r, "Failed to parse '%s' as byte (unsigned 8-bit integer): %m", v);
r = sd_bus_message_append_basic(m, t, &z);
break;
r = safe_atoi16(v, &z);
if (r < 0)
- return log_error_errno(r, "Failed to parse '%s' as signed 16bit integer: %m", v);
+ return log_error_errno(r, "Failed to parse '%s' as signed 16-bit integer: %m", v);
r = sd_bus_message_append_basic(m, t, &z);
break;
r = safe_atou16(v, &z);
if (r < 0)
- return log_error_errno(r, "Failed to parse '%s' as unsigned 16bit integer: %m", v);
+ return log_error_errno(r, "Failed to parse '%s' as unsigned 16-bit integer: %m", v);
r = sd_bus_message_append_basic(m, t, &z);
break;
r = safe_atoi32(v, &z);
if (r < 0)
- return log_error_errno(r, "Failed to parse '%s' as signed 32bit integer: %m", v);
+ return log_error_errno(r, "Failed to parse '%s' as signed 32-bit integer: %m", v);
r = sd_bus_message_append_basic(m, t, &z);
break;
r = safe_atou32(v, &z);
if (r < 0)
- return log_error_errno(r, "Failed to parse '%s' as unsigned 32bit integer: %m", v);
+ return log_error_errno(r, "Failed to parse '%s' as unsigned 32-bit integer: %m", v);
r = sd_bus_message_append_basic(m, t, &z);
break;
r = safe_atoi64(v, &z);
if (r < 0)
- return log_error_errno(r, "Failed to parse '%s' as signed 64bit integer: %m", v);
+ return log_error_errno(r, "Failed to parse '%s' as signed 64-bit integer: %m", v);
r = sd_bus_message_append_basic(m, t, &z);
break;
r = safe_atou64(v, &z);
if (r < 0)
- return log_error_errno(r, "Failed to parse '%s' as unsigned 64bit integer: %m", v);
+ return log_error_errno(r, "Failed to parse '%s' as unsigned 64-bit integer: %m", v);
r = sd_bus_message_append_basic(m, t, &z);
break;
}
do {
- /* Compare IPv4 with one word instruction (32bit) */
+ /* Compare IPv4 with one word instruction (32-bit) */
struct bpf_insn insn[] = {
/* If skb->protocol != ETH_P_IP, skip this whole block. The offset will be set later. */
BPF_JMP_IMM(BPF_JNE, BPF_REG_7, htobe16(protocol), 0),
continue;
}
- /* glibc implies O_LARGEFILE everywhere on 64bit off_t builds, but forgets to hide it away on
+ /* glibc implies O_LARGEFILE everywhere on 64-bit off_t builds, but forgets to hide it away on
* F_GETFL, but provides no definition to check for that. Let's mask the flag away manually,
* to not confuse clients. */
flags &= ~RAW_O_LARGEFILE;
size_t *value = ASSERT_PTR(userdata);
uint32_t sz = *value >= UINT32_MAX ? UINT32_MAX : (uint32_t) *value;
- /* Returns a size_t as a D-Bus "u" type, i.e. as 32bit value, even if size_t is 64bit. We'll saturate if it doesn't fit. */
+ /* Returns a size_t as a D-Bus "u" type, i.e. as 32-bit value, even if size_t is 64-bit. We'll saturate if it doesn't fit. */
return sd_bus_message_append_basic(reply, 'u', &sz);
}
if (r < 0)
return r;
- /* Permit addressing units by invocation ID: if the passed bus path is suffixed by a 128bit ID then
+ /* Permit addressing units by invocation ID: if the passed bus path is suffixed by a 128-bit ID then
* we use it as invocation ID. */
r = sd_id128_from_string(n, &invocation_id);
if (r >= 0) {
/* A generic implementation, covering both manager_unref_uid() and manager_unref_gid(), under the
* assumption that uid_t and gid_t are actually defined the same way, with the same validity rules.
*
- * We store a hashmap where the key is the UID/GID and the value is a 32bit reference counter, whose
+ * We store a hashmap where the key is the UID/GID and the value is a 32-bit reference counter, whose
* highest bit is used as flag for marking UIDs/GIDs whose IPC objects to remove when the last
* reference to the UID/GID is dropped. The flag is set to on, once at least one reference from a
* unit where RemoveIPC= is set is added on a UID/GID. It is reset when the UID's/GID's reference
#include "uid-alloc-range.h"
#include "user-util.h"
-/* The maximum size up to which we process coredumps. We use 1G on 32bit systems, and 32G on 64bit systems */
+/* The maximum size up to which we process coredumps. We use 1G on 32-bit systems, and 32G on 64-bit systems */
#if __SIZEOF_POINTER__ == 4
#define PROCESS_SIZE_MAX ((uint64_t) (1LLU*1024LLU*1024LLU*1024LLU))
#elif __SIZEOF_POINTER__ == 8
return log_error_errno(r, "Failed to parse root hash '%s': %m", optarg);
if (l < sizeof(sd_id128_t))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
- "Root hash must be at least 128bit long: %s", optarg);
+ "Root hash must be at least 128-bit long: %s", optarg);
free_and_replace(arg_verity_settings.root_hash, p);
arg_verity_settings.root_hash_size = l;
char **list;
int n;
- /* Check if this xattr has the format 'trusted.fscrypt_slot<nr>' where '<nr>' is a 32bit unsigned integer */
+ /* Check if this xattr has the format 'trusted.fscrypt_slot<nr>' where '<nr>' is a 32-bit unsigned integer */
nr = startswith(xa, "trusted.fscrypt_slot");
if (!nr)
continue;
const char *nr;
uint32_t z;
- /* Check if this xattr has the format 'trusted.fscrypt_slot<nr>' where '<nr>' is a 32bit unsigned integer */
+ /* Check if this xattr has the format 'trusted.fscrypt_slot<nr>' where '<nr>' is a 32-bit unsigned integer */
nr = startswith(xa, "trusted.fscrypt_slot");
if (!nr)
continue;
return log_oom();
/* Leave everything else unmapped, starting from UID_NOBODY itself. Specifically, this means the
- * whole space outside of 16bit remains unmapped */
+ * whole space outside of 16-bit remains unmapped */
log_debug("Creating userns with mapping:\n%s", text);
return log_oom();
printf("%s [OPTIONS...] COMMAND\n\n"
- "%sGenerate and print 128bit identifiers.%s\n"
+ "%sGenerate and print 128-bit identifiers.%s\n"
"\nCommands:\n"
" new Generate a new ID\n"
" machine-id Print the ID of current machine\n"
return log_ndisc_errno(nd, SYNTHETIC_ERRNO(EBADMSG),
"Too small to be a router advertisement, ignoring.");
- /* Router advertisement packets are neatly aligned to 64bit boundaries, hence we can access them directly */
+ /* Router advertisement packets are neatly aligned to 64-bit boundaries, hence we can access them directly */
a = NDISC_ROUTER_RAW(rt);
if (a->nd_ra_type != ND_ROUTER_ADVERT)
"Received ND packet with wrong RA code, ignoring.");
rt->hop_limit = a->nd_ra_curhoplimit;
- rt->flags = a->nd_ra_flags_reserved; /* the first 8bit */
+ rt->flags = a->nd_ra_flags_reserved; /* the first 8 bits */
rt->lifetime = be16toh(a->nd_ra_router_lifetime);
rt->preference = (rt->flags >> 3) & 3;
if ((unsigned) capability > lc)
return 0;
- /* If the last cap is 63, then there are 64 caps defined, and we need 2 entries à 32bit hence. *
- * If the last cap is 64, then there are 65 caps defined, and we need 3 entries à 32bit hence. */
+ /* If the last cap is 63, then there are 64 caps defined, and we need 2 entries à 32-bit hence. *
+ * If the last cap is 64, then there are 65 caps defined, and we need 3 entries à 32-bit hence. */
sz = DIV_ROUND_UP(lc+1, 32LU);
return !!(c->capability[offset * sz + CAP_TO_INDEX((uint32_t) capability)] & CAP_TO_MASK_CORRECTED((uint32_t) capability));
assert(m);
- /* dbus only allows 8bit header field ids */
+ /* dbus only allows 8-bit header field ids */
if (h > 0xFF)
return -EINVAL;
- /* dbus doesn't allow strings over 32bit */
+ /* dbus doesn't allow strings over 32-bit */
l = strlen(s);
if (l > UINT32_MAX)
return -EINVAL;
assert(m);
- /* dbus only allows 8bit header field ids */
+ /* dbus only allows 8-bit header field ids */
if (h > 0xFF)
return -EINVAL;
- /* dbus doesn't allow signatures over 8bit */
+ /* dbus doesn't allow signatures over 8-bit */
l = strlen(s);
if (l > SD_BUS_MAXIMUM_SIGNATURE_LENGTH)
return -EINVAL;
assert(m);
- /* dbus only allows 8bit header field ids */
+ /* dbus only allows 8-bit header field ids */
if (h > 0xFF)
return -EINVAL;
static int message_append_reply_cookie(sd_bus_message *m, uint64_t cookie) {
assert(m);
- /* 64bit cookies are not supported */
+ /* 64-bit cookies are not supported */
if (cookie > UINT32_MAX)
return -EOPNOTSUPP;
padding = start_body - m->body_size;
added = padding + sz;
- /* Check for 32bit overflows */
+ /* Check for 32-bit overflows */
if (end_body < start_body || end_body > UINT32_MAX) {
m->poisoned = true;
return NULL;
(void) sd_bus_get_description(b, &d);
/* Generate a recognizable source address in the abstract namespace. We'll include:
- * - a random 64bit value (to avoid collisions)
+ * - a random 64-bit value (to avoid collisions)
* - our "comm" process name (suppressed if contains "/" to avoid parsing issues)
* - the description string of the bus connection. */
(void) get_process_comm(0, &comm);
static uint64_t cookie_inc(uint64_t cookie) {
- /* Stay within the 32bit range, since classic D-Bus can't deal with more */
+ /* Stay within the 32-bit range, since classic D-Bus can't deal with more */
if (cookie >= UINT32_MAX)
return COOKIE_CYCLED; /* Don't go back to zero, but use the highest bit for checking
* whether we are looping. */
l = strlen(s);
if (l == SD_ID128_STRING_MAX - 1)
- /* Plain formatted 128bit hex string */
+ /* Plain formatted 128-bit hex string */
return in_charset(s, HEXDIGITS);
if (l == SD_ID128_UUID_STRING_MAX - 1) {
assert(fd >= 0);
- /* Reads an 128bit ID from a file, which may either be in plain format (32 hex digits), or in UUID format, both
+ /* Reads an 128-bit ID from a file, which may either be in plain format (32 hex digits), or in UUID format, both
* optionally followed by a newline and nothing else. ID files should really be newline terminated, but if they
* aren't that's OK too, following the rule of "Be conservative in what you send, be liberal in what you
* accept".
/* Objects may only be located at multiple of 64 bit */
if (!VALID64(offset))
return log_debug_errno(SYNTHETIC_ERRNO(EBADMSG),
- "Attempt to move to %s object at non-64bit boundary: %" PRIu64,
+ "Attempt to move to %s object at non-64-bit boundary: %" PRIu64,
journal_object_type_to_string(type),
offset);
/* Objects may only be located at multiple of 64 bit */
if (!VALID64(offset))
return log_debug_errno(SYNTHETIC_ERRNO(EBADMSG),
- "Attempt to read %s object at non-64bit boundary: %" PRIu64,
+ "Attempt to read %s object at non-64-bit boundary: %" PRIu64,
journal_object_type_to_string(type), offset);
/* Object may not be located in the file header */
assert(f);
- /* We can't read objects larger than 4G on a 32bit machine */
+ /* We can't read objects larger than 4G on a 32-bit machine */
if ((uint64_t) (size_t) size != size)
return -E2BIG;
/* Already includes a newline? Bummer, then
* let's write the variable name, then a
- * newline, then the size (64bit LE), followed
+ * newline, then the size (64-bit LE), followed
* by the data and a final newline */
w[j++] = IOVEC_MAKE(iov[i].iov_base, c - (char*) iov[i].iov_base);
assert(de);
/* returns true if the specified directory entry looks like a directory that might contain journal
- * files we might be interested in, i.e. is either a 128bit ID or a 128bit ID suffixed by a
+ * files we might be interested in, i.e. is either a 128-bit ID or a 128-bit ID suffixed by a
* namespace. */
if (!IN_SET(de->d_type, DT_DIR, DT_LNK, DT_UNKNOWN))
if (naming_scheme_has(NAMING_NSPAWN_LONG_HASH)) {
uint64_t h;
- /* Calculate 64bit hash value */
+ /* Calculate 64-bit hash value */
h = siphash24(ifname, strlen(ifname), SHORTEN_IFNAME_HASH_KEY.bytes);
- /* Set the final four bytes (i.e. 32bit) to the lower 24bit of the hash, encoded in url-safe base64 */
+ /* Set the final four bytes (i.e. 32-bit) to the lower 24bit of the hash, encoded in url-safe base64 */
memcpy(new_ifname, ifname, IFNAMSIZ - 5);
new_ifname[IFNAMSIZ - 5] = urlsafe_base64char(h >> 18);
new_ifname[IFNAMSIZ - 4] = urlsafe_base64char(h >> 12);
/* Recursively adjusts the UID/GIDs of all files of a directory tree. This is used to automatically fix up an
* OS tree to the used user namespace UID range. Note that this automatic adjustment only works for UID ranges
- * following the concept that the upper 16bit of a UID identify the container, and the lower 16bit are the actual
+ * following the concept that the upper 16-bit of a UID identify the container, and the lower 16-bit are the actual
* UID within the container. */
if ((shift & 0xFFFF) != 0) {
}
if (range != 0x10000) {
- /* We only support containers with 16bit UID ranges for the patching logic */
+ /* We only support containers with 16-bit UID ranges for the patching logic */
r = -EOPNOTSUPP;
goto finish;
}
}
/* Try to detect if the range is already right. Of course, this a pretty drastic optimization, as we assume
- * that if the top-level dir has the right upper 16bit assigned, then everything below will have too... */
+ * that if the top-level dir has the right upper 16-bit assigned, then everything below will have too... */
if (((uint32_t) (st.st_uid ^ shift) >> 16) == 0)
return 0;
if (r < 0)
return log_error_errno(r, "Failed to parse root hash: %s", optarg);
if (l < sizeof(sd_id128_t))
- return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Root hash must be at least 128bit long: %s", optarg);
+ return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Root hash must be at least 128-bit long: %s", optarg);
free_and_replace(arg_verity_settings.root_hash, k);
arg_verity_settings.root_hash_size = l;
return 0;
overflow_sum:
- return log_error_errno(SYNTHETIC_ERRNO(EOVERFLOW), "Combined weight of partition exceeds unsigned 64bit range, refusing.");
+ return log_error_errno(SYNTHETIC_ERRNO(EOVERFLOW), "Combined weight of partition exceeds unsigned 64-bit range, refusing.");
}
static uint64_t scale_by_weight(uint64_t value, uint64_t weight, uint64_t weight_sum) {
r = sd_id128_from_string(rvalue, &partition->new_uuid);
if (r < 0) {
- log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse 128bit ID/UUID, ignoring: %s", rvalue);
+ log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse 128-bit ID/UUID, ignoring: %s", rvalue);
return 0;
}
" Enroll signed TPM2 PCR policy against PEM public key\n"
" --tpm2-public-key-pcrs=PCR1+PCR2+PCR3+…\n"
" Enroll signed TPM2 PCR policy for specified TPM2 PCRs\n"
- " --seed=UUID 128bit seed UUID to derive all UUIDs from\n"
+ " --seed=UUID 128-bit seed UUID to derive all UUIDs from\n"
" --size=BYTES Grow loopback file to specified size\n"
" --json=pretty|short|off\n"
" Generate JSON output\n"
assert_cc(sizeof(struct udphdr) == 8);
assert_cc(sizeof(DnsPacketHeader) == 12);
-/* The various DNS protocols deviate in how large a packet can grow, but the TCP transport has a 16bit size
+/* The various DNS protocols deviate in how large a packet can grow, but the TCP transport has a 16-bit size
* field, hence that appears to be the absolute maximum. */
#define DNS_PACKET_SIZE_MAX 0xFFFFu
assert_cc(sizeof(unsigned) == sizeof(uint32_t));
#define bus_property_get_unsigned ((sd_bus_property_get_t) NULL)
-/* On 64bit machines we can use the default serializer for size_t and
+/* On 64-bit machines we can use the default serializer for size_t and
* friends, otherwise we need to cast this manually */
#if __SIZEOF_SIZE_T__ == 8
#define bus_property_get_size ((sd_bus_property_get_t) NULL)
#endif
/* uid_t and friends on Linux 32 bit. This means we can just use the
- * default serializer for 32bit unsigned, for serializing it, and map
+ * default serializer for 32-bit unsigned, for serializing it, and map
* it to NULL here */
assert_cc(sizeof(uid_t) == sizeof(uint32_t));
#define bus_property_get_uid ((sd_bus_property_get_t) NULL)
r = sd_id128_from_string(rvalue, &t);
if (r < 0) {
- log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse 128bit ID/UUID, ignoring: %s", rvalue);
+ log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse 128-bit ID/UUID, ignoring: %s", rvalue);
return 0;
}
if (sd_id128_is_null(t)) {
- log_syntax(unit, LOG_WARNING, filename, line, 0, "128bit ID/UUID is all 0, ignoring: %s", rvalue);
+ log_syntax(unit, LOG_WARNING, filename, line, 0, "128-bit ID/UUID is all 0, ignoring: %s", rvalue);
return 0;
}
sd_id128_t fsuuid, vuuid;
/* If a root hash is supplied, then we use the root partition that has a UUID that match the
- * first 128bit of the root hash. And we use the verity partition that has a UUID that match
- * the final 128bit. */
+ * first 128-bit of the root hash. And we use the verity partition that has a UUID that match
+ * the final 128-bit. */
if (verity->root_hash_size < sizeof(sd_id128_t))
return -EINVAL;
((unsigned) (n[1] - '0') * 10) +
((unsigned) (n[2] - '0'));
- /* Don't allow anything that doesn't
- * fit in 8bit. Note that we do allow
- * control characters, as some servers
- * (e.g. cloudflare) are happy to
- * generate labels with them
- * inside. */
+ /* Don't allow anything that doesn't fit in 8 bits. Note that we do allow
+ * control characters, as some servers (e.g. cloudflare) are happy to
+ * generate labels with them inside. */
if (k > 255)
return -EINVAL;
int dns_label_apply_idna(const char *encoded, size_t encoded_size, char *decoded, size_t decoded_max) {
_cleanup_free_ uint32_t *input = NULL;
size_t input_size, l;
- bool contains_8bit = false;
+ bool contains_8_bit = false;
char buffer[DNS_LABEL_MAX+1];
int r;
for (const char *p = encoded; p < encoded + encoded_size; p++)
if ((uint8_t) *p > 127)
- contains_8bit = true;
+ contains_8_bit = true;
- if (!contains_8bit) {
+ if (!contains_8_bit) {
if (encoded_size > DNS_LABEL_MAX)
return -EINVAL;
* interface with this. */
typedef union JsonValue {
- /* Encodes a simple value. This structure is generally 8 bytes wide (as double is 64bit). */
+ /* Encodes a simple value. This structure is generally 8 bytes wide (as double is 64-bit). */
bool boolean;
double real;
int64_t integer;
In case you wonder why we have our own JSON implementation, here are a couple of reasons why this implementation has
benefits over various other implementations:
- - We need support for 64bit signed and unsigned integers, i.e. the full 64,5bit range of -9223372036854775808…18446744073709551615
+ - We need support for 64-bit signed and unsigned integers, i.e. the full 64,5bit range of -9223372036854775808…18446744073709551615
- All our variants are immutable after creation
- Special values such as true, false, zero, null, empty strings, empty array, empty objects require zero dynamic memory
- Progressive parsing
*
* u64 bpf_jiffies64(void)
* Description
- * Obtain the 64bit jiffies
+ * Obtain the 64-bit jiffies
* Return
* The 64 bit jiffies
*
/* How rings are laid out when accessing virtual functions or
* offloaded queues is device specific. To allow users to do flow
* steering and specify these queues the ring cookie is partitioned
- * into a 32bit queue index with an 8 bit virtual function id.
+ * into a 32-bit queue index with an 8 bit virtual function id.
* This also leaves the 3bytes for further specifiers. It is possible
* future devices may support more than 256 virtual functions if
* devices start supporting PCIe w/ARI. However at the moment I
#include <sys/types.h>
/* Wrapper around the QCMD() macro of linux/quota.h that removes some undefined behaviour. A typical quota
- * command such as QCMD(Q_GETQUOTA, USRQUOTA) cannot be resolved on platforms where "int" is 32bit, as it is
+ * command such as QCMD(Q_GETQUOTA, USRQUOTA) cannot be resolved on platforms where "int" is 32-bit, as it is
* larger than INT_MAX. Yikes, because that are basically all platforms Linux supports. Let's add a wrapper
- * that explicitly takes its arguments as unsigned 32bit, and then converts the shift result explicitly to
+ * that explicitly takes its arguments as unsigned 32-bit, and then converts the shift result explicitly to
* int, acknowledging the undefined behaviour of the kernel headers. This doesn't remove the undefined
* behaviour, but it stops ubsan from complaining about it. */
static inline int QCMD_FIXED(uint32_t cmd, uint32_t type) {
* to write our own implementation relatively easily. However, the main reasons are these:
*
* • We want to use our own JSON subsystem, with all the benefits that brings (i.e. accurate unsigned+signed
- * 64bit integers, full fuzzing, logging during parsing and so on). If we'd want to use that with
+ * 64-bit integers, full fuzzing, logging during parsing and so on). If we'd want to use that with
* libvarlink we'd have to serialize and deserialize all the time from its own representation which is
* inefficient and nasty.
*
} \
struct _sd_useless_struct_to_allow_trailing_semicolon_
-/* The following macro should be used in all public enums, to force 64bit wideness on them, so that we can
+/* The following macro should be used in all public enums, to force 64-bit wideness on them, so that we can
* freely extend them later on, without breaking compatibility. */
#define _SD_ENUM_FORCE_S64(id) \
_SD_##id##_INT64_MIN = INT64_MIN, \
continue;
}
- if (u >= sizeof(flags)*8) { /* partition flags on GPT are 64bit. Let's ignore any further
+ if (u >= sizeof(flags)*8) { /* partition flags on GPT are 64-bit. Let's ignore any further
bits should libfdisk report them */
log_debug("Partition flag above bit 63 (%s), ignoring.", word);
continue;
assert_se(prctl(PR_CAP_AMBIENT, PR_CAP_AMBIENT_IS_SET, CAP_CHOWN, 0, 0) == 0);
}
-static void test_ensure_cap_64bit(void) {
+static void test_ensure_cap_64_bit(void) {
_cleanup_free_ char *content = NULL;
unsigned long p = 0;
int r;
assert_se(safe_atolu(content, &p) >= 0);
- /* If caps don't fit into 64bit anymore, we have a problem, fail the test. */
+ /* If caps don't fit into 64-bit anymore, we have a problem, fail the test. */
assert_se(p <= 63);
/* Also check for the header definition */
test_setup_logging(LOG_DEBUG);
- test_ensure_cap_64bit();
+ test_ensure_cap_64_bit();
test_last_cap_file();
test_last_cap_probe();
}
TEST(device_major_minor_valid) {
- /* on glibc dev_t is 64bit, even though in the kernel it is only 32bit */
+ /* on glibc dev_t is 64-bit, even though in the kernel it is only 32-bit */
assert_cc(sizeof(dev_t) == sizeof(uint64_t));
assert_se(DEVICE_MAJOR_VALID(0U));
}
static uint32_t graceful_add_offset_1900_1970(time_t t) {
- /* Adds OFFSET_1900_1970 to t and returns it as 32bit value. This is handles overflows
+ /* Adds OFFSET_1900_1970 to t and returns it as 32-bit value. This is handles overflows
* gracefully in a deterministic and well-defined way by cutting off the top bits. */
uint64_t a = (uint64_t) t + OFFSET_1900_1970;
return (uint32_t) (a & UINT64_C(0xFFFFFFFF));
projects / thirdparty / systemd.git / commitdiff
