The pkgcheck instance run for the Repo mirror&CI project has finished gaining a full support for GLEP 73 REQUIRED_USE validation and verification today. As a result, it can report 5 new issues defined by that GLEP. In this article, I’d like to shortly summarize them and explain how to interpret and solve the reports.
Technical note: the GLEP number has not been formally assigned yet. However, since there is no other GLEP request open at the moment, I have taken the liberty of using the next free number in the implementation.
GLEP73Syntax: syntax violates GLEP 73
GLEP 73 specifies a few syntax restrictions as compared to the pretty much free-form syntax allowed by the PMS. The restrictions could be shortly summarized as:
??can not not be empty,
??can not not be nested,
- USE-conditional groups can not be used inside
- All-of groups (expressed using parentheses without a prefix) are banned completely.
The full rationale for the restrictions, along with examples and proposed fixes is provided in the GLEP. For the purpose of this article, it is enough to say that in all the cases found, there was a simpler (more obvious) way of expressing the same constraint.
Violation of this syntax prevents pkgcheck from performing any of the remaining checks. But more importantly, the report indicates that the constraint is unnecessarily complex and could result in REQUIRED_USE mismatch messages that are unnecessarily confusing to the user. Taking a real example, compare:
The following REQUIRED_USE flag constraints are unsatisfied: exactly-one-of ( ( !32bit 64bit ) ( 32bit !64bit ) ( 32bit 64bit ) )
and the effect of a valid replacement:
The following REQUIRED_USE flag constraints are unsatisfied: any-of ( 64bit 32bit )
While we could debate about usefulness of the Portage output, I think it is clear that the second output is simpler to comprehend. And the best proof is that you actually need to think a bit before confirming that they’re equivalent.
GLEP73Immutability: REQUIRED_USE violates immutability rules
This one is rather simple: it means
this constraint may tell user to enable (disable) a flag that is use.masked/forced. Taking a trivial example:
a? ( b )
GLEP73Immutability report will trigger if a profile masks the b flag. This means that if the user has a enabled, the PM would normally tell him to enable b as well. However, since b is masked, it can not be enabled using normal methods (we assume that altering use.mask is not normally expected).
The alternative is to disable a then. But what’s the point of letting user enable it if we afterwards tell him to disable it anyway? It is more friendly to disable both flags together, and this is pretty much what the check is about. So in this case, the solution is to mask a as well.
How to read it? Given the generic message of:
REQUIRED_USE violates immutability rules: [C] requires [E] while the opposite value is enforced by use.force/mask (in profiles: [P])
It indicates that in profiles P (a lot of profiles usually indicates you’re looking for base or top-level arch profile), E is forced or masked, and that you probably need to force/mask C appropriately as well.
GLEP73SelfConflicting: impossible self-conflicting condition
This one is going to be extremely rare. It indicates that somehow the REQUIRED_USE nested a condition and its negation, causing it to never evaluate to true. It is best explained using the following trivial example:
a? ( !a? ( b ) )
This constraint will never be enforced since a and !a can not be true simultaneously.
Is there a point in having such a report at all? Well, such a thing is extremely unlikely to happen. However, it would break the verification algorithms and so we need to account for it explicitly. Since we account for it anyway and it is a clear mistake, why not report it?
GLEP73Conflict: request for conflicting states
This warning indicates that there are at least two constraints that can apply simultaneously and request the opposite states for the same USE flag. Again, best explained on a generic example:
a? ( c ) b? ( !c )
In this example, any USE flag set with both a and b enabled could not satisfy the constraint. However, Portage will happily led us astray:
The following REQUIRED_USE flag constraints are unsatisfied: a? ( c )
If we follow the advice and enable c, we get:
The following REQUIRED_USE flag constraints are unsatisfied: b? ( !c )
The goal of this check is to avoid such a bad advices, and to require constraints to clearly indicate a suggested way forward. For example, the above case could be modified to:
a? ( !b c ) b? ( !c )
to indicate that a takes precedence over b, and that b should be disabled to avoid the impossible constraint. The opposite can be stated similarly — however, note that you need to reorder the constraints to make sure that the PM will get it right:
b? ( !a !c ) a? ( c )
How to read it? Given the generic message of:
REQUIRED_USE can request conflicting states: [Ci] requires [Ei] while [Cj] requires [Ej]
It means that if the user enables Ci and Cj simultaneously, the PM will request conflicting Ei and Ej. Depending on the intent, the solution might involve negating one of the conditions in the other constraint, or reworking the REQUIRED_USE towards another solution.
GLEP73BackAlteration: previous condition starts applying
This warning is the most specific and the least important from all the additions at the moment. It indicates that the specific constraint may cause a preceding condition to start to apply, enforcing additional requirements. Consider the following example:
b? ( c ) a? ( b )
If the user has only a enabled, the second rule will enforce b. Then the condition for the first rule will start matching, and additionally enforce c. Is this a problem? Usually not. However, for the purpose of GLEP 73 we prefer that the REQUIRED_USE can be enforced while processing left-to-right, in a single iteration. If a previous rule starts applying, we may need to do another iteration.
The solution is usually trivial: to reorder (swap) the constraints. However, in some cases developers seem to prefer copying the enforcements into the subsequent rule, e.g.:
b? ( c ) a? ( b c )
Either way works for the purposes of GLEP 73, though the latter increases complexity.
How to read it? Given the generic message of:
REQUIRED_USE causes a preceding condition to start applying: [Cj] enforces [Ej] which may cause preceding [Ci] enforcing [Ei] to evaluate to true
This indicates that if Cj is true, Ej needs to be true as well. Once it is true, a preceding condition of Ci may also become true, adding another requirement for Ei. To fix the issue, you need to either move the latter constraint before the former, or include the enforcement of Ei in the rule for Cj, rendering the application of the first rule unnecessary.
Constructs using ||, ^^ and ?? operators
GLEP 73 specifies a leftmost-preferred behavior for the
?? operators. It is expressed in a simple transformation into implications (USE-conditional groups). Long story short:
^^groups force the leftmost unmasked flag if none of the flags are enabled already, and
^^groups disable all but the leftmost enabled flag if more than one flag is enabled.
All the verification algorithms work on the transformed form, and so their output may list conditions resulting from it. For example, the following construct:
|| ( a b c ) static? ( !a )
will report a conflict between !b !c ⇒ a and static ⇒ !a. This indicates the fact that per the forementioned rule,
|| group is transformed into
!b? ( !c? ( a ) ) which explains that if none of the flags are enabled, the first one is preferred, causing a conflict with the
In this particular case you could debate that the algorithm could choose
c instead in order to avoid the problem. However, we determined that this kind of heuristic is not a goal for GLEP 73, and instead we always obide the developer’s preference expressed in the ordering. The only exception to this rule is when the leftmost flag can not match due to a mask, in which case the first unmasked flag is used.
For completeness, I should add that
^^ blocks create implications in the form of: a ⇒ !b !c…, b ⇒ !c… and so on.
At some point I might work on making the reports include the original form to avoid ambiguity.
The most important goal for GLEP 73 is to make it possible for users to install packages out-of-the-box without having to fight through mazes of REQUIRED_USE, and for developers to use REQUIRED_USE not only sparingly but whenever possible to improve the visibility of resulting package configuration. However, there is still a lot of testing, some fixing and many bikesheds before that could happen.
Nevertheless, I think we can all agree that most of the reports produced so far (with the exception of the back-alteration case) are meaningful even without automatic enforcing of REQUIRED_USE, and fixing them would benefit our users already. I would like to ask you to look for the reports on your packages and fix them whenever possible. Feel free to ping me if you need any help with that.
Once the number of non-conforming packages goes down, I will convert the reports successively into warning levels, making the CI report new issues and the pull request scans proactively complain about them.