/* * DECnet An implementation of the DECnet protocol suite for the LINUX * operating system. DECnet is implemented using the BSD Socket * interface as the means of communication with the user level. * * DECnet Routing Forwarding Information Base (Rules) * * Author: Steve Whitehouse * Mostly copied from Alexey Kuznetsov's ipv4/fib_rules.c * * * Changes: * Steve Whitehouse * Updated for Thomas Graf's generic rules * */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include static struct fib_rules_ops *dn_fib_rules_ops; struct dn_fib_rule { struct fib_rule common; unsigned char dst_len; unsigned char src_len; __le16 src; __le16 srcmask; __le16 dst; __le16 dstmask; __le16 srcmap; u8 flags; }; int dn_fib_lookup(struct flowidn *flp, struct dn_fib_res *res) { struct fib_lookup_arg arg = { .result = res, }; int err; err = fib_rules_lookup(dn_fib_rules_ops, flowidn_to_flowi(flp), 0, &arg); res->r = arg.rule; return err; } static int dn_fib_rule_action(struct fib_rule *rule, struct flowi *flp, int flags, struct fib_lookup_arg *arg) { struct flowidn *fld = &flp->u.dn; int err = -EAGAIN; struct dn_fib_table *tbl; switch(rule->action) { case FR_ACT_TO_TBL: break; case FR_ACT_UNREACHABLE: err = -ENETUNREACH; goto errout; case FR_ACT_PROHIBIT: err = -EACCES; goto errout; case FR_ACT_BLACKHOLE: default: err = -EINVAL; goto errout; } tbl = dn_fib_get_table(rule->table, 0); if (tbl == NULL) goto errout; err = tbl->lookup(tbl, fld, (struct dn_fib_res *)arg->result); if (err > 0) err = -EAGAIN; errout: return err; } static const struct nla_policy dn_fib_rule_policy[FRA_MAX+1] = { FRA_GENERIC_POLICY, }; static int dn_fib_rule_match(struct fib_rule *rule, struct flowi *fl, int flags) { struct dn_fib_rule *r = (struct dn_fib_rule *)rule; struct flowidn *fld = &fl->u.dn; __le16 daddr = fld->daddr; __le16 saddr = fld->saddr; if (((saddr ^ r->src) & r->srcmask) || ((daddr ^ r->dst) & r->dstmask)) return 0; return 1; } static int dn_fib_rule_configure(struct fib_rule *rule, struct sk_buff *skb, struct fib_rule_hdr *frh, struct nlattr **tb) { int err = -EINVAL; struct dn_fib_rule *r = (struct dn_fib_rule *)rule; if (frh->tos) goto errout; if (rule->table == RT_TABLE_UNSPEC) { if (rule->action == FR_ACT_TO_TBL) { struct dn_fib_table *table; table = dn_fib_empty_table(); if (table == NULL) { err = -ENOBUFS; goto errout; } rule->table = table->n; } } if (frh->src_len) r->src = nla_get_le16(tb[FRA_SRC]); if (frh->dst_len) r->dst = nla_get_le16(tb[FRA_DST]); r->src_len = frh->src_len; r->srcmask = dnet_make_mask(r->src_len); r->dst_len = frh->dst_len; r->dstmask = dnet_make_mask(r->dst_len); err = 0; errout: return err; } static int dn_fib_rule_compare(struct fib_rule *rule, struct fib_rule_hdr *frh, struct nlattr **tb) { struct dn_fib_rule *r = (struct dn_fib_rule *)rule; if (frh->src_len && (r->src_len != frh->src_len)) return 0; if (frh->dst_len && (r->dst_len != frh->dst_len)) return 0; if (frh->src_len && (r->src != nla_get_le16(tb[FRA_SRC]))) return 0; if (frh->dst_len && (r->dst != nla_get_le16(tb[FRA_DST]))) return 0; return 1; } unsigned int dnet_addr_type(__le16 addr) { struct flowidn fld = { .daddr = addr }; struct dn_fib_res res; unsigned int ret = RTN_UNICAST; struct dn_fib_table *tb = dn_fib_get_table(RT_TABLE_LOCAL, 0); res.r = NULL; if (tb) { if (!tb->lookup(tb, &fld, &res)) { ret = res.type; dn_fib_res_put(&res); } } return ret; } static int dn_fib_rule_fill(struct fib_rule *rule, struct sk_buff *skb, struct fib_rule_hdr *frh) { struct dn_fib_rule *r = (struct dn_fib_rule *)rule; frh->dst_len = r->dst_len; frh->src_len = r->src_len; frh->tos = 0; if ((r->dst_len && nla_put_le16(skb, FRA_DST, r->dst)) || (r->src_len && nla_put_le16(skb, FRA_SRC, r->src))) goto nla_put_failure; return 0; nla_put_failure: return -ENOBUFS; } static void dn_fib_rule_flush_cache(struct fib_rules_ops *ops) { dn_rt_cache_flush(-1); } static const struct fib_rules_ops __net_initconst dn_fib_rules_ops_template = { .family = AF_DECnet, .rule_size = sizeof(struct dn_fib_rule), .addr_size = sizeof(u16), .action = dn_fib_rule_action, .match = dn_fib_rule_match, .configure = dn_fib_rule_configure, .compare = dn_fib_rule_compare, .fill = dn_fib_rule_fill, .flush_cache = dn_fib_rule_flush_cache, .nlgroup = RTNLGRP_DECnet_RULE, .policy = dn_fib_rule_policy, .owner = THIS_MODULE, .fro_net = &init_net, }; void __init dn_fib_rules_init(void) { dn_fib_rules_ops = fib_rules_register(&dn_fib_rules_ops_template, &init_net); BUG_ON(IS_ERR(dn_fib_rules_ops)); BUG_ON(fib_default_rule_add(dn_fib_rules_ops, 0x7fff, RT_TABLE_MAIN, 0)); } void __exit dn_fib_rules_cleanup(void) { rtnl_lock(); fib_rules_unregister(dn_fib_rules_ops); rtnl_unlock(); rcu_barrier(); } /include/acpi/platform/aclinux.h parent7a308bb3016f57e5be11a677d15b821536419d36 (diff)
x86/microcode/intel: Drop stashed AP patch pointer optimization
This was meant to save us the scanning of the microcode containter in the initrd since the first AP had already done that but it can also hurt us: Imagine a single hyperthreaded CPU (Intel(R) Atom(TM) CPU N270, for example) which updates the microcode on the BSP but since the microcode engine is shared between the two threads, the update on CPU1 doesn't happen because it has already happened on CPU0 and we don't find a newer microcode revision on CPU1. Which doesn't set the intel_ucode_patch pointer and at initrd jettisoning time we don't save the microcode patch for later application. Now, when we suspend to RAM, the loaded microcode gets cleared so we need to reload but there's no patch saved in the cache. Removing the optimization fixes this issue and all is fine and dandy. Fixes: 06b8534cb728 ("x86/microcode: Rework microcode loading") Signed-off-by: Borislav Petkov <bp@suse.de> Reviewed-by: Thomas Gleixner <tglx@linutronix.de> Link: http://lkml.kernel.org/r/20170120202955.4091-2-bp@alien8.de Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
Diffstat (limited to 'include/acpi/platform/aclinux.h')