/* * mpx.c - Memory Protection eXtensions * * Copyright (c) 2014, Intel Corporation. * Qiaowei Ren <qiaowei.ren@intel.com> * Dave Hansen <dave.hansen@intel.com> */ #include <linux/kernel.h> #include <linux/slab.h> #include <linux/syscalls.h> #include <linux/sched/sysctl.h> #include <asm/insn.h> #include <asm/mman.h> #include <asm/mmu_context.h> #include <asm/mpx.h> #include <asm/processor.h> #include <asm/fpu/internal.h> #define CREATE_TRACE_POINTS #include <asm/trace/mpx.h> static inline unsigned long mpx_bd_size_bytes(struct mm_struct *mm) { if (is_64bit_mm(mm)) return MPX_BD_SIZE_BYTES_64; else return MPX_BD_SIZE_BYTES_32; } static inline unsigned long mpx_bt_size_bytes(struct mm_struct *mm) { if (is_64bit_mm(mm)) return MPX_BT_SIZE_BYTES_64; else return MPX_BT_SIZE_BYTES_32; } /* * This is really a simplified "vm_mmap". it only handles MPX * bounds tables (the bounds directory is user-allocated). */ static unsigned long mpx_mmap(unsigned long len) { struct mm_struct *mm = current->mm; unsigned long addr, populate; /* Only bounds table can be allocated here */ if (len != mpx_bt_size_bytes(mm)) return -EINVAL; down_write(&mm->mmap_sem); addr = do_mmap(NULL, 0, len, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, VM_MPX, 0, &populate); up_write(&mm->mmap_sem); if (populate) mm_populate(addr, populate); return addr; } enum reg_type { REG_TYPE_RM = 0, REG_TYPE_INDEX, REG_TYPE_BASE, }; static int get_reg_offset(struct insn *insn, struct pt_regs *regs, enum reg_type type) { int regno = 0; static const int regoff[] = { offsetof(struct pt_regs, ax), offsetof(struct pt_regs, cx), offsetof(struct pt_regs, dx), offsetof(struct pt_regs, bx), offsetof(struct pt_regs, sp), offsetof(struct pt_regs, bp), offsetof(struct pt_regs, si), offsetof(struct pt_regs, di), #ifdef CONFIG_X86_64 offsetof(struct pt_regs, r8), offsetof(struct pt_regs, r9), offsetof(struct pt_regs, r10), offsetof(struct pt_regs, r11), offsetof(struct pt_regs, r12), offsetof(struct pt_regs, r13), offsetof(struct pt_regs, r14), offsetof(struct pt_regs, r15), #endif }; int nr_registers = ARRAY_SIZE(regoff); /* * Don't possibly decode a 32-bit instructions as * reading a 64-bit-only register. */ if (IS_ENABLED(CONFIG_X86_64) && !insn->x86_64) nr_registers -= 8; switch (type) { case REG_TYPE_RM: regno = X86_MODRM_RM(insn->modrm.value); if (X86_REX_B(insn->rex_prefix.value)) regno += 8; break; case REG_TYPE_INDEX: regno = X86_SIB_INDEX(insn->sib.value); if (X86_REX_X(insn->rex_prefix.value)) regno += 8; break; case REG_TYPE_BASE: regno = X86_SIB_BASE(insn->sib.value); if (X86_REX_B(insn->rex_prefix.value)) regno += 8; break; default: pr_err("invalid register type"); BUG(); break; } if (regno >= nr_registers) { WARN_ONCE(1, "decoded an instruction with an invalid register"); return -EINVAL; } return regoff[regno]; } /* * return the address being referenced be instruction * for rm=3 returning the content of the rm reg * for rm!=3 calculates the address using SIB and Disp */ static void __user *mpx_get_addr_ref(struct insn *insn, struct pt_regs *regs) { unsigned long addr, base, indx; int addr_offset, base_offset, indx_offset; insn_byte_t sib; insn_get_modrm(insn); insn_get_sib(insn); sib = insn->sib.value; if (X86_MODRM_MOD(insn->modrm.value) == 3) { addr_offset = get_reg_offset(insn, regs, REG_TYPE_RM); if (addr_offset < 0) goto out_err; addr = regs_get_register(regs, addr_offset); } else { if (insn->sib.nbytes) { base_offset = get_reg_offset(insn, regs, REG_TYPE_BASE); if (base_offset < 0) goto out_err; indx_offset = get_reg_offset(insn, regs, REG_TYPE_INDEX); if (indx_offset < 0) goto out_err; base = regs_get_register(regs, base_offset); indx = regs_get_register(regs, indx_offset); addr = base + indx * (1 << X86_SIB_SCALE(sib)); } else { addr_offset = get_reg_offset(insn, regs, REG_TYPE_RM); if (addr_offset < 0) goto out_err; addr = regs_get_register(regs, addr_offset); } addr += insn->displacement.value; } return (void __user *)addr; out_err: return (void __user *)-1; } static int mpx_insn_decode(struct insn *insn, struct pt_regs *regs) { unsigned char buf[MAX_INSN_SIZE]; int x86_64 = !test_thread_flag(TIF_IA32); int not_copied; int nr_copied; not_copied = copy_from_user(buf, (void __user *)regs->ip, sizeof(buf)); nr_copied = sizeof(buf) - not_copied; /* * The decoder _should_ fail nicely if we pass it a short buffer. * But, let's not depend on that implementation detail. If we * did not get anything, just error out now. */ if (!nr_copied) return -EFAULT; insn_init(insn, buf, nr_copied, x86_64); insn_get_length(insn); /* * copy_from_user() tries to get as many bytes as we could see in * the largest possible instruction. If the instruction we are * after is shorter than that _and_ we attempt to copy from * something unreadable, we might get a short read. This is OK * as long as the read did not stop in the middle of the * instruction. Check to see if we got a partial instruction. */ if (nr_copied < insn->length) return -EFAULT; insn_get_opcode(insn); /* * We only _really_ need to decode bndcl/bndcn/bndcu * Error out on anything else. */ if (insn->opcode.bytes[0] != 0x0f) goto bad_opcode; if ((insn->opcode.bytes[1] != 0x1a) && (insn->opcode.bytes[1] != 0x1b)) goto bad_opcode; return 0; bad_opcode: return -EINVAL; } /* * If a bounds overflow occurs then a #BR is generated. This * function decodes MPX instructions to get violation address * and set this address into extended struct siginfo. * * Note that this is not a super precise way of doing this. * Userspace could have, by the time we get here, written * anything it wants in to the instructions. We can not * trust anything about it. They might not be valid * instructions or might encode invalid registers, etc... * * The caller is expected to kfree() the returned siginfo_t. */ siginfo_t *mpx_generate_siginfo(struct pt_regs *regs) { const struct mpx_bndreg_state *bndregs; const struct mpx_bndreg *bndreg; siginfo_t *info = NULL; struct insn insn; uint8_t bndregno; int err; err = mpx_insn_decode(&insn, regs); if (err) goto err_out; /* * We know at this point that we are only dealing with * MPX instructions. */ insn_get_modrm(&insn); bndregno = X86_MODRM_REG(insn.modrm.value); if (bndregno > 3) { err = -EINVAL; goto err_out; } /* get bndregs field from current task's xsave area */ bndregs = get_xsave_field_ptr(XFEATURE_MASK_BNDREGS); if (!bndregs) { err = -EINVAL; goto err_out; } /* now go select the individual register in the set of 4 */ bndreg = &bndregs->bndreg[bndregno]; info = kzalloc(sizeof(*info), GFP_KERNEL); if (!info) { err = -ENOMEM; goto err_out; } /* * The registers are always 64-bit, but the upper 32 * bits are ignored in 32-bit mode. Also, note that the * upper bounds are architecturally represented in 1's * complement form. * * The 'unsigned long' cast is because the compiler * complains when casting from integers to different-size * pointers. */ info->si_lower = (void __user *)(unsigned long)bndreg->lower_bound; info->si_upper = (void __user *)(unsigned long)~bndreg->upper_bound; info->si_addr_lsb = 0; info->si_signo = SIGSEGV; info->si_errno = 0; info->si_code = SEGV_BNDERR; info->si_addr = mpx_get_addr_ref(&insn, regs); /* * We were not able to extract an address from the instruction, * probably because there was something invalid in it. */ if (info->si_addr == (void *)-1) { err = -EINVAL; goto err_out; } trace_mpx_bounds_register_exception(info->si_addr, bndreg); return info; err_out: /* info might be NULL, but kfree() handles that */ kfree(info); return ERR_PTR(err); } static __user void *mpx_get_bounds_dir(void) { const struct mpx_bndcsr *bndcsr; if (!cpu_feature_enabled(X86_FEATURE_MPX)) return MPX_INVALID_BOUNDS_DIR; /* * The bounds directory pointer is stored in a register * only accessible if we first do an xsave. */ bndcsr = get_xsave_field_ptr(XFEATURE_MASK_BNDCSR); if (!bndcsr) return MPX_INVALID_BOUNDS_DIR; /* * Make sure the register looks valid by checking the * enable bit. */ if (!(bndcsr->bndcfgu & MPX_BNDCFG_ENABLE_FLAG)) return MPX_INVALID_BOUNDS_DIR; /* * Lastly, mask off the low bits used for configuration * flags, and return the address of the bounds table. */ return (void __user *)(unsigned long) (bndcsr->bndcfgu & MPX_BNDCFG_ADDR_MASK); } int mpx_enable_management(void) { void __user *bd_base = MPX_INVALID_BOUNDS_DIR; struct mm_struct *mm = current->mm; int ret = 0; /* * runtime in the userspace will be responsible for allocation of * the bounds directory. Then, it will save the base of the bounds * directory into XSAVE/XRSTOR Save Area and enable MPX through * XRSTOR instruction. * * The copy_xregs_to_kernel() beneath get_xsave_field_ptr() is * expected to be relatively expensive. Storing the bounds * directory here means that we do not have to do xsave in the * unmap path; we can just use mm->bd_addr instead. */ bd_base = mpx_get_bounds_dir(); down_write(&mm->mmap_sem); mm->bd_addr = bd_base; if (mm->bd_addr == MPX_INVALID_BOUNDS_DIR) ret = -ENXIO; up_write(&mm->mmap_sem); return ret; } int mpx_disable_management(void) { struct mm_struct *mm = current->mm; if (!cpu_feature_enabled(X86_FEATURE_MPX)) return -ENXIO; down_write(&mm->mmap_sem); mm->bd_addr = MPX_INVALID_BOUNDS_DIR; up_write(&mm->mmap_sem); return 0; } static int mpx_cmpxchg_bd_entry(struct mm_struct *mm, unsigned long *curval, unsigned long __user *addr, unsigned long old_val, unsigned long new_val) { int ret; /* * user_atomic_cmpxchg_inatomic() actually uses sizeof() * the pointer that we pass to it to figure out how much * data to cmpxchg. We have to be careful here not to * pass a pointer to a 64-bit data type when we only want * a 32-bit copy. */ if (is_64bit_mm(mm)) { ret = user_atomic_cmpxchg_inatomic(curval, addr, old_val, new_val); } else { u32 uninitialized_var(curval_32); u32 old_val_32 = old_val; u32 new_val_32 = new_val; u32 __user *addr_32 = (u32 __user *)addr; ret = user_atomic_cmpxchg_inatomic(&curval_32, addr_32, old_val_32, new_val_32); *curval = curval_32; } return ret; } /* * With 32-bit mode, a bounds directory is 4MB, and the size of each * bounds table is 16KB. With 64-bit mode, a bounds directory is 2GB, * and the size of each bounds table is 4MB. */ static int allocate_bt(struct mm_struct *mm, long __user *bd_entry) { unsigned long expected_old_val = 0; unsigned long actual_old_val = 0; unsigned long bt_addr; unsigned long bd_new_entry; int ret = 0; /* * Carve the virtual space out of userspace for the new * bounds table: */ bt_addr = mpx_mmap(mpx_bt_size_bytes(mm)); if (IS_ERR((void *)bt_addr)) return PTR_ERR((void *)bt_addr); /* * Set the valid flag (kinda like _PAGE_PRESENT in a pte) */ bd_new_entry = bt_addr | MPX_BD_ENTRY_VALID_FLAG; /* * Go poke the address of the new bounds table in to the * bounds directory entry out in userspace memory. Note: * we may race with another CPU instantiating the same table. * In that case the cmpxchg will see an unexpected * 'actual_old_val'. * * This can fault, but that's OK because we do not hold * mmap_sem at this point, unlike some of the other part * of the MPX code that have to pagefault_disable(). */ ret = mpx_cmpxchg_bd_entry(mm, &actual_old_val, bd_entry, expected_old_val, bd_new_entry); if (ret) goto out_unmap; /* * The user_atomic_cmpxchg_inatomic() will only return nonzero * for faults, *not* if the cmpxchg itself fails. Now we must * verify that the cmpxchg itself completed successfully. */ /* * We expected an empty 'expected_old_val', but instead found * an apparently valid entry. Assume we raced with another * thread to instantiate this table and desclare succecss. */ if (actual_old_val & MPX_BD_ENTRY_VALID_FLAG) { ret = 0; goto out_unmap; } /* * We found a non-empty bd_entry but it did not have the * VALID_FLAG set. Return an error which will result in * a SEGV since this probably means that somebody scribbled * some invalid data in to a bounds table. */ if (expected_old_val != actual_old_val) { ret = -EINVAL; goto out_unmap; } trace_mpx_new_bounds_table(bt_addr); return 0; out_unmap: vm_munmap(bt_addr, mpx_bt_size_bytes(mm)); return ret; } /* * When a BNDSTX instruction attempts to save bounds to a bounds * table, it will first attempt to look up the table in the * first-level bounds directory. If it does not find a table in * the directory, a #BR is generated and we get here in order to * allocate a new table. * * With 32-bit mode, the size of BD is 4MB, and the size of each * bound table is 16KB. With 64-bit mode, the size of BD is 2GB, * and the size of each bound table is 4MB. */ static int do_mpx_bt_fault(void) { unsigned long bd_entry, bd_base; const struct mpx_bndcsr *bndcsr; struct mm_struct *mm = current->mm; bndcsr = get_xsave_field_ptr(XFEATURE_MASK_BNDCSR); if (!bndcsr) return -EINVAL; /* * Mask off the preserve and enable bits */ bd_base = bndcsr->bndcfgu & MPX_BNDCFG_ADDR_MASK; /* * The hardware provides the address of the missing or invalid * entry via BNDSTATUS, so we don't have to go look it up. */ bd_entry = bndcsr->bndstatus & MPX_BNDSTA_ADDR_MASK; /* * Make sure the directory entry is within where we think * the directory is. */ if ((bd_entry < bd_base) || (bd_entry >= bd_base + mpx_bd_size_bytes(mm))) return -EINVAL; return allocate_bt(mm, (long __user *)bd_entry); } int mpx_handle_bd_fault(void) { /* * Userspace never asked us to manage the bounds tables, * so refuse to help. */ if (!kernel_managing_mpx_tables(current->mm)) return -EINVAL; if (do_mpx_bt_fault()) { force_sig(SIGSEGV, current); /* * The force_sig() is essentially "handling" this * exception, so we do not pass up the error * from do_mpx_bt_fault(). */ } return 0; } /* * A thin wrapper around get_user_pages(). Returns 0 if the * fault was resolved or -errno if not. */ static int mpx_resolve_fault(long __user *addr, int write) { long gup_ret; int nr_pages = 1; int force = 0; gup_ret = get_user_pages(current, current->mm, (unsigned long)addr, nr_pages, write, force, NULL, NULL); /* * get_user_pages() returns number of pages gotten. * 0 means we failed to fault in and get anything, * probably because 'addr' is bad. */ if (!gup_ret) return -EFAULT; /* Other error, return it */ if (gup_ret < 0) return gup_ret; /* must have gup'd a page and gup_ret>0, success */ return 0; } static unsigned long mpx_bd_entry_to_bt_addr(struct mm_struct *mm, unsigned long bd_entry) { unsigned long bt_addr = bd_entry; int align_to_bytes; /* * Bit 0 in a bt_entry is always the valid bit. */ bt_addr &= ~MPX_BD_ENTRY_VALID_FLAG; /* * Tables are naturally aligned at 8-byte boundaries * on 64-bit and 4-byte boundaries on 32-bit. The * documentation makes it appear that the low bits * are ignored by the hardware, so we do the same. */ if (is_64bit_mm(mm)) align_to_bytes = 8; else align_to_bytes = 4; bt_addr &= ~(align_to_bytes-1); return bt_addr; } /* * We only want to do a 4-byte get_user() on 32-bit. Otherwise, * we might run off the end of the bounds table if we are on * a 64-bit kernel and try to get 8 bytes. */ int get_user_bd_entry(struct mm_struct *mm, unsigned long *bd_entry_ret, long __user *bd_entry_ptr) { u32 bd_entry_32; int ret; if (is_64bit_mm(mm)) return get_user(*bd_entry_ret, bd_entry_ptr); /* * Note that get_user() uses the type of the *pointer* to * establish the size of the get, not the destination. */ ret = get_user(bd_entry_32, (u32 __user *)bd_entry_ptr); *bd_entry_ret = bd_entry_32; return ret; } /* * Get the base of bounds tables pointed by specific bounds * directory entry. */ static int get_bt_addr(struct mm_struct *mm, long __user *bd_entry_ptr, unsigned long *bt_addr_result) { int ret; int valid_bit; unsigned long bd_entry; unsigned long bt_addr; if (!access_ok(VERIFY_READ, (bd_entry_ptr), sizeof(*bd_entry_ptr))) return -EFAULT; while (1) { int need_write = 0; pagefault_disable(); ret = get_user_bd_entry(mm, &bd_entry, bd_entry_ptr); pagefault_enable(); if (!ret) break; if (ret == -EFAULT) ret = mpx_resolve_fault(bd_entry_ptr, need_write); /* * If we could not resolve the fault, consider it * userspace's fault and error out. */ if (ret) return ret; } valid_bit = bd_entry & MPX_BD_ENTRY_VALID_FLAG; bt_addr = mpx_bd_entry_to_bt_addr(mm, bd_entry); /* * When the kernel is managing bounds tables, a bounds directory * entry will either have a valid address (plus the valid bit) * *OR* be completely empty. If we see a !valid entry *and* some * data in the address field, we know something is wrong. This * -EINVAL return will cause a SIGSEGV. */ if (!valid_bit && bt_addr) return -EINVAL; /* * Do we have an completely zeroed bt entry? That is OK. It * just means there was no bounds table for this memory. Make * sure to distinguish this from -EINVAL, which will cause * a SEGV. */ if (!valid_bit) return -ENOENT; *bt_addr_result = bt_addr; return 0; } static inline int bt_entry_size_bytes(struct mm_struct *mm) { if (is_64bit_mm(mm)) return MPX_BT_ENTRY_BYTES_64; else return MPX_BT_ENTRY_BYTES_32; } /* * Take a virtual address and turns it in to the offset in bytes * inside of the bounds table where the bounds table entry * controlling 'addr' can be found. */ static unsigned long mpx_get_bt_entry_offset_bytes(struct mm_struct *mm, unsigned long addr) { unsigned long bt_table_nr_entries; unsigned long offset = addr; if (is_64bit_mm(mm)) { /* Bottom 3 bits are ignored on 64-bit */ offset >>= 3; bt_table_nr_entries = MPX_BT_NR_ENTRIES_64; } else { /* Bottom 2 bits are ignored on 32-bit */ offset >>= 2; bt_table_nr_entries = MPX_BT_NR_ENTRIES_32; } /* * We know the size of the table in to which we are * indexing, and we have eliminated all the low bits * which are ignored for indexing. * * Mask out all the high bits which we do not need * to index in to the table. Note that the tables * are always powers of two so this gives us a proper * mask. */ offset &= (bt_table_nr_entries-1); /* * We now have an entry offset in terms of *entries* in * the table. We need to scale it back up to bytes. */ offset *= bt_entry_size_bytes(mm); return offset; } /* * How much virtual address space does a single bounds * directory entry cover? * * Note, we need a long long because 4GB doesn't fit in * to a long on 32-bit. */ static inline unsigned long bd_entry_virt_space(struct mm_struct *mm) { unsigned long long virt_space; unsigned long long GB = (1ULL << 30); /* * This covers 32-bit emulation as well as 32-bit kernels * running on 64-bit harware. */ if (!is_64bit_mm(mm)) return (4ULL * GB) / MPX_BD_NR_ENTRIES_32; /* * 'x86_virt_bits' returns what the hardware is capable * of, and returns the full >32-bit adddress space when * running 32-bit kernels on 64-bit hardware. */ virt_space = (1ULL << boot_cpu_data.x86_virt_bits); return virt_space / MPX_BD_NR_ENTRIES_64; } /* * Free the backing physical pages of bounds table 'bt_addr'. * Assume start...end is within that bounds table. */ static noinline int zap_bt_entries_mapping(struct mm_struct *mm, unsigned long bt_addr, unsigned long start_mapping, unsigned long end_mapping) { struct vm_area_struct *vma; unsigned long addr, len; unsigned long start; unsigned long end; /* * if we 'end' on a boundary, the offset will be 0 which * is not what we want. Back it up a byte to get the * last bt entry. Then once we have the entry itself, * move 'end' back up by the table entry size. */ start = bt_addr + mpx_get_bt_entry_offset_bytes(mm, start_mapping); end = bt_addr + mpx_get_bt_entry_offset_bytes(mm, end_mapping - 1); /* * Move end back up by one entry. Among other things * this ensures that it remains page-aligned and does * not screw up zap_page_range() */ end += bt_entry_size_bytes(mm); /* * Find the first overlapping vma. If vma->vm_start > start, there * will be a hole in the bounds table. This -EINVAL return will * cause a SIGSEGV. */ vma = find_vma(mm, start); if (!vma || vma->vm_start > start) return -EINVAL; /* * A NUMA policy on a VM_MPX VMA could cause this bounds table to * be split. So we need to look across the entire 'start -> end' * range of this bounds table, find all of the VM_MPX VMAs, and * zap only those. */ addr = start; while (vma && vma->vm_start < end) { /* * We followed a bounds directory entry down * here. If we find a non-MPX VMA, that's bad, * so stop immediately and return an error. This * probably results in a SIGSEGV. */ if (!(vma->vm_flags & VM_MPX)) return -EINVAL; len = min(vma->vm_end, end) - addr; zap_page_range(vma, addr, len, NULL); trace_mpx_unmap_zap(addr, addr+len); <style>.highlight .hll { background-color: #ffffcc } .highlight .c { color: #888888 } /* Comment */ .highlight .err { color: #a61717; background-color: #e3d2d2 } /* Error */ .highlight .k { color: #008800; font-weight: bold } /* Keyword */ .highlight .ch { color: #888888 } /* Comment.Hashbang */ .highlight .cm { color: #888888 } /* Comment.Multiline */ .highlight .cp { color: #cc0000; font-weight: bold } /* Comment.Preproc */ .highlight .cpf { color: #888888 } /* Comment.PreprocFile */ .highlight .c1 { color: #888888 } /* Comment.Single */ .highlight .cs { color: #cc0000; font-weight: bold; background-color: #fff0f0 } /* Comment.Special */ .highlight .gd { color: #000000; background-color: #ffdddd } /* Generic.Deleted */ .highlight .ge { font-style: italic } /* Generic.Emph */ .highlight .gr { color: #aa0000 } /* Generic.Error */ .highlight .gh { color: #333333 } /* Generic.Heading */ .highlight .gi { color: #000000; background-color: #ddffdd } /* Generic.Inserted */ .highlight .go { color: #888888 } /* Generic.Output */ .highlight .gp { color: #555555 } /* Generic.Prompt */ .highlight .gs { font-weight: bold } /* Generic.Strong */ .highlight .gu { color: #666666 } /* Generic.Subheading */ .highlight .gt { color: #aa0000 } /* Generic.Traceback */ .highlight .kc { color: #008800; font-weight: bold } /* Keyword.Constant */ .highlight .kd { color: #008800; font-weight: bold } /* Keyword.Declaration */ .highlight .kn { color: #008800; font-weight: bold } /* Keyword.Namespace */ .highlight .kp { color: #008800 } /* Keyword.Pseudo */ .highlight .kr { color: #008800; font-weight: bold } /* Keyword.Reserved */ .highlight .kt { color: #888888; font-weight: bold } /* Keyword.Type */ .highlight .m { color: #0000DD; font-weight: bold } /* Literal.Number */ .highlight .s { color: #dd2200; background-color: #fff0f0 } /* Literal.String */ .highlight .na { color: #336699 } /* Name.Attribute */ .highlight .nb { color: #003388 } /* Name.Builtin */ .highlight .nc { color: #bb0066; font-weight: bold } /* Name.Class */ .highlight .no { color: #003366; font-weight: bold } /* Name.Constant */ .highlight .nd { color: #555555 } /* Name.Decorator */ .highlight .ne { color: #bb0066; font-weight: bold } /* Name.Exception */ .highlight .nf { color: #0066bb; font-weight: bold } /* Name.Function */ .highlight .nl { color: #336699; font-style: italic } /* Name.Label */ .highlight .nn { color: #bb0066; font-weight: bold } /* Name.Namespace */ .highlight .py { color: #336699; font-weight: bold } /* Name.Property */ .highlight .nt { color: #bb0066; font-weight: bold } /* Name.Tag */ .highlight .nv { color: #336699 } /* Name.Variable */ .highlight .ow { color: #008800 } /* Operator.Word */ .highlight .w { color: #bbbbbb } /* Text.Whitespace */ .highlight .mb { color: #0000DD; font-weight: bold } /* Literal.Number.Bin */ .highlight .mf { color: #0000DD; font-weight: bold } /* Literal.Number.Float */ .highlight .mh { color: #0000DD; font-weight: bold } /* Literal.Number.Hex */ .highlight .mi { color: #0000DD; font-weight: bold } /* Literal.Number.Integer */ .highlight .mo { color: #0000DD; font-weight: bold } /* Literal.Number.Oct */ .highlight .sa { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Affix */ .highlight .sb { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Backtick */ .highlight .sc { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Char */ .highlight .dl { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Delimiter */ .highlight .sd { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Doc */ .highlight .s2 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Double */ .highlight .se { color: #0044dd; background-color: #fff0f0 } /* Literal.String.Escape */ .highlight .sh { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Heredoc */ .highlight .si { color: #3333bb; background-color: #fff0f0 } /* Literal.String.Interpol */ .highlight .sx { color: #22bb22; background-color: #f0fff0 } /* Literal.String.Other */ .highlight .sr { color: #008800; background-color: #fff0ff } /* Literal.String.Regex */ .highlight .s1 { color: #dd2200; background-color: #fff0f0 } /* Literal.String.Single */ .highlight .ss { color: #aa6600; background-color: #fff0f0 } /* Literal.String.Symbol */ .highlight .bp { color: #003388 } /* Name.Builtin.Pseudo */ .highlight .fm { color: #0066bb; font-weight: bold } /* Name.Function.Magic */ .highlight .vc { color: #336699 } /* Name.Variable.Class */ .highlight .vg { color: #dd7700 } /* Name.Variable.Global */ .highlight .vi { color: #3333bb } /* Name.Variable.Instance */ .highlight .vm { color: #336699 } /* Name.Variable.Magic */ .highlight .il { color: #0000DD; font-weight: bold } /* Literal.Number.Integer.Long */</style><div class="highlight"><pre><span></span><span class="ch">#!/usr/bin/env python</span> <span class="c1"># Copyright (c) 2016 Orange and others.</span> <span class="c1">#</span> <span class="c1"># All rights reserved. This program and the accompanying materials</span> <span class="c1"># are made available under the terms of the Apache License, Version 2.0</span> <span class="c1"># which accompanies this distribution, and is available at</span> <span class="c1"># http://www.apache.org/licenses/LICENSE-2.0</span> <span class="kn">import</span> <span class="nn">json</span> <span class="kn">import</span> <span class="nn">logging</span> <span class="kn">import</span> <span class="nn">os</span> <span class="kn">import</span> <span class="nn">socket</span> <span class="kn">import</span> <span class="nn">sys</span> <span class="kn">import</span> <span class="nn">time</span> <span class="kn">import</span> <span class="nn">yaml</span> <span class="kn">import</span> <span class="nn">functest.core.vnf</span> <span class="kn">as</span> <span class="nn">vnf</span> <span class="kn">import</span> <span class="nn">functest.utils.functest_utils</span> <span class="kn">as</span> <span class="nn">ft_utils</span> <span class="kn">import</span> <span class="nn">functest.utils.openstack_utils</span> <span class="kn">as</span> <span class="nn">os_utils</span> <span class="kn">from</span> <span class="nn">functest.utils.constants</span> <span class="kn">import</span> <span class="n">CONST</span> <span class="kn">from</span> <span class="nn">org.openbaton.cli.agents.agents</span> <span class="kn">import</span> <span class="n">MainAgent</span> <span class="kn">from</span> <span class="nn">org.openbaton.cli.errors.errors</span> <span class="kn">import</span> <span class="n">NfvoException</span> <span class="c1"># ----------------------------------------------------------</span> <span class="c1">#</span> <span class="c1"># UTILS</span> <span class="c1">#</span> <span class="c1"># -----------------------------------------------------------</span> <span class="k">def</span> <span class="nf">get_config</span><span class="p">(</span><span class="n">parameter</span><span class="p">,</span> <span class="nb">file</span><span class="p">):</span> <span class="sd">"""</span> <span class="sd"> Returns the value of a given parameter in file.yaml</span> <span class="sd"