Linode Xen 下 grsecurity >= 4.3 崩溃问题

自从 Linux 4.3 开始,在 Linode 上使用 PaX/grsecurity 时,内核会在被 pv-grub 执行后不久立即崩溃。由于崩溃是在启动后极早期立刻发生的,没有任何可以用来调试的日志,同时公司也不是盖子开的,也没有办法得到母机上有意义的调试信息。这导致了盖子的 VPS 内核从去年 12 月开始被锁定在 4.2.7。由于不知什么时候产生了 Linode 东京机房会在 2016 年 6 月从 Xen 迁移到 KVM 的错觉,也没有花精力去尝试调试这个问题。

然而今年 Linode 周年庆时硬件全部翻倍,惟独东京机房除外。而根据官方最新的说法,新机房乐观估计要第四季度上线。解决内核问题就不得不提上了盖子的日程,首先是手工修复了不少 CVE 高危漏洞,随后又祭出 diff 折腾半天,内核始终会在启动后立刻死亡。而由于 grsecurity 并不提供 git 源,所以 git bisect 也是不可能的,唯一可用的工具只有 Linux 4.2.7 / 补丁文件,与 Linux 4.3.3 / 补丁文件。

在阅读代码差异时,一个很大的挑战是如何区分上游内核的修改与下游 PaX/grsecurity 补丁的修改。直接比较补丁文件会导致代码上下文丢失,让代码的意图不可理解。最后盖子打算编写一个名为 metadiff 的工具,自动比较并去除在上游中出现的代码段,以便仅仅对 PaX/grsecurity 的代码进行比较,就连名字都想好了就叫 metadiff ,但一直没有动手。

直到上个月和 Shawn 聊天时,提到了自己装个 Xen 也不是不可行;于是周六终于动手在 VirutalBox 虚拟机里撞了个 Debian + Xen,又在 Xen 里启动了一个虚拟机,果然很快就得到了内核崩溃的 traceback。

rip: ffffffff8100b2b0 pmu_msr_read+0x10
flags: 00000282 i s nz
rsp: ffffffff81aeff30
rax: 8000000000000000  rcx: 0000000000000001  rdx: ffffffff81aeffcc
rbx: 00000000c0000080  rsi: ffffffff81aeffa0  rdi: 00000000c0000080
rbp: ffffffff81aeffa0  r8: 0000000000000001  r9: 00000000ffffffff
r10: ffffffff81cf9000  r11: 0000000000000000  r12: ffffffff81aeffcc
r13: ffffffff81aeffc4  r14: ffffffff81aeffc0  r15: 6f73b764afec1c9d
 cs: e033    ss: e02b    ds: 0000    es: 0000
 fs: 0000 @ 0000000000000000
 gs: 0000 @ 0000000000000000/0000000000000000
Code (instr addr ffffffff8100b2b0)
00 00 00 00 00 41 54 49 89 d4 55 48 89 f5 53 89 fb 48 83 ec 10 <65> 48 8b 04 25 28 00 00 00 48 89 

Stack:
 0000000000000001 0000000000000000 0000000000000000 ffffffff8100b2b0
 000000010000e030 0000000000010082 ffffffff81aeff70 000000000000e02b
 0000000000000000 0000000000000000 00000000c0000080 ffffffff81aeffcc
 ffffffff81aeffc8 ffffffff810041c8 ffffffff81aeffc8 ffffffff81aeffcc

Call Trace:
 [<ffffffff8100b2b0>] pmu_msr_read+0x10 <--
 [<ffffffff8100b2b0>] pmu_msr_read+0x10
 [<ffffffff810041c8>] xen_read_msr_safe+0x18
 [<ffffffff81be93eb>] xen_start_kernel+0x1b9

哦?可见内核在 xen_start_kernel 不久就崩溃了,这是 /* First C function to be called on Xen boot */,在如此早期就崩溃,什么错误日志到看不到也就不奇怪了。来看看 xen_read_msr 和 pmu_msr_read 在 4.2 和 4.3 之间有什么改变:

