Re: [PATCH v9 2/8] powerpc/ima: add support to initialize ima policy rules

From: Michael Ellerman
Date: Mon Oct 28 2019 - 19:42:40 EST

Hi Lakshmi,

Lakshmi Ramasubramanian <nramas@xxxxxxxxxxxxxxxxxxx> writes:
> On 10/25/2019 10:02 AM, Nayna Jain wrote:
> >> Is there any way to not use conditional compilation in
> >> the above array definition? Maybe define different functions to get
> >> "secure_rules" for when CONFIG_MODULE_SIG_FORCE is defined and when
> >> it is not defined.
> >
> > How will you decide which function to be called ?
> Define the array in the C file:
> const char *const secure_rules_kernel_check[] = {
> "appraise func=KEXEC_KERNEL_CHECK appraise_type=imasig|modsig",
> };
> const char *const secure_rules_kernel_module_check[] = {
> "appraise func=KEXEC_KERNEL_CHECK appraise_type=imasig|modsig",
> "appraise func=MODULE_CHECK appraise_type=imasig|modsig",
> };
> And, in the header file :

But there's no reason for any of this to be in a header, it's all
contained in one file.

Moving things into a header purely to avoid a single #ifdef in a C file
is a backward step.

> extern const char *const secure_rules_kernel_check;
> extern const char *const secure_rules_kernel_module_check;
> const char *secure_rules() { return secure_rules_kernel_check; }
> #else
> const char *secure_rules() { return secure_rules_kernel_module_check;}
> #endif // #ifdef CONFIG_MODULE_SIG_FORCE
> If you want to avoid duplication, secure_rules_kernel_check and
> secure_rules_kernel_module_check could be defined in separate C files
> and conditionally compiled (in Makefile).

Again that's just lots of added complication for no real benefit.

> I was just trying to suggest the guidelines given in
> "Section 21) Conditional Compilation" in coding-style.rst.
> It says:
> Whenever possible don't use preprocessor conditionals (#ifdef, #if) in
> .c files;...

The key phrase being "guideline" :)

That suggestion is aimed at avoiding code with lots of ifdefs sprinkled
through the body of functions. Code written in that way can be very hard
to read because you have to mentally pre-process it first, and then read
the C-level logic. See below for an example.

Moving the pre-processing out of line into helpers means when you're
reading the function you can just reason about the C control flow.

The reference to ".c files" is really talking about moving logic that is
#ifdef'ed into static inline helpers. Those typically go in headers, but
they don't have to if there's no other reason for them to be in a

So where the code is all in one C file it would be completely fine to
have an #ifdef in the C file around a static inline helper.

But in this case where the #ifdef is just in an array I think it's
entirely fine to just keep the #ifdef. Its presence there doesn't
complicate the logic in anyway.


This is a "good" (bad) example of what we're trying to avoid:

static long ppc_set_hwdebug(struct task_struct *child,
struct ppc_hw_breakpoint *bp_info)
int len = 0;
struct thread_struct *thread = &(child->thread);
struct perf_event *bp;
struct perf_event_attr attr;
struct arch_hw_breakpoint brk;

if (bp_info->version != 1)
return -ENOTSUPP;
* Check for invalid flags and combinations
if ((bp_info->trigger_type == 0) ||
(bp_info->trigger_type & ~(PPC_BREAKPOINT_TRIGGER_EXECUTE |
(bp_info->addr_mode & ~PPC_BREAKPOINT_MODE_MASK) ||
(bp_info->condition_mode &
return -EINVAL;
if (bp_info->condition_mode != PPC_BREAKPOINT_CONDITION_NONE)
return -EINVAL;

if (bp_info->trigger_type & PPC_BREAKPOINT_TRIGGER_EXECUTE) {
if ((bp_info->trigger_type != PPC_BREAKPOINT_TRIGGER_EXECUTE) ||
(bp_info->condition_mode != PPC_BREAKPOINT_CONDITION_NONE))
return -EINVAL;
return set_instruction_bp(child, bp_info);
if (bp_info->addr_mode == PPC_BREAKPOINT_MODE_EXACT)
return set_dac(child, bp_info);

return set_dac_range(child, bp_info);
return -EINVAL;
* We only support one data breakpoint
if ((bp_info->trigger_type & PPC_BREAKPOINT_TRIGGER_RW) == 0 ||
(bp_info->trigger_type & ~PPC_BREAKPOINT_TRIGGER_RW) != 0 ||
bp_info->condition_mode != PPC_BREAKPOINT_CONDITION_NONE)
return -EINVAL;

if ((unsigned long)bp_info->addr >= TASK_SIZE)
return -EIO;

brk.address = bp_info->addr & ~7UL;
brk.len = 8;
if (bp_info->trigger_type & PPC_BREAKPOINT_TRIGGER_READ)
brk.type |= HW_BRK_TYPE_READ;
if (bp_info->trigger_type & PPC_BREAKPOINT_TRIGGER_WRITE)
brk.type |= HW_BRK_TYPE_WRITE;
* Check if the request is for 'range' breakpoints. We can
* support it if range < 8 bytes.
if (bp_info->addr_mode == PPC_BREAKPOINT_MODE_RANGE_INCLUSIVE)
len = bp_info->addr2 - bp_info->addr;
else if (bp_info->addr_mode == PPC_BREAKPOINT_MODE_EXACT)
len = 1;
return -EINVAL;
bp = thread->ptrace_bps[0];
if (bp)
return -ENOSPC;

/* Create a new breakpoint request if one doesn't exist already */
attr.bp_addr = (unsigned long)bp_info->addr & ~HW_BREAKPOINT_ALIGN;
attr.bp_len = len;
arch_bp_generic_fields(brk.type, &attr.bp_type);

thread->ptrace_bps[0] = bp = register_user_hw_breakpoint(&attr,
ptrace_triggered, NULL, child);
if (IS_ERR(bp)) {
thread->ptrace_bps[0] = NULL;
return PTR_ERR(bp);

return 1;

if (bp_info->addr_mode != PPC_BREAKPOINT_MODE_EXACT)
return -EINVAL;

if (child->thread.hw_brk.address)
return -ENOSPC;

if (!ppc_breakpoint_available())
return -ENODEV;

child->thread.hw_brk = brk;

return 1;