Magellan Linux

  • Back to homepage
    • /[pkg-src]/trunk/kernel-magellan/patches-4.14/0111-4.14.12-all-fixes.patch

    Annotation of /trunk/kernel-magellan/patches-4.14/0111-4.14.12-all-fixes.patch

    Parent Directory Parent Directory | Revision Log Revision Log

    Revision 3072 - (hide annotations) (download)
    Wed Jan 17 13:27:05 2018 UTC (6 years, 3 months ago) by niro
    File size: 16563 byte(s) 
    -linux-4.14.12
    1 niro 3072 diff --git a/Makefile b/Makefile
    2     index 655887067dc7..20f7d4de0f1c 100644
    3     --- a/Makefile
    4     +++ b/Makefile
    5     @@ -1,7 +1,7 @@
    6     # SPDX-License-Identifier: GPL-2.0
    7     VERSION = 4
    8     PATCHLEVEL = 14
    9     -SUBLEVEL = 11
    10     +SUBLEVEL = 12
    11     EXTRAVERSION =
    12     NAME = Petit Gorille
    13    
    14     diff --git a/arch/x86/entry/entry_64_compat.S b/arch/x86/entry/entry_64_compat.S
    15     index 40f17009ec20..98d5358e4041 100644
    16     --- a/arch/x86/entry/entry_64_compat.S
    17     +++ b/arch/x86/entry/entry_64_compat.S
    18     @@ -190,8 +190,13 @@ ENTRY(entry_SYSCALL_compat)
    19     /* Interrupts are off on entry. */
    20     swapgs
    21    
    22     - /* Stash user ESP and switch to the kernel stack. */
    23     + /* Stash user ESP */
    24     movl %esp, %r8d
    25     +
    26     + /* Use %rsp as scratch reg. User ESP is stashed in r8 */
    27     + SWITCH_TO_KERNEL_CR3 scratch_reg=%rsp
    28     +
    29     + /* Switch to the kernel stack */
    30     movq PER_CPU_VAR(cpu_current_top_of_stack), %rsp
    31    
    32     /* Construct struct pt_regs on stack */
    33     @@ -219,12 +224,6 @@ GLOBAL(entry_SYSCALL_compat_after_hwframe)
    34     pushq $0 /* pt_regs->r14 = 0 */
    35     pushq $0 /* pt_regs->r15 = 0 */
    36    
    37     - /*
    38     - * We just saved %rdi so it is safe to clobber. It is not
    39     - * preserved during the C calls inside TRACE_IRQS_OFF anyway.
    40     - */
    41     - SWITCH_TO_KERNEL_CR3 scratch_reg=%rdi
    42     -
    43     /*
    44     * User mode is traced as though IRQs are on, and SYSENTER
    45     * turned them off.
    46     diff --git a/arch/x86/include/asm/unwind.h b/arch/x86/include/asm/unwind.h
    47     index c1688c2d0a12..1f86e1b0a5cd 100644
    48     --- a/arch/x86/include/asm/unwind.h
    49     +++ b/arch/x86/include/asm/unwind.h
    50     @@ -56,18 +56,27 @@ void unwind_start(struct unwind_state *state, struct task_struct *task,
    51    
    52     #if defined(CONFIG_UNWINDER_ORC) || defined(CONFIG_UNWINDER_FRAME_POINTER)
    53     /*
    54     - * WARNING: The entire pt_regs may not be safe to dereference. In some cases,
    55     - * only the iret frame registers are accessible. Use with caution!
    56     + * If 'partial' returns true, only the iret frame registers are valid.
    57     */
    58     -static inline struct pt_regs *unwind_get_entry_regs(struct unwind_state *state)
    59     +static inline struct pt_regs *unwind_get_entry_regs(struct unwind_state *state,
    60     + bool *partial)
    61     {
    62     if (unwind_done(state))
    63     return NULL;
    64    
    65     + if (partial) {
    66     +#ifdef CONFIG_UNWINDER_ORC
    67     + *partial = !state->full_regs;
    68     +#else
    69     + *partial = false;
    70     +#endif
    71     + }
    72     +
    73     return state->regs;
    74     }
    75     #else
    76     -static inline struct pt_regs *unwind_get_entry_regs(struct unwind_state *state)
    77     +static inline struct pt_regs *unwind_get_entry_regs(struct unwind_state *state,
    78     + bool *partial)
    79     {
    80     return NULL;
    81     }
    82     diff --git a/arch/x86/kernel/cpu/common.c b/arch/x86/kernel/cpu/common.c
    83     index f2a94dfb434e..b1be494ab4e8 100644
    84     --- a/arch/x86/kernel/cpu/common.c
    85     +++ b/arch/x86/kernel/cpu/common.c
    86     @@ -899,8 +899,8 @@ static void __init early_identify_cpu(struct cpuinfo_x86 *c)
    87    
    88     setup_force_cpu_cap(X86_FEATURE_ALWAYS);
    89    
    90     - /* Assume for now that ALL x86 CPUs are insecure */
    91     - setup_force_cpu_bug(X86_BUG_CPU_INSECURE);
    92     + if (c->x86_vendor != X86_VENDOR_AMD)
    93     + setup_force_cpu_bug(X86_BUG_CPU_INSECURE);
    94    
    95     fpu__init_system(c);
    96    
    97     diff --git a/arch/x86/kernel/dumpstack.c b/arch/x86/kernel/dumpstack.c
    98     index 5fa110699ed2..afbecff161d1 100644
    99     --- a/arch/x86/kernel/dumpstack.c
    100     +++ b/arch/x86/kernel/dumpstack.c
    101     @@ -76,12 +76,23 @@ void show_iret_regs(struct pt_regs *regs)
    102     regs->sp, regs->flags);
    103     }
    104    
    105     -static void show_regs_safe(struct stack_info *info, struct pt_regs *regs)
    106     +static void show_regs_if_on_stack(struct stack_info *info, struct pt_regs *regs,
    107     + bool partial)
    108     {
    109     - if (on_stack(info, regs, sizeof(*regs)))
    110     + /*
    111     + * These on_stack() checks aren't strictly necessary: the unwind code
    112     + * has already validated the 'regs' pointer. The checks are done for
    113     + * ordering reasons: if the registers are on the next stack, we don't
    114     + * want to print them out yet. Otherwise they'll be shown as part of
    115     + * the wrong stack. Later, when show_trace_log_lvl() switches to the
    116     + * next stack, this function will be called again with the same regs so
    117     + * they can be printed in the right context.
    118     + */
    119     + if (!partial && on_stack(info, regs, sizeof(*regs))) {
    120     __show_regs(regs, 0);
    121     - else if (on_stack(info, (void *)regs + IRET_FRAME_OFFSET,
    122     - IRET_FRAME_SIZE)) {
    123     +
    124     + } else if (partial && on_stack(info, (void *)regs + IRET_FRAME_OFFSET,
    125     + IRET_FRAME_SIZE)) {
    126     /*
    127     * When an interrupt or exception occurs in entry code, the
    128     * full pt_regs might not have been saved yet. In that case
    129     @@ -98,11 +109,13 @@ void show_trace_log_lvl(struct task_struct *task, struct pt_regs *regs,
    130     struct stack_info stack_info = {0};
    131     unsigned long visit_mask = 0;
    132     int graph_idx = 0;
    133     + bool partial;
    134    
    135     printk("%sCall Trace:\n", log_lvl);
    136    
    137     unwind_start(&state, task, regs, stack);
    138     stack = stack ? : get_stack_pointer(task, regs);
    139     + regs = unwind_get_entry_regs(&state, &partial);
    140    
    141     /*
    142     * Iterate through the stacks, starting with the current stack pointer.
    143     @@ -120,7 +133,7 @@ void show_trace_log_lvl(struct task_struct *task, struct pt_regs *regs,
    144     * - hardirq stack
    145     * - entry stack
    146     */
    147     - for (regs = NULL; stack; stack = PTR_ALIGN(stack_info.next_sp, sizeof(long))) {
    148     + for ( ; stack; stack = PTR_ALIGN(stack_info.next_sp, sizeof(long))) {
    149     const char *stack_name;
    150    
    151     if (get_stack_info(stack, task, &stack_info, &visit_mask)) {
    152     @@ -140,7 +153,7 @@ void show_trace_log_lvl(struct task_struct *task, struct pt_regs *regs,
    153     printk("%s <%s>\n", log_lvl, stack_name);
    154    
    155     if (regs)
    156     - show_regs_safe(&stack_info, regs);
    157     + show_regs_if_on_stack(&stack_info, regs, partial);
    158    
    159     /*
    160     * Scan the stack, printing any text addresses we find. At the
    161     @@ -164,7 +177,7 @@ void show_trace_log_lvl(struct task_struct *task, struct pt_regs *regs,
    162    
    163     /*
    164     * Don't print regs->ip again if it was already printed
    165     - * by show_regs_safe() below.
    166     + * by show_regs_if_on_stack().
    167     */
    168     if (regs && stack == &regs->ip)
    169     goto next;
    170     @@ -199,9 +212,9 @@ void show_trace_log_lvl(struct task_struct *task, struct pt_regs *regs,
    171     unwind_next_frame(&state);
    172    
    173     /* if the frame has entry regs, print them */
    174     - regs = unwind_get_entry_regs(&state);
    175     + regs = unwind_get_entry_regs(&state, &partial);
    176     if (regs)
    177     - show_regs_safe(&stack_info, regs);
    178     + show_regs_if_on_stack(&stack_info, regs, partial);
    179     }
    180    
    181     if (stack_name)
    182     diff --git a/arch/x86/kernel/process.c b/arch/x86/kernel/process.c
    183     index 517415978409..3cb2486c47e4 100644
    184     --- a/arch/x86/kernel/process.c
    185     +++ b/arch/x86/kernel/process.c
    186     @@ -47,7 +47,7 @@
    187     * section. Since TSS's are completely CPU-local, we want them
    188     * on exact cacheline boundaries, to eliminate cacheline ping-pong.
    189     */
    190     -__visible DEFINE_PER_CPU_SHARED_ALIGNED(struct tss_struct, cpu_tss_rw) = {
    191     +__visible DEFINE_PER_CPU_PAGE_ALIGNED(struct tss_struct, cpu_tss_rw) = {
    192     .x86_tss = {
    193     /*
    194     * .sp0 is only used when entering ring 0 from a lower
    195     diff --git a/arch/x86/kernel/stacktrace.c b/arch/x86/kernel/stacktrace.c
    196     index 8dabd7bf1673..60244bfaf88f 100644
    197     --- a/arch/x86/kernel/stacktrace.c
    198     +++ b/arch/x86/kernel/stacktrace.c
    199     @@ -98,7 +98,7 @@ static int __save_stack_trace_reliable(struct stack_trace *trace,
    200     for (unwind_start(&state, task, NULL, NULL); !unwind_done(&state);
    201     unwind_next_frame(&state)) {
    202    
    203     - regs = unwind_get_entry_regs(&state);
    204     + regs = unwind_get_entry_regs(&state, NULL);
    205     if (regs) {
    206     /*
    207     * Kernel mode registers on the stack indicate an
    208     diff --git a/arch/x86/mm/pti.c b/arch/x86/mm/pti.c
    209     index bce8aea65606..2da28ba97508 100644
    210     --- a/arch/x86/mm/pti.c
    211     +++ b/arch/x86/mm/pti.c
    212     @@ -367,7 +367,8 @@ static void __init pti_setup_espfix64(void)
    213     static void __init pti_clone_entry_text(void)
    214     {
    215     pti_clone_pmds((unsigned long) __entry_text_start,
    216     - (unsigned long) __irqentry_text_end, _PAGE_RW);
    217     + (unsigned long) __irqentry_text_end,
    218     + _PAGE_RW | _PAGE_GLOBAL);
    219     }
    220    
    221     /*
    222     diff --git a/drivers/rtc/rtc-m41t80.c b/drivers/rtc/rtc-m41t80.c
    223     index f4c070ea8384..c90fba3ed861 100644
    224     --- a/drivers/rtc/rtc-m41t80.c
    225     +++ b/drivers/rtc/rtc-m41t80.c
    226     @@ -154,6 +154,8 @@ struct m41t80_data {
    227     struct rtc_device *rtc;
    228     #ifdef CONFIG_COMMON_CLK
    229     struct clk_hw sqw;
    230     + unsigned long freq;
    231     + unsigned int sqwe;
    232     #endif
    233     };
    234    
    235     @@ -443,43 +445,40 @@ static SIMPLE_DEV_PM_OPS(m41t80_pm, m41t80_suspend, m41t80_resume);
    236     #ifdef CONFIG_COMMON_CLK
    237     #define sqw_to_m41t80_data(_hw) container_of(_hw, struct m41t80_data, sqw)
    238    
    239     -static unsigned long m41t80_sqw_recalc_rate(struct clk_hw *hw,
    240     - unsigned long parent_rate)
    241     +static unsigned long m41t80_decode_freq(int setting)
    242     +{
    243     + return (setting == 0) ? 0 : (setting == 1) ? M41T80_SQW_MAX_FREQ :
    244     + M41T80_SQW_MAX_FREQ >> setting;
    245     +}
    246     +
    247     +static unsigned long m41t80_get_freq(struct m41t80_data *m41t80)
    248     {
    249     - struct m41t80_data *m41t80 = sqw_to_m41t80_data(hw);
    250     struct i2c_client *client = m41t80->client;
    251     int reg_sqw = (m41t80->features & M41T80_FEATURE_SQ_ALT) ?
    252     M41T80_REG_WDAY : M41T80_REG_SQW;
    253     int ret = i2c_smbus_read_byte_data(client, reg_sqw);
    254     - unsigned long val = M41T80_SQW_MAX_FREQ;
    255    
    256     if (ret < 0)
    257     return 0;
    258     + return m41t80_decode_freq(ret >> 4);
    259     +}
    260    
    261     - ret >>= 4;
    262     - if (ret == 0)
    263     - val = 0;
    264     - else if (ret > 1)
    265     - val = val / (1 << ret);
    266     -
    267     - return val;
    268     +static unsigned long m41t80_sqw_recalc_rate(struct clk_hw *hw,
    269     + unsigned long parent_rate)
    270     +{
    271     + return sqw_to_m41t80_data(hw)->freq;
    272     }
    273    
    274     static long m41t80_sqw_round_rate(struct clk_hw *hw, unsigned long rate,
    275     unsigned long *prate)
    276     {
    277     - int i, freq = M41T80_SQW_MAX_FREQ;
    278     -
    279     - if (freq <= rate)
    280     - return freq;
    281     -
    282     - for (i = 2; i <= ilog2(M41T80_SQW_MAX_FREQ); i++) {
    283     - freq /= 1 << i;
    284     - if (freq <= rate)
    285     - return freq;
    286     - }
    287     -
    288     - return 0;
    289     + if (rate >= M41T80_SQW_MAX_FREQ)
    290     + return M41T80_SQW_MAX_FREQ;
    291     + if (rate >= M41T80_SQW_MAX_FREQ / 4)
    292     + return M41T80_SQW_MAX_FREQ / 4;
    293     + if (!rate)
    294     + return 0;
    295     + return 1 << ilog2(rate);
    296     }
    297    
    298     static int m41t80_sqw_set_rate(struct clk_hw *hw, unsigned long rate,
    299     @@ -491,17 +490,12 @@ static int m41t80_sqw_set_rate(struct clk_hw *hw, unsigned long rate,
    300     M41T80_REG_WDAY : M41T80_REG_SQW;
    301     int reg, ret, val = 0;
    302    
    303     - if (rate) {
    304     - if (!is_power_of_2(rate))
    305     - return -EINVAL;
    306     - val = ilog2(rate);
    307     - if (val == ilog2(M41T80_SQW_MAX_FREQ))
    308     - val = 1;
    309     - else if (val < (ilog2(M41T80_SQW_MAX_FREQ) - 1))
    310     - val = ilog2(M41T80_SQW_MAX_FREQ) - val;
    311     - else
    312     - return -EINVAL;
    313     - }
    314     + if (rate >= M41T80_SQW_MAX_FREQ)
    315     + val = 1;
    316     + else if (rate >= M41T80_SQW_MAX_FREQ / 4)
    317     + val = 2;
    318     + else if (rate)
    319     + val = 15 - ilog2(rate);
    320    
    321     reg = i2c_smbus_read_byte_data(client, reg_sqw);
    322     if (reg < 0)
    323     @@ -510,10 +504,9 @@ static int m41t80_sqw_set_rate(struct clk_hw *hw, unsigned long rate,
    324     reg = (reg & 0x0f) | (val << 4);
    325    
    326     ret = i2c_smbus_write_byte_data(client, reg_sqw, reg);
    327     - if (ret < 0)
    328     - return ret;
    329     -
    330     - return -EINVAL;
    331     + if (!ret)
    332     + m41t80->freq = m41t80_decode_freq(val);
    333     + return ret;
    334     }
    335    
    336     static int m41t80_sqw_control(struct clk_hw *hw, bool enable)
    337     @@ -530,7 +523,10 @@ static int m41t80_sqw_control(struct clk_hw *hw, bool enable)
    338     else
    339     ret &= ~M41T80_ALMON_SQWE;
    340    
    341     - return i2c_smbus_write_byte_data(client, M41T80_REG_ALARM_MON, ret);
    342     + ret = i2c_smbus_write_byte_data(client, M41T80_REG_ALARM_MON, ret);
    343     + if (!ret)
    344     + m41t80->sqwe = enable;
    345     + return ret;
    346     }
    347    
    348     static int m41t80_sqw_prepare(struct clk_hw *hw)
    349     @@ -545,14 +541,7 @@ static void m41t80_sqw_unprepare(struct clk_hw *hw)
    350    
    351     static int m41t80_sqw_is_prepared(struct clk_hw *hw)
    352     {
    353     - struct m41t80_data *m41t80 = sqw_to_m41t80_data(hw);
    354     - struct i2c_client *client = m41t80->client;
    355     - int ret = i2c_smbus_read_byte_data(client, M41T80_REG_ALARM_MON);
    356     -
    357     - if (ret < 0)
    358     - return ret;
    359     -
    360     - return !!(ret & M41T80_ALMON_SQWE);
    361     + return sqw_to_m41t80_data(hw)->sqwe;
    362     }
    363    
    364     static const struct clk_ops m41t80_sqw_ops = {
    365     @@ -587,6 +576,7 @@ static struct clk *m41t80_sqw_register_clk(struct m41t80_data *m41t80)
    366     init.parent_names = NULL;
    367     init.num_parents = 0;
    368     m41t80->sqw.init = &init;
    369     + m41t80->freq = m41t80_get_freq(m41t80);
    370    
    371     /* optional override of the clockname */
    372     of_property_read_string(node, "clock-output-names", &init.name);
    373     diff --git a/fs/exec.c b/fs/exec.c
    374     index 3e14ba25f678..acec119fcc31 100644
    375     --- a/fs/exec.c
    376     +++ b/fs/exec.c
    377     @@ -1350,9 +1350,14 @@ void setup_new_exec(struct linux_binprm * bprm)
    378    
    379     current->sas_ss_sp = current->sas_ss_size = 0;
    380    
    381     - /* Figure out dumpability. */
    382     + /*
    383     + * Figure out dumpability. Note that this checking only of current
    384     + * is wrong, but userspace depends on it. This should be testing
    385     + * bprm->secureexec instead.
    386     + */
    387     if (bprm->interp_flags & BINPRM_FLAGS_ENFORCE_NONDUMP ||
    388     - bprm->secureexec)
    389     + !(uid_eq(current_euid(), current_uid()) &&
    390     + gid_eq(current_egid(), current_gid())))
    391     set_dumpable(current->mm, suid_dumpable);
    392     else
    393     set_dumpable(current->mm, SUID_DUMP_USER);
    394     diff --git a/net/xfrm/xfrm_policy.c b/net/xfrm/xfrm_policy.c
    395     index 2a6093840e7e..6bc16bb61b55 100644
    396     --- a/net/xfrm/xfrm_policy.c
    397     +++ b/net/xfrm/xfrm_policy.c
    398     @@ -1362,29 +1362,36 @@ xfrm_tmpl_resolve_one(struct xfrm_policy *policy, const struct flowi *fl,
    399     struct net *net = xp_net(policy);
    400     int nx;
    401     int i, error;
    402     + xfrm_address_t *daddr = xfrm_flowi_daddr(fl, family);
    403     + xfrm_address_t *saddr = xfrm_flowi_saddr(fl, family);
    404     xfrm_address_t tmp;
    405    
    406     for (nx = 0, i = 0; i < policy->xfrm_nr; i++) {
    407     struct xfrm_state *x;
    408     - xfrm_address_t *local;
    409     - xfrm_address_t *remote;
    410     + xfrm_address_t *remote = daddr;
    411     + xfrm_address_t *local = saddr;
    412     struct xfrm_tmpl *tmpl = &policy->xfrm_vec[i];
    413    
    414     - remote = &tmpl->id.daddr;
    415     - local = &tmpl->saddr;
    416     - if (xfrm_addr_any(local, tmpl->encap_family)) {
    417     - error = xfrm_get_saddr(net, fl->flowi_oif,
    418     - &tmp, remote,
    419     - tmpl->encap_family, 0);
    420     - if (error)
    421     - goto fail;
    422     - local = &tmp;
    423     + if (tmpl->mode == XFRM_MODE_TUNNEL ||
    424     + tmpl->mode == XFRM_MODE_BEET) {
    425     + remote = &tmpl->id.daddr;
    426     + local = &tmpl->saddr;
    427     + if (xfrm_addr_any(local, tmpl->encap_family)) {
    428     + error = xfrm_get_saddr(net, fl->flowi_oif,
    429     + &tmp, remote,
    430     + tmpl->encap_family, 0);
    431     + if (error)
    432     + goto fail;
    433     + local = &tmp;
    434     + }
    435     }
    436    
    437     x = xfrm_state_find(remote, local, fl, tmpl, policy, &error, family);
    438    
    439     if (x && x->km.state == XFRM_STATE_VALID) {
    440     xfrm[nx++] = x;
    441     + daddr = remote;
    442     + saddr = local;
    443     continue;
    444     }
    445     if (x) {
    446     diff --git a/security/commoncap.c b/security/commoncap.c
    447     index fc46f5b85251..7b01431d1e19 100644
    448     --- a/security/commoncap.c
    449     +++ b/security/commoncap.c
    450     @@ -348,21 +348,18 @@ static __u32 sansflags(__u32 m)
    451     return m & ~VFS_CAP_FLAGS_EFFECTIVE;
    452     }
    453    
    454     -static bool is_v2header(size_t size, __le32 magic)
    455     +static bool is_v2header(size_t size, const struct vfs_cap_data *cap)
    456     {
    457     - __u32 m = le32_to_cpu(magic);
    458     if (size != XATTR_CAPS_SZ_2)
    459     return false;
    460     - return sansflags(m) == VFS_CAP_REVISION_2;
    461     + return sansflags(le32_to_cpu(cap->magic_etc)) == VFS_CAP_REVISION_2;
    462     }
    463    
    464     -static bool is_v3header(size_t size, __le32 magic)
    465     +static bool is_v3header(size_t size, const struct vfs_cap_data *cap)
    466     {
    467     - __u32 m = le32_to_cpu(magic);
    468     -
    469     if (size != XATTR_CAPS_SZ_3)
    470     return false;
    471     - return sansflags(m) == VFS_CAP_REVISION_3;
    472     + return sansflags(le32_to_cpu(cap->magic_etc)) == VFS_CAP_REVISION_3;
    473     }
    474    
    475     /*
    476     @@ -405,7 +402,7 @@ int cap_inode_getsecurity(struct inode *inode, const char *name, void **buffer,
    477    
    478     fs_ns = inode->i_sb->s_user_ns;
    479     cap = (struct vfs_cap_data *) tmpbuf;
    480     - if (is_v2header((size_t) ret, cap->magic_etc)) {
    481     + if (is_v2header((size_t) ret, cap)) {
    482     /* If this is sizeof(vfs_cap_data) then we're ok with the
    483     * on-disk value, so return that. */
    484     if (alloc)
    485     @@ -413,7 +410,7 @@ int cap_inode_getsecurity(struct inode *inode, const char *name, void **buffer,
    486     else
    487     kfree(tmpbuf);
    488     return ret;
    489     - } else if (!is_v3header((size_t) ret, cap->magic_etc)) {
    490     + } else if (!is_v3header((size_t) ret, cap)) {
    491     kfree(tmpbuf);
    492     return -EINVAL;
    493     }
    494     @@ -470,9 +467,9 @@ static kuid_t rootid_from_xattr(const void *value, size_t size,
    495     return make_kuid(task_ns, rootid);
    496     }
    497    
    498     -static bool validheader(size_t size, __le32 magic)
    499     +static bool validheader(size_t size, const struct vfs_cap_data *cap)
    500     {
    501     - return is_v2header(size, magic) || is_v3header(size, magic);
    502     + return is_v2header(size, cap) || is_v3header(size, cap);
    503     }
    504    
    505     /*
    506     @@ -495,7 +492,7 @@ int cap_convert_nscap(struct dentry *dentry, void **ivalue, size_t size)
    507    
    508     if (!*ivalue)
    509     return -EINVAL;
    510     - if (!validheader(size, cap->magic_etc))
    511     + if (!validheader(size, cap))
    512     return -EINVAL;
    513     if (!capable_wrt_inode_uidgid(inode, CAP_SETFCAP))
    514     return -EPERM;