--- ../../4.2.7/linux-4.2.7/arch/x86/xen/enlighten.c  2016-09-11 00:44:12.010022936 +0800
+++ arch/x86/xen/enlighten.c  2015-12-15 13:41:43.000000000 +0800

@@ -1030,6 +1034,9 @@ static u64 xen_read_msr_safe(unsigned in
 {
    u64 val;

+    if (pmu_msr_read(msr, &val, err))
+        return val;
+
    val = native_read_msr_safe(msr, err);
    switch (msr) {
    case MSR_IA32_APICBASE:
@@ -1074,9 +1081,11 @@ static int xen_write_msr_safe(unsigned i
        /* Fast syscall setup is all done in hypercalls, so
          these are all ignored. Stub them out here to stop
          Xen console noise. */
+        break;

    default:
-        ret = native_write_msr_safe(msr, low, high);
+        if (!pmu_msr_write(msr, low, high, &ret))
+            ret = native_write_msr_safe(msr, low, high);
    }

    return ret;

可见 pmu_msr_read 完全是个新东西,使用 git blame 继续追查。

xen/PMU: Initialization code for Xen PMU 65d0cf0be79feebeb19e7626fd3ed41ae73f642d
xen/PMU: Describe vendor-specific PMU registers e27b72df01109c689062caeba1defa013b759e0e
xen/PMU: Intercept PMU-related MSR and APIC accesses 6b08cd6328c58a2ae190c5ee03a2ffcab5ef828e
xen/PMU: PMU emulation code bf6dfb154d935725c9a2005033ca33017b9df439

发现 PMU 是 Xen 在 4.3 进入主线内核的新特性,于是解决方法就很简单了,把 bf6dfb 和 6b08cd 都撤销就好,接下来的事情就让 PaX Team 和 spender 去追查吧。最后的补丁是:

diff -uprN linux-4.7.3-hardened/arch/x86/xen/apic.c linux-4.7.3-hardened.good/arch/x86/xen/apic.c
  --- linux-4.7.3-hardened/arch/x86/xen/apic.c  2016-07-24 19:23:50.000000000 +0000
  +++ linux-4.7.3-hardened.good/arch/x86/xen/apic.c  2016-09-10 20:05:21.450647009 +0000
  @@ -7,7 +7,6 @@
   #include <xen/xen.h>
   #include <xen/interface/physdev.h>
   #include "xen-ops.h"
  -#include "pmu.h"
   #include "smp.h"

   static unsigned int xen_io_apic_read(unsigned apic, unsigned reg)
  @@ -73,10 +72,8 @@ static u32 xen_apic_read(u32 reg)

   static void xen_apic_write(u32 reg, u32 val)
   {
  -  if (reg == APIC_LVTPC) {
  -   (void)pmu_apic_update(reg);
  +  if (reg == APIC_LVTPC)
      return;
  -  }

    /* Warn to see if there's any stray references */
    WARN(1,"register: %x, value: %x\n", reg, val);
  diff -uprN linux-4.7.3-hardened/arch/x86/xen/enlighten.c linux-4.7.3-hardened.good/arch/x86/xen/enlighten.c
  --- linux-4.7.3-hardened/arch/x86/xen/enlighten.c  2016-09-10 19:59:29.237313676 +0000
  +++ linux-4.7.3-hardened.good/arch/x86/xen/enlighten.c  2016-09-10 20:06:49.683980342 +0000
  @@ -1031,9 +1031,6 @@ static u64 xen_read_msr_safe(unsigned in
   {
    u64 val;

  -  if (pmu_msr_read(msr, &val, err))
  -   return val;
  -
    val = native_read_msr_safe(msr, err);
    switch (msr) {
    case MSR_IA32_APICBASE:
  @@ -1081,13 +1078,17 @@ static int xen_write_msr_safe(unsigned i
      break;

    default:
  -   if (!pmu_msr_write(msr, low, high, &ret))
  -     ret = native_write_msr_safe(msr, low, high);
  +   ret = native_write_msr_safe(msr, low, high);
    }

    return ret;
   }

  +unsigned long long xen_read_pmc(int counter)
  +{
  +  return 0;
  +}
  +
   static u64 xen_read_msr(unsigned int msr)
   {
    /*
  diff -uprN linux-4.7.3-hardened/arch/x86/xen/pmu.c linux-4.7.3-hardened.good/arch/x86/xen/pmu.c
  --- linux-4.7.3-hardened/arch/x86/xen/pmu.c  2016-07-24 19:23:50.000000000 +0000
  +++ linux-4.7.3-hardened.good/arch/x86/xen/pmu.c  2016-09-10 20:05:21.450647009 +0000
  @@ -13,20 +13,11 @@
   /* x86_pmu.handle_irq definition */
   #include "../events/perf_event.h"

  -#define XENPMU_IRQ_PROCESSING  1
  -struct xenpmu {
  -  /* Shared page between hypervisor and domain */
  -  struct xen_pmu_data *xenpmu_data;

  -  uint8_t flags;
  -};
  -static DEFINE_PER_CPU(struct xenpmu, xenpmu_shared);
  -#define get_xenpmu_data()  (this_cpu_ptr(&xenpmu_shared)->xenpmu_data)
  -#define get_xenpmu_flags()  (this_cpu_ptr(&xenpmu_shared)->flags)
  -
  -/* Macro for computing address of a PMU MSR bank */
  -#define field_offset(ctxt, field) ((void *)((uintptr_t)ctxt + \
  -          (uintptr_t)ctxt->field))
  +/* Shared page between hypervisor and domain */
  +static DEFINE_PER_CPU(struct xen_pmu_data *, xenpmu_shared);
  +#define get_xenpmu_data()  per_cpu(xenpmu_shared, smp_processor_id())
  +

   /* AMD PMU */
   #define F15H_NUM_COUNTERS  6
  @@ -60,8 +51,6 @@ static __read_mostly int amd_num_counter
   /* Alias registers (0x4c1) for full-width writes to PMCs */
   #define MSR_PMC_ALIAS_MASK     (~(MSR_IA32_PERFCTR0 ^ MSR_IA32_PMC0))

  -#define INTEL_PMC_TYPE_SHIFT    30
  -
   static __read_mostly int intel_num_arch_counters, intel_num_fixed_counters;

  @@ -178,232 +167,6 @@ static int is_intel_pmu_msr(u32 msr_inde
    }
   }

  -static bool xen_intel_pmu_emulate(unsigned int msr, u64 *val, int type,
  -       int index, bool is_read)
  -{
  -  uint64_t *reg = NULL;
  -  struct xen_pmu_intel_ctxt *ctxt;
  -  uint64_t *fix_counters;
  -  struct xen_pmu_cntr_pair *arch_cntr_pair;
  -  struct xen_pmu_data *xenpmu_data = get_xenpmu_data();
  -  uint8_t xenpmu_flags = get_xenpmu_flags();
  -
  -
  -  if (!xenpmu_data || !(xenpmu_flags & XENPMU_IRQ_PROCESSING))
  -   return false;
  -
  -  ctxt = &xenpmu_data->pmu.c.intel;
  -
  -  switch (msr) {
  -  case MSR_CORE_PERF_GLOBAL_OVF_CTRL:
  -   reg = &ctxt->global_ovf_ctrl;
  -   break;
  -  case MSR_CORE_PERF_GLOBAL_STATUS:
  -   reg = &ctxt->global_status;
  -   break;
  -  case MSR_CORE_PERF_GLOBAL_CTRL:
  -   reg = &ctxt->global_ctrl;
  -   break;
  -  case MSR_CORE_PERF_FIXED_CTR_CTRL:
  -   reg = &ctxt->fixed_ctrl;
  -   break;
  -  default:
  -   switch (type) {
  -   case MSR_TYPE_COUNTER:
  -     fix_counters = field_offset(ctxt, fixed_counters);
  -     reg = &fix_counters[index];
  -     break;
  -   case MSR_TYPE_ARCH_COUNTER:
  -     arch_cntr_pair = field_offset(ctxt, arch_counters);
  -     reg = &arch_cntr_pair[index].counter;
  -     break;
  -   case MSR_TYPE_ARCH_CTRL:
  -     arch_cntr_pair = field_offset(ctxt, arch_counters);
  -     reg = &arch_cntr_pair[index].control;
  -     break;
  -   default:
  -     return false;
  -   }
  -  }
  -
  -  if (reg) {
  -   if (is_read)
  -     *val = *reg;
  -   else {
  -     *reg = *val;
  -
  -     if (msr == MSR_CORE_PERF_GLOBAL_OVF_CTRL)
  -      ctxt->global_status &= (~(*val));
  -   }
  -   return true;
  -  }
  -
  -  return false;
  -}
  -
  -static bool xen_amd_pmu_emulate(unsigned int msr, u64 *val, bool is_read)
  -{
  -  uint64_t *reg = NULL;
  -  int i, off = 0;
  -  struct xen_pmu_amd_ctxt *ctxt;
  -  uint64_t *counter_regs, *ctrl_regs;
  -  struct xen_pmu_data *xenpmu_data = get_xenpmu_data();
  -  uint8_t xenpmu_flags = get_xenpmu_flags();
  -
  -  if (!xenpmu_data || !(xenpmu_flags & XENPMU_IRQ_PROCESSING))
  -   return false;
  -
  -  if (k7_counters_mirrored &&
  -    ((msr >= MSR_K7_EVNTSEL0) && (msr <= MSR_K7_PERFCTR3)))
  -   msr = get_fam15h_addr(msr);
  -
  -  ctxt = &xenpmu_data->pmu.c.amd;
  -  for (i = 0; i < amd_num_counters; i++) {
  -   if (msr == amd_ctrls_base + off) {
  -     ctrl_regs = field_offset(ctxt, ctrls);
  -     reg = &ctrl_regs[i];
  -     break;
  -   } else if (msr == amd_counters_base + off) {
  -     counter_regs = field_offset(ctxt, counters);
  -     reg = &counter_regs[i];
  -     break;
  -   }
  -   off += amd_msr_step;
  -  }
  -
  -  if (reg) {
  -   if (is_read)
  -     *val = *reg;
  -   else
  -     *reg = *val;
  -
  -   return true;
  -  }
  -  return false;
  -}
  -
  -bool pmu_msr_read(unsigned int msr, uint64_t *val, int *err)
  -{
  -  if (boot_cpu_data.x86_vendor == X86_VENDOR_AMD) {
  -   if (is_amd_pmu_msr(msr)) {
  -     if (!xen_amd_pmu_emulate(msr, val, 1))
  -      *val = native_read_msr_safe(msr, err);
  -     return true;
  -   }
  -  } else {
  -   int type, index;
  -
  -   if (is_intel_pmu_msr(msr, &type, &index)) {
  -     if (!xen_intel_pmu_emulate(msr, val, type, index, 1))
  -      *val = native_read_msr_safe(msr, err);
  -     return true;
  -   }
  -  }
  -
  -  return false;
  -}
  -
  -bool pmu_msr_write(unsigned int msr, uint32_t low, uint32_t high, int *err)
  -{
  -  uint64_t val = ((uint64_t)high << 32) | low;
  -
  -  if (boot_cpu_data.x86_vendor == X86_VENDOR_AMD) {
  -   if (is_amd_pmu_msr(msr)) {
  -     if (!xen_amd_pmu_emulate(msr, &val, 0))
  -      *err = native_write_msr_safe(msr, low, high);
  -     return true;
  -   }
  -  } else {
  -   int type, index;
  -
  -   if (is_intel_pmu_msr(msr, &type, &index)) {
  -     if (!xen_intel_pmu_emulate(msr, &val, type, index, 0))
  -      *err = native_write_msr_safe(msr, low, high);
  -     return true;
  -   }
  -  }
  -
  -  return false;
  -}
  -
  -static unsigned long long xen_amd_read_pmc(int counter)
  -{
  -  struct xen_pmu_amd_ctxt *ctxt;
  -  uint64_t *counter_regs;
  -  struct xen_pmu_data *xenpmu_data = get_xenpmu_data();
  -  uint8_t xenpmu_flags = get_xenpmu_flags();
  -
  -  if (!xenpmu_data || !(xenpmu_flags & XENPMU_IRQ_PROCESSING)) {
  -   uint32_t msr;
  -   int err;
  -
  -   msr = amd_counters_base + (counter * amd_msr_step);
  -   return native_read_msr_safe(msr, &err);
  -  }
  -
  -  ctxt = &xenpmu_data->pmu.c.amd;
  -  counter_regs = field_offset(ctxt, counters);
  -  return counter_regs[counter];
  -}
  -
  -static unsigned long long xen_intel_read_pmc(int counter)
  -{
  -  struct xen_pmu_intel_ctxt *ctxt;
  -  uint64_t *fixed_counters;
  -  struct xen_pmu_cntr_pair *arch_cntr_pair;
  -  struct xen_pmu_data *xenpmu_data = get_xenpmu_data();
  -  uint8_t xenpmu_flags = get_xenpmu_flags();
  -
  -  if (!xenpmu_data || !(xenpmu_flags & XENPMU_IRQ_PROCESSING)) {
  -   uint32_t msr;
  -   int err;
  -
  -   if (counter & (1 << INTEL_PMC_TYPE_SHIFT))
  -     msr = MSR_CORE_PERF_FIXED_CTR0 + (counter & 0xffff);
  -   else
  -     msr = MSR_IA32_PERFCTR0 + counter;
  -
  -   return native_read_msr_safe(msr, &err);
  -  }
  -
  -  ctxt = &xenpmu_data->pmu.c.intel;
  -  if (counter & (1 << INTEL_PMC_TYPE_SHIFT)) {
  -   fixed_counters = field_offset(ctxt, fixed_counters);
  -   return fixed_counters[counter & 0xffff];
  -  }
  -
  -  arch_cntr_pair = field_offset(ctxt, arch_counters);
  -  return arch_cntr_pair[counter].counter;
  -}
  -
  -unsigned long long xen_read_pmc(int counter)
  -{
  -  if (boot_cpu_data.x86_vendor == X86_VENDOR_AMD)
  -   return xen_amd_read_pmc(counter);
  -  else
  -   return xen_intel_read_pmc(counter);
  -}
  -
  -int pmu_apic_update(uint32_t val)
  -{
  -  int ret;
  -  struct xen_pmu_data *xenpmu_data = get_xenpmu_data();
  -
  -  if (!xenpmu_data) {
  -   pr_warn_once("%s: pmudata not initialized\n", __func__);
  -   return -EINVAL;
  -  }
  -
  -  xenpmu_data->pmu.l.lapic_lvtpc = val;
  -
  -  if (get_xenpmu_flags() & XENPMU_IRQ_PROCESSING)
  -   return 0;
  -
  -  ret = HYPERVISOR_xenpmu_op(XENPMU_lvtpc_set, NULL);
  -
  -  return ret;
  -}
  -
   /* perf callbacks */
   static int xen_is_in_guest(void)
   {
  @@ -476,37 +239,26 @@ static void xen_convert_regs(const struc

   irqreturn_t xen_pmu_irq_handler(int irq, void *dev_id)
   {
  -  int err, ret = IRQ_NONE;
  +  int ret = IRQ_NONE;
    struct pt_regs regs;
    const struct xen_pmu_data *xenpmu_data = get_xenpmu_data();
  -  uint8_t xenpmu_flags = get_xenpmu_flags();

    if (!xenpmu_data) {
      pr_warn_once("%s: pmudata not initialized\n", __func__);
      return ret;
    }

  -  this_cpu_ptr(&xenpmu_shared)->flags =
  -   xenpmu_flags | XENPMU_IRQ_PROCESSING;
    xen_convert_regs(&xenpmu_data->pmu.r.regs, ®s,
        xenpmu_data->pmu.pmu_flags);
    if (x86_pmu.handle_irq(®s))
      ret = IRQ_HANDLED;

  -  /* Write out cached context to HW */
  -  err = HYPERVISOR_xenpmu_op(XENPMU_flush, NULL);
  -  this_cpu_ptr(&xenpmu_shared)->flags = xenpmu_flags;
  -  if (err) {
  -   pr_warn_once("%s: failed hypercall, err: %d\n", __func__, err);
  -   return IRQ_NONE;
  -  }
  -
    return ret;
   }

   bool is_xen_pmu(int cpu)
   {
  -  return (get_xenpmu_data() != NULL);
  +  return (per_cpu(xenpmu_shared, cpu) != NULL);
   }

   void xen_pmu_init(int cpu)
  @@ -536,8 +288,7 @@ void xen_pmu_init(int cpu)
    if (err)
      goto fail;

  -  per_cpu(xenpmu_shared, cpu).xenpmu_data = xenpmu_data;
  -  per_cpu(xenpmu_shared, cpu).flags = 0;
  +  per_cpu(xenpmu_shared, cpu) = xenpmu_data;

    if (cpu == 0) {
      perf_register_guest_info_callbacks(&xen_guest_cbs);
  @@ -565,6 +316,6 @@ void xen_pmu_finish(int cpu)

    (void)HYPERVISOR_xenpmu_op(XENPMU_finish, &xp);

  -  free_pages((unsigned long)per_cpu(xenpmu_shared, cpu).xenpmu_data, 0);
  -  per_cpu(xenpmu_shared, cpu).xenpmu_data = NULL;
  +  free_pages((unsigned long)per_cpu(xenpmu_shared, cpu), 0);
  +  per_cpu(xenpmu_shared, cpu) = NULL;
   }
  diff -uprN linux-4.7.3-hardened/arch/x86/xen/pmu.h linux-4.7.3-hardened.good/arch/x86/xen/pmu.h
  --- linux-4.7.3-hardened/arch/x86/xen/pmu.h  2016-07-24 19:23:50.000000000 +0000
  +++ linux-4.7.3-hardened.good/arch/x86/xen/pmu.h  2016-09-10 20:05:21.453980342 +0000
  @@ -7,9 +7,5 @@ irqreturn_t xen_pmu_irq_handler(int irq,
   void xen_pmu_init(int cpu);
   void xen_pmu_finish(int cpu);
   bool is_xen_pmu(int cpu);
  -bool pmu_msr_read(unsigned int msr, uint64_t *val, int *err);
  -bool pmu_msr_write(unsigned int msr, uint32_t low, uint32_t high, int *err);
  -int pmu_apic_update(uint32_t reg);
  -unsigned long long xen_read_pmc(int counter);

   #endif /* __XEN_PMU_H */

打好补丁再编译内核,被智子锁定版本的内核果然升级成功了。

$ uname -r
4.7.3-hardened

更新:官方已在 grsecurity-3.1-4.7.4-201609152234.patch 中修复问题,不再需要此 workaround。

(0)

相关推荐

  • 基于Xen的VPS 配置squid服务器

    安装很简单:apt-get install squid 配置中的重点是打开用户验证. 通过htpasswd建立用户名密码文件,然后在squid的配置文件中设置. http_port 3128 auth_param basic program /usr/lib/squid/ncsa_auth /etc/squid/squid.password auth_param basic children 5 auth_param basic realm Hamo's Private Proxy auth_p

  • 基于Xen的VPS ubuntu+nginx+php安装教程

    因为对系统性能要求很低,所以选择了Link-1,2.5G硬盘.64M内存.100GB流量.1个独立ip.使用优惠码9DMM7R可以有10%的折扣,vpslink.com.当然也可以找更大折扣的优惠码,但是一般只限3个月内.在vpslink后台安装os,选择ubuntu9.04,一分钟后系统装完了,ssh登录root.工作1:配置web服务器为了调试程序,支持php的web服务器还是需要的.内存太小所以抛弃了一直以来的apache,改用nginx,并且通过fast-cgi来支持php.vpslin

  • Citrix XenServer 6.1 的安装与配置方法

    一.XenServer 6.1简介 Citrix XenServer服务器虚拟化系统通过更快的应用交付,更高的IT 资源可用性和利用率,让数据中心变得更加灵活.高效.XenServer 在提供了关键工作负载(操作系统.应用和配置)所需的先进功能的同时,不会牺牲大规模部署必需的易于操作的特点.利用独特的流技术,XenServer可通过虚拟或物理服务器快速交付各种工作负载,成为企业每台服务器的理想虚拟化平台. 而在2012年10月17日,北京--思杰公司日前宣布推出业界领先的企业级虚拟化平台XenS

  • xenserver虚拟机实时性能查看方法

    登陆服务器,执行脚本/opt/tools/real_time_status.sh:(该脚本的相关数据都是从xentop命令中提取的) #!/bin/bash # Program: # Real-time Performance # History: # 2014/09/29 caishunzhi First release DIR="/opt/tools" HOSTNAME=`/bin/hostname` SORT=${1:-4} NUM=${2:-6} function get_pe

  • linux XenServer 6.2安装图解教程

    Citrix Xenserver,思杰基于Linux的虚拟化服务器.Citrix XenServer是一种全面而易于管理的服务器虚拟化平台,基于强大的 Xen Hypervisor 程序之上.Xen技术被广泛看作是业界最快速.最安全的虚拟化软件.XenServer 是为了高效地管理 Windows(R) 和 Linux(R)虚拟服务器而设计的,可提供经济高效的服务器整合和业务连续性. 安装说明: 安装XenServer 6.2的服务器CPU必须支持虚拟化,Intel (VT-X) 或者AMD (

  • 使用xenocode代码混淆加密的操作步骤

    步骤如下: 1.选中Application标签 2.点击Add按钮,加载要混淆的Dll.Exe文件 3.如果是Dll文件则选中Preset列表框中的第二项,反之选中第一项 4.点击Apply按钮 5.选中Protect标签 6.点击Select   String按钮进行设置 8.点击Bulid Application按钮完成混淆工作 从网上了解到,凡是需要序列化成二进制的代码,是不能用混淆器的.混淆后的代码将不能正常序列化.

  • Linode Xen 下 grsecurity >= 4.3 崩溃问题

    自从 Linux 4.3 开始,在 Linode 上使用 PaX/grsecurity 时,内核会在被 pv-grub 执行后不久立即崩溃.由于崩溃是在启动后极早期立刻发生的,没有任何可以用来调试的日志,同时公司也不是盖子开的,也没有办法得到母机上有意义的调试信息.这导致了盖子的 VPS 内核从去年 12 月开始被锁定在 4.2.7.由于不知什么时候产生了 Linode 东京机房会在 2016 年 6 月从 Xen 迁移到 KVM 的错觉,也没有花精力去尝试调试这个问题. 然而今年 Linode

  • CentOS 5.X xen虚拟机的安装配置及基本使用

    CentOS 5.X下安装配置xen虚拟机及基本使用 1.前提需求 1.1.简介 Xen是以GNU的GPL授权发布的自由软件,目的在于提供高效能.可支援不同操作系统同时运行且各个操作系统之间彼此相互独立的系统环境,Xen是基于X86架构开发出来的虚拟机控制器(Virtual Machine Hypervisor).Xen虚拟化包括两种虚拟化方式,半虚拟化(Para-virtualization)和全虚拟化(Fully-virtualization).这两种虚拟化都需要cpu的支持.半虚拟化的架构

  • MySQL数据库修复方法(MyISAM/InnoDB)

    在网上找了篇MySQL的技术文章,感觉不错,把它翻译过来共享下.   原文作者:Mike Peters   我整理了7条修复MySQL数据库的方法,当简单的重启对数据库不起作用,或者有表崩溃时.   简单的MySQL重启:   /usr/local/mysql/bin/mysqladmin -uUSERNAME -pPASSWORD shutdown /usr/local/mysql/bin/mysqld_safe &    1.MyISAM表崩溃    MySQL数据库允许不同的表使用不同的存

  • oracle 数据库学习 基本结构介绍

    普及一下oracle的基础知识,总结一下,oracle 是由实例和数据库组成.结构如下: oracle数据库由实例.数据库组成: * 数据库由数据文件(包含oracle 数据.索引.表结构等数据).控制文件(包括每个表的操作信息).日志文件(数据操作sql语句).参数文件.口令文件.日志归档文件(归档模式下)(服务器崩溃.硬盘损坏情况下,通过日志恢复时用) * 实例由 内存结构(memory strutct) 和 后台进程(background processor)组成. 内存结构组成: * P

  • ON_COMMAND_RANGE多个按钮响应一个函数的解决方法

    本文描述了ON_COMMAND_RANGE多个按钮响应一个函数的解决方法. 开发人员需要注意在自定义消息响应函数的声明过程中,一定要注意参数的形式,稍微一疏忽就会导致莫须有的错误,具体以ON_COMMAND_RANGE为例说下. 1.声明消息响应函数:在要添加的工程上添加函数afx_msg void OnButtonPort(); 2.消息映射: BEGIN_MESSAGE_MAP(CXXXDlg, CDialog) //{{AFX_MSG_MAP(CXXXDlg) ON_WM_SYSCOMMA

  • Linux日志式文件系统面面观

    文件系统是用来管理和组织保存在磁盘驱动器上的数据的系统软件,其实现了数据完整性的保 证,也就是保证写入磁盘的数据和随后读出的内容的一致性.除了保存以文件方式存储的数据以外,一个文件系统同样存储和管理关于文件和文件系统自身的一些重要信息(例如:日期时间.属主.访问权限.文件大小和存储位置等等).这些信息通常被称为元数据(metadata). 由于为了避免磁盘访问瓶颈效应,一般文件系统大都以异步方式工作,因此如果磁盘操作被突然中断可能导致数据被丢失.例如如果出现这种情况:如果当你处理一个在linux

  • Python 多进程并发操作中进程池Pool的实例

    在利用Python进行系统管理的时候,特别是同时操作多个文件目录,或者远程控制多台主机,并行操作可以节约大量的时间.当被操作对象数目不大时,可以直接利用multiprocessing中的Process动态成生多个进程,10几个还好,但如果是上百个,上千个目标,手动的去限制进程数量却又太过繁琐,这时候进程池Pool发挥作用的时候就到了. Pool可以提供指定数量的进程,供用户调用,当有新的请求提交到pool中时,如果池还没有满,那么就会创建一个新的进程用来执行该请求:但如果池中的进程数已经达到规定

  • C语言中函数的声明、定义及使用的入门教程

    对函数的"定义"和"声明"不是一回事.函数的定义是指对函数功能的确立,包括指定函数名,函数值类型.形参及其类型以及函数体等,它是一个完整的.独立的函数单位.而函数的声明的作用则是把函数的名字,函数类型以及形参的类型.个数和顺序通知编译系统,以便在调用该函数时进行对照检查(例如,函数名是否正确,实参与形参的类型和个数是否一致),它不包括函数体.--谭浩强 ,<C程序设计>(第四版),清华大学出版社,2010年6月,p182 这段论述包含了许多概念性错误,这

  • MongoDB中4种日志的详细介绍

    前言 任何一种数据库都有各种各样的日志,MongoDB也不例外.MongoDB中有4种日志,分别是系统日志.Journal日志.oplog主从日志.慢查询日志等.这些日志记录着MongoDB数据库不同方面的踪迹.下面分别介绍这几种日志. 系统日志 系统日志在MongoDB数据库中很重要,它记录着MongoDB启动和停止的操作,以及服务器在运行过程中发生的任何异常信息. 配置系统日志的方法比较简单,在启动mongod时指定logpath参数即可 mongod -logpath=/data/log/

  • 这一次搞懂Spring事务是如何传播的

    前言 上一篇分析了事务注解的解析过程,本质上是将事务封装为切面加入到AOP的执行链中,因此会调用到MethodInceptor的实现类的invoke方法,而事务切面的Interceptor就是TransactionInterceptor,所以本篇直接从该类开始. 正文 事务切面的调用过程 public Object invoke(MethodInvocation invocation) throws Throwable { // Work out the target class: may be

随机推荐