void GetGuestState() { PHYSICAL_ADDRESS HighestAcceptableAddress; HighestAcceptableAddress.QuadPart = 0xFFFFFFFF00000000; g_GuestState.CR0 = __readcr0(); g_GuestState.CR3 = __readcr3(); g_GuestState.CR4 = __readcr4() | CR4_VMXE; g_GuestState.RFLAGS = __readeflags(); g_GuestState.Cs = __readcs(); g_GuestState.Ds = __readds(); g_GuestState.Es = __reades(); g_GuestState.Ss = __readss(); g_GuestState.Fs = __readfs(); g_GuestState.Gs = __readgs(); g_GuestState.Ldtr = __sldt(); g_GuestState.Tr = __str(); __sgdt(&(g_GuestState.Gdtr)); __sidt(&(g_GuestState.Idtr)); g_GuestState.S_CS = __readmsr(IA32_SYSENTER_CS); g_GuestState.SEIP = __readmsr(IA64_SYSENTER_EIP); g_GuestState.SESP = __readmsr(IA32_SYSENTER_ESP); g_GuestState.VMXON = MmAllocateNonCachedMemory(PAGE_SIZE); RtlZeroMemory(g_GuestState.VMXON, PAGE_SIZE); g_GuestState.VMCS = MmAllocateNonCachedMemory(PAGE_SIZE); RtlZeroMemory(g_GuestState.VMCS, PAGE_SIZE); g_GuestState.hvStack = // 分配的是非页面内存, 且保证在物理内存中是连续的, MmFreeContiguousMemory MmAllocateContiguousMemory(PAGE_SIZE * 2, HighestAcceptableAddress); RtlZeroMemory(g_GuestState.hvStack, PAGE_SIZE * 2); }
static __inline__ void __sdp_media_append_fields(sdp_media *m, stm_into_pri *field, int32_t pt) { char attr[MAX_ATTR_LEN]; switch (field->field_type) { case FIELD_EMPTY: sdp_media_add_attribute(m, "", __str(field->data)); break; case FIELD_FMTP: snprintf(attr, MAX_ATTR_LEN, "%d %s", pt, __str(field->data)); sdp_media_add_attribute(m, "fmtp", attr); break; case FILED_PRI: snprintf(attr, MAX_ATTR_LEN, "%d %s", pt, __str(field->data)); sdp_media_add_attribute(m, "pri", attr); break; default: break; } }
static __inline__ void sdp_media_add_rtpmap(sdp_media *m, stm_info *stm, int32_t pt) { char attr[MAX_ATTR_LEN]; switch (stm->stm_type) { case ST_VIDEO: snprintf(attr, MAX_ATTR_LEN, "%d %s/%u", pt, __str(stm->encoding_name), stm->sample_rate); sdp_media_add_attribute(m, "rtpmap", attr); #ifdef TEST_ONVIF sdp_media_add_attribute(m, "x-onvif-track", "VIDEO001"); #endif break; case ST_AUDIO: snprintf(attr, MAX_ATTR_LEN, "%d %s/%u/%d", pt, __str(stm->encoding_name), stm->sample_rate, stm->audio.audio_channels); sdp_media_add_attribute(m, "rtpmap", attr); snprintf(attr, MAX_ATTR_LEN, "%d", 1000/stm->frame_rate); sdp_media_add_attribute(m, "ptime", attr); #ifdef TEST_ONVIF sdp_media_add_attribute(m, "x-onvif-track", "AUDIO001"); #endif break; default: break; } }
static __inline__ int32_t __ldh_src_open(ldh_src *ldh, media_uri *mrl) { int32_t err = -EPERM, ch, level, type; uint8_t prop[PROPERTY_BUF_LEN], start_time[TIME_BUF_LEN],end_time[TIME_BUF_LEN]; if (!hso || !hso->open) return err; err = __parse_mrl(mrl, &ch, &level, &type, start_time, end_time, prop, NULL); if (err) { LOG_W( "__ldh_src_open()->__parse_mrl(%s) failed, err:'%d'.", __str(mrl), err ); return err; } err = (*hso->open)((avs_media*)ldh, ch, level, type, start_time, end_time, prop); if (err) { LOG_W( "__ldh_src_open()->(*hso->open)(%s) failed, err:'%d'.", __str(mrl), err ); return err; } ldh->state = OPENED; return 0; }
int32_t unix_resolve_host(struct sockaddr_in *sin, uint8_t *host, uint16_t port) { uint8_t dns_buf[DNS_BUFFER_LEN]; struct hostent ht, *ret = NULL; int32_t err, rc; bzero(sin, sizeof(*sin)); rc = gethostbyname_r(__str(host), &ht, __str(dns_buf), DNS_BUFFER_LEN, &ret, &err); if (!rc && ret) { if (ret->h_addrtype != AF_INET) return -EPFNOSUPPORT; sin->sin_family = AF_INET; sin->sin_port = htons(port); sin->sin_addr = *((struct in_addr*)ret->h_addr); return 0; } return err ? -err : -EADDRNOTAVAIL; }
void ___tr_log(int32_t level, char *file, int32_t line, const char *fmt, ...) { va_list ap; log_item *li; if (!log_tp || level > log_verbose) return; if (atomic_get(&backlog) >= LOG_MAX_BACKLOG) return; atomic_inc(&backlog); li = tr_alloc(sizeof(*li)); if (!li) { atomic_dec(&backlog); return; } strcpy(__str(li->text), "LOG: "); va_start(ap, fmt); vsnprintf(__str(li->text) + 5, sizeof(li->text) - 7, fmt, ap); /* -6 */ va_end(ap); strcat(__str(li->text), "\n"); if (level == LVL_ERROR) li->err = 1; else li->err = 0; nmp_threadpool_push(log_tp, li); }
int32_t avs_start_pf_service(uint8_t *mds_ip, uint16_t port, int32_t pu_type, uint8_t *puid, int32_t l4_proto, int32_t ka, exp_cb exp, void *u) { static uint32_t seq = 0; tp_block *tb = tr_alloc(sizeof(*tb)); if (tb) { memset(tb, 0, sizeof(*tb)); tb->action = START; strncpy(__str(tb->psp.ip), __str(mds_ip), MAX_IP_LEN - 1); tb->psp.port = port; strncpy(__str(tb->psp.puid), __str(puid), MAX_PUID_LEN - 1); tb->psp.pu_type = pu_type; tb->psp.l4_proto = l4_proto; tb->psp.ka = ka; tb->psp.exp_notifier = exp; tb->psp.user_data = u; tb->seq = ++seq; pfs_control.last_start = tb->seq; jpf_service_push_op(tb); return 0; } return -ENOMEM; }
template<> str *oct(int i) { if(i<0) return (new str("-0"))->__add__(__str(-i, 8)); else if(i>0) return (new str("0"))->__add__(__str(i, 8)); else return new str("0"); }
str *DynamInt::__div__(DynamInt *num) { /** Overloaded == function Checks if this DynamInt is equal to this one @param num reference to an existing DynamInt @return added DynamInt */ str *remainderString, *result, *xString; int __0, __1, i, j, m, n; DynamInt *cur, *remainder, *temp, *x; j = 0; result = const_0; xString = const_0; remainderString = const_0; temp = (new DynamInt(((int )(0)))); n = 0; while ((n<len(this->data))) { result = result->__add__(const_1); xString = xString->__add__(const_1); n = (n+1); } m = 0; while ((m<len(num->data))) { remainderString = remainderString->__add__(const_1); } cur = (new DynamInt(((int )(0)))); cur->setData((this->data)->__getitem__(0)); remainder = (new DynamInt(((int )(0)))); remainder->setData(remainderString); while ((j<len(this->data))) { x = (new DynamInt(((int )(0)))); x->setData(xString); FAST_FOR(i,0,(len(num->data)-1),1,0,1) temp->setData(x->data); x->setData(x->__add__(num)); if (__gt(x, cur)) { result = __add_strs(3, result->__slice__(2, 0, (j+1), 0), __str(i), result->__slice__(1, (j+2), 0, 0)); break; } END_FOR j = (j+1); remainder->setData(cur->__sub__(temp)); if ((j==len(this->data))) { cur->setData(__str(remainder)); } cur->setData((remainder->data)->__add__((this->data)->__getitem__(j))); } return result; }
static __inline__ sdp_message * rtsp_method_mi_to_sdp(media_info *mi) { #define _MAX_RANGE 64 sdp_message *sdp; char max_range[_MAX_RANGE]; int32_t stm_i, stm_type; sdp_media *media; sdp_message_new(&sdp); sdp_message_set_version(sdp, "0"); #if 1 sdp_message_set_origin(sdp, "-", "12345678910111213", "1", "IN", "IP4", "0.0.0.0"); #else sdp_message_set_origin(sdp, "-", "12345678910111213", "1", "IN", "IP4", "192.168.1.39"); #endif sdp_message_set_session_name(sdp, (const char *)mi->descp); #if 0 sdp_message_add_email(sdp, (const char *)mi->email); sdp_message_add_phone(sdp, (const char *)mi->phone); #endif sdp_message_set_connection(sdp, "IN", "IP4", "0.0.0.0", DEFAULT_TTL, 0); sdp_message_add_time(sdp, "0", "0", NULL); #if 0 sdp_message_add_attribute(sdp, "tool", TR_SERVER_SHORT_BANNER); sdp_message_add_attribute(sdp, "type", "broadcast"); #endif sdp_message_add_attribute(sdp, "control", "*"); #if 1 snprintf(max_range, _MAX_RANGE, "%s", mi->range[0] ? (char*)mi->range : "0-"); sdp_message_add_attribute(sdp, "range", max_range); #endif for (stm_i = 0; stm_i < mi->n_stms; ++stm_i) { sdp_media_new(&media); stm_type = mi->stms[stm_i].stm_type; sdp_media_set_media(media, __str(__stm_name(stm_type))); sdp_media_set_port_info(media, 0, 1); sdp_media_set_proto(media, __str(__stm_proto(stm_type))); sprintf(max_range, "%d", __stm_pt(stm_type, mi->stms[stm_i].fmt)); sdp_media_add_format(media, max_range); sdp_media_add_bandwidth(media, "AS", mi->stms[stm_i].bit_rate); sdp_media_add_rtpmap(media, &mi->stms[stm_i], __stm_pt(stm_type, mi->stms[stm_i].fmt)); sprintf(max_range, TRACK_INDICATOR"%d", stm_i); sdp_media_add_attribute(media, "control", max_range); sdp_media_append_fields(media, &mi->stms[stm_i], __stm_pt(stm_type, mi->stms[stm_i].fmt)); sdp_message_add_media(sdp, media); sdp_media_free(media); } return sdp; }
void *DynamInt::random(int length) { int n; n = 0; while ((n<length)) { this->data = __str((__str(__random__::randint(0, 9)))->__add__(this->data)); n = (n+1); } this->size = len(this->data); return NULL; }
static __inline__ int32_t __parse_mrl(media_uri *mrl, int32_t *channel, int32_t *level, int32_t *type, uint8_t *start_time, uint8_t *end_time, uint8_t *property, int32_t *downld) { char url[MAX_URL_LEN]; char *rt, *start, *end, *pro; strcpy(url, __str(mrl->mrl)); rt = strstr(url, "recordType="); if (!rt) return -EINVAL; start = strstr(url, "startTime="); if (!start) return -EINVAL; end = strstr(url, "endTime="); if (!end) return -EINVAL; pro = strstr(url, "property="); if (pro) { strncpy(__str(property), pro, PROPERTY_BUF_LEN - 1); property[PROPERTY_BUF_LEN - 1] = 0; } strtok(rt, "&"); strtok(rt, "/"); strtok(start, "/"); strtok(end, "/"); if (sscanf(rt, "recordType=%d", type) != 1) return -EINVAL; start += strlen("startTime="); strncpy(__str(start_time), start, TIME_STR_LEN); start_time[TIME_STR_LEN] = 0; end += strlen("endTime="); strncpy(__str(end_time), end, TIME_STR_LEN); end_time[TIME_STR_LEN] = 0; *channel = mrl->mrl_ind1; *level = mrl->mrl_ind2; if (downld) *downld = (mrl->mrl_type == 3); return 0; }
void *writer::writerow(list<str *> *seq) { list<str *> *__24; __iter<str *> *__25; Excel *dialect; __ss_int __26, quoted; str *field; dialect = this->dialect; this->join_reset(); FOR_IN_SEQ(field,seq,24,26) quoted = 0; if ((dialect->quoting==QUOTE_NONNUMERIC)) { quoted = 1; } else if ((dialect->quoting==QUOTE_ALL)) { quoted = 1; } if ((field==NULL)) { quoted = this->join_append(const_16, quoted, (len(seq)==1)); } else { quoted = this->join_append(__str(field), quoted, (len(seq)==1)); } END_FOR (this->rec)->append((this->dialect)->lineterminator); (this->output_file)->write((const_16)->join(this->rec)); return NULL; }
str *DynamInt::__mul__(DynamInt *num) { /** Overloaded add function Adds an existing DynamInt to this one @param num reference to an existing DynamInt @return added DynamInt */ str *bottom, *product, *top; int __2, __3, carry, i, j, k, n, resultSize, tempProduct; if (__gt(this, num)) { top = this->data; bottom = num->data; } else { top = num->data; bottom = this->data; } tempProduct = 0; product = const_0; resultSize = (this->size+num->size); FAST_FOR(n,0,resultSize,1,2,3) product = (const_1)->__add__(product); END_FOR i = (len(bottom)-1); while ((i>=0)) { carry = 0; j = (len(top)-1); while ((j>=0)) { k = (i+j); tempProduct = __int((((__int(top->__getitem__(j))*__int(bottom->__getitem__(i)))+__int(product->__getitem__(k)))+carry)); product = __add_strs(3, product->__slice__(2, 0, (k+1), 0), __str(__mods(tempProduct, 10)), product->__slice__(1, (k+2), 0, 0)); carry = __int(__divs(tempProduct, 10)); j = (j-1); } if ((carry!=0)) { product = __add_strs(3, product->__slice__(2, 0, i, 0), __str(carry), product->__slice__(1, (i+1), 0, 0)); } i = (i-1); } return product; return 0; }
std::string sys::OSWin32::getCurrentWorkingDirectory() const { char buffer[MAX_PATH + 1]; DWORD where = GetCurrentDirectory(MAX_PATH + 1, buffer); if (where == 0) throw sys::SystemException("In getCurrentWorkingDirectory()"); std::string __str(buffer, where); return __str; }
static int32_t __ldl_src_open(ldl_src *ldl, media_uri *mrl) { int32_t err = -EPERM, ch, level; if (!lso || !lso->open) return err; if (ldl->state != INIT) return err; err = __parse_mrl(mrl, &ch, &level); if (err) { LOG_W( "__ldl_src_open()->__parse_mrl(%s) failed, err:'%d'.", __str(mrl), err ); return err; } LOG_I( "__ldl_src_open(): mrl '%s'.", __str(mrl->mrl) ); err = (*lso->open)((avs_media*)ldl, ch, level); if (err) { LOG_W( "__ldl_src_open()->(*lso->open)() failed, err:'%d'.", err ); return err; } else { LOG_I( "__ldl_src_open(): mrl '%s' ok.", __str(mrl->mrl) ); } ldl->state = OPENED; return 0; }
static __inline__ int32_t __ldl_src_probe(ldl_src *ls, media_uri *mrl, media_info *msi) { int32_t ch, level, err = -EPERM; media_info_t mi; if (!lso || !lso->probe) return err; err = __parse_mrl(mrl, &ch, &level); if (err) { LOG_W( "__ldl_src_probe()->__parse_mrl(%s) failed, err:'%d'.", __str(mrl), err ); return err; } memset(&mi, 0, sizeof(mi)); LOG_I( "__ldl_src_probe(): mrl '%s'.", __str(mrl->mrl) ); err = (*lso->probe)(ch, level, &mi); if (err) { LOG_W( "__ldl_src_probe()->(*lso->probe)(%s) failed, err:'%d'.", __str(mrl->mrl), err ); return -ENOENT; } else { LOG_I( "__ldl_src_probe(): mrl '%s' ok.", __str(mrl->mrl) ); } __fill_media_info((ld_src*)ls, msi, &mi); return 0; }
int32_t unix_sock_get_peer(int32_t sock, uint8_t *ip, int32_t size) {//@{Not thread-safe, can't be reentry} struct sockaddr_in sin; socklen_t len = sizeof(sin); bzero(&sin, sizeof(sin)); if (getpeername(sock, (struct sockaddr*)&sin, &len) < 0) return -errno; strncpy(__str(ip), inet_ntoa(sin.sin_addr), size - 1); ip[size -1] = '\0'; return 0; }
static __inline__ int32_t __ldh_src_probe(ldh_src *src, media_uri *mrl, media_info *msi) { int32_t ch, level, type, downld, err = -EPERM; uint8_t prop[PROPERTY_BUF_LEN], start_time[TIME_BUF_LEN], end_time[TIME_BUF_LEN]; media_info_t mi; if (!hso || !hso->probe) return err; err = __parse_mrl(mrl, &ch, &level, &type, start_time, end_time, prop, &downld); if (err) { LOG_W( "__ldh_src_probe()->__parse_mrl(%s) failed, err:'%d'.", __str(mrl), err ); return err; } memset(&mi, 0, sizeof(mi)); err = (*hso->probe)(ch, level, type, start_time, end_time, prop, &mi); if (err) { LOG_W( "__ldh_src_probe()->(*hso->probe)(%s) failed, err:'%d'.", __str(mrl), err ); return -ENOENT; } if (downld) src->flags |= LDH_FLGS_DOWNLD; __fill_media_info((ld_src*)src, msi, &mi); return 0; }
void raspbootUartInit(void) { __str(UART0_CR,0); U32 pinVal = __ldr(GPFSEL1); pinVal &= ~(7<<12); pinVal |= 4<<12; pinVal &= ~(7<<15); pinVal |= 4<<15; __str(GPFSEL1, pinVal); __str(GPPUD, 0); __str(GPPUDCLK0, 0); __str(UART0_ICR, 0x7FF); __str(UART0_IBRD, 1); __str(UART0_FBRD, 40); __str(UART0_LCRH, 0x70); __str(UART0_CR, 0x301); }
int32_t unix_sock_connect(int32_t sock, uint8_t *ip, uint16_t port) { struct sockaddr_in addr; int32_t err; bzero(&addr, sizeof(addr)); addr.sin_family = AF_INET; addr.sin_port = htons(port); addr.sin_addr.s_addr = inet_addr(__str(ip)); err = connect(sock, (struct sockaddr*)&addr, sizeof(addr)); if (err < 0) { return -errno; } return err; }
/** * @brief Deserialize the string value from the specified input stream. * @param __s Reference to the input stream. */ void load(std::basic_istream<CharT, Traits>& __s) { // Define the integer symbol representation placeholder. std::basic_stringstream<CharT, Traits> __i; // Define the input stream iterator of the provided stream to // be able to read the string length value symbol by symbol. auto __si = std::istream_iterator<CharT, CharT, Traits>(__s); // Define the output stream to as a buffer for the integer // value, which will be later converted. auto __ival = std::ostream_iterator<CharT, CharT, Traits>(__i); // Copy the symbols from the input stream to the integer // placeholder until the ":" delimiter value. auto __result = copy_until(__si, __ival, [&__s](const CharT& __ch) { // Additionally, check that we did not exceed the // length of the stream to prevent hangs. return !__s.eof() && __ch != basic_value_type::delimiter_token; }, basic_value_type::integer_length); if (*__result != basic_value_type::delimiter_token) { std::ostringstream __error; __error << "bencode::string::load the delimiter `:` " "expected, but `" << CharT(*__result) << "` found\n"; throw encoding_error(__error.str()); } // Save the length of the string. int64_t __count; __i >> __count; if (!__count && __i.str() != std::basic_string< CharT, Traits>(1, CharT('0'))) { std::ostringstream __error; __error << "bencode::string::load the specified string " "length is not a number\n"; throw value_error(__error.str()); } // Ensure that the string length is a non-negative value. if (__count < 0) { std::ostringstream __error; __error << "bencode::string::load the length of the string " "value must be a positive integer: `" << __count << "`\n"; throw value_error(__error.str()); } // Allocate the list of symbols of the specified string length. std::unique_ptr<CharT[]> __str(new CharT[__count+1]); // Read the string value into the symbol list. __s.get(__str.get(), std::streamsize(__count+1)); auto __strval = string_type(__str.get()); // Ensure that valid count of the symbols was extracted from // the provided input stream. if (int64_t(__strval.length()) != __count) { std::ostringstream __error; __error << "bencode::string::load the specified string " "decoded length is not equal to the real one: `" << __count << "` != `" << __strval.length() << "`\n"; throw value_error(__error.str()); } // Initialize the internal value with a new string. _M_value = __strval; }
str *DynamInt::__add__(DynamInt *num) { /** Overloaded add function Adds an existing DynamInt to this one @param num reference to an existing DynamInt @return added DynamInt */ str *bottom, *sum, *top; int carryover, i, j, tempSum; /** Basically, this selects what should be added to what it is based on primary school addition techniques i.e to add 1234 to 12345, the code makes a configuration similar to 1 2 3 4 5 + 1 2 3 4 ------------- 1 3 5 7 9 ------------- The larger number goes on top while the smaller goes below */ if (__gt(this, num)) { top = this->data; bottom = num->data; } else { top = num->data; bottom = this->data; } /** Temporary Variables used in addition process tempSum ----- Stores partial subtraction j ----- Stores length of bottom number i ----- Stores length of top number sum ----- Stores final sum string carryover ----- A flag that determines if there is a carryover to the next digit */ tempSum = 0; j = (len(bottom)-1); i = (len(top)-1); sum = const_0; carryover = 0; while ((i>=0)) { /** Have we run out of bottom digits ? */ if ((j>=0)) { tempSum = ((__int(top->__getitem__(i))+__int(bottom->__getitem__(j)))+carryover); j = (j-1); } else { /** No more bottom digits, add any leftover carryover */ tempSum = (__int(top->__getitem__(i))+carryover); } if ((tempSum>=10)) { /** do we have a remainder to carryover ? */ tempSum = __mods(tempSum, 10); carryover = 1; } else { carryover = 0; } /** lets concatenate the main sum outputed */ sum = (__str(tempSum))->__add__(sum); i = (i-1); } if ((carryover==1)) { sum = (__str(carryover))->__add__(sum); } return sum; }
template<> str *bin(int i) { if(i<0) return (new str("-0b"))->__add__(__str(-i, 2)); else return (new str("0b"))->__add__(__str(i, 2)); }
str *DynamInt::__sub__(DynamInt *num) { /** Overloaded Subtraction function subtracts an existing DynamInt from this one @param num reference to an existing DynamInt @return added DynamInt */ str *bottom, *sub, *sum, *top; int borrow, i, j, tempSub; /** Uses two's compliment on each element of both numbers */ if (__eq(this, num)) { return const_1; } if (__gt(this, num)) { top = this->data; bottom = num->data; } else if (__gt(num, this)) { top = num->data; bottom = this->data; } /** Temporary Variables used in addition process tempSub ----- Stores partial subtraction j ----- Stores length of bottom number i ----- Stores length of top number sub ----- Stores final sub string borrow ----- A flag that determines if it would need to borrow from next digit */ tempSub = 0; j = (len(bottom)-1); i = (len(top)-1); borrow = 0; sub = const_0; while ((i>=0)) { /** Have we run out of bottom digits ? */ if ((j>=0)) { tempSub = ((__int(top->__getitem__(i))-__int(bottom->__getitem__(j)))-borrow); if ((tempSub<0)) { borrow = 1; tempSub = (tempSub+10); } else { borrow = 0; } j = (j-1); } else { /** No more bottom digits, subtract any leftover borrow out */ tempSub = (__int(top->__getitem__(i))-borrow); if ((tempSub<0)) { borrow = 1; tempSub = (tempSub+10); } else { borrow = 0; } } /** lets concatenate the main sum outputed */ sub = (__str(tempSub))->__add__(sub); i = (i-1); } if ((borrow==1)) { sum = (const_2)->__add__(sub); } return sub; }
template<> str *hex(int i) { if(i<0) return (new str("-0x"))->__add__(__str(-i, 16)); else return (new str("0x"))->__add__(__str(i, 16)); }
template<> str *repr(int i) { return __str(i); }
template<> str *repr(double d) { return __str(d); }
VOID NTAPI KiInitializePcr(IN PKIPCR Pcr, IN ULONG ProcessorNumber, IN PKTHREAD IdleThread, IN PVOID DpcStack) { KDESCRIPTOR GdtDescriptor = {{0},0,0}, IdtDescriptor = {{0},0,0}; PKGDTENTRY64 TssEntry; USHORT Tr = 0; /* Zero out the PCR */ RtlZeroMemory(Pcr, sizeof(KIPCR)); /* Set pointers to ourselves */ Pcr->Self = (PKPCR)Pcr; Pcr->CurrentPrcb = &Pcr->Prcb; /* Set the PCR Version */ Pcr->MajorVersion = PCR_MAJOR_VERSION; Pcr->MinorVersion = PCR_MINOR_VERSION; /* Set the PRCB Version */ Pcr->Prcb.MajorVersion = 1; Pcr->Prcb.MinorVersion = 1; /* Set the Build Type */ Pcr->Prcb.BuildType = 0; #ifndef CONFIG_SMP Pcr->Prcb.BuildType |= PRCB_BUILD_UNIPROCESSOR; #endif #if DBG Pcr->Prcb.BuildType |= PRCB_BUILD_DEBUG; #endif /* Set the Processor Number and current Processor Mask */ Pcr->Prcb.Number = (UCHAR)ProcessorNumber; Pcr->Prcb.SetMember = 1ULL << ProcessorNumber; /* Get GDT and IDT descriptors */ __sgdt(&GdtDescriptor.Limit); __sidt(&IdtDescriptor.Limit); Pcr->GdtBase = (PVOID)GdtDescriptor.Base; Pcr->IdtBase = (PKIDTENTRY)IdtDescriptor.Base; /* Get TSS Selector */ __str(&Tr); ASSERT(Tr == KGDT64_SYS_TSS); /* Get TSS Entry */ TssEntry = KiGetGdtEntry(Pcr->GdtBase, Tr); /* Get the KTSS itself */ Pcr->TssBase = KiGetGdtDescriptorBase(TssEntry); Pcr->Prcb.RspBase = Pcr->TssBase->Rsp0; // FIXME /* Set DPC Stack */ Pcr->Prcb.DpcStack = DpcStack; /* Setup the processor set */ Pcr->Prcb.MultiThreadProcessorSet = Pcr->Prcb.SetMember; /* Clear DR6/7 to cleanup bootloader debugging */ Pcr->Prcb.ProcessorState.SpecialRegisters.KernelDr6 = 0; Pcr->Prcb.ProcessorState.SpecialRegisters.KernelDr7 = 0; /* Set the Current Thread */ Pcr->Prcb.CurrentThread = IdleThread; /* Start us out at PASSIVE_LEVEL */ Pcr->Irql = PASSIVE_LEVEL; KeSetCurrentIrql(PASSIVE_LEVEL); }
static bool setup_vmcs(struct vcpu *vcpu, uintptr_t sp, uintptr_t ip, uintptr_t stack_base) { struct gdtr gdtr; __sgdt(&gdtr); struct gdtr idtr; __sidt(&idtr); /* Get this CPU's EPT */ struct ept *ept = &vcpu->ept; u64 cr0 = __readcr0(); u64 cr4 = __readcr4(); u64 err = 0; u16 es = __reades(); u16 cs = __readcs(); u16 ss = __readss(); u16 ds = __readds(); u16 fs = __readfs(); u16 gs = __readgs(); u16 ldt = __sldt(); u16 tr = __str(); vcpu->g_idt.base = idtr.base; vcpu->g_idt.limit = idtr.limit; struct kidt_entry64 *current = (struct kidt_entry64 *)idtr.base; struct kidt_entry64 *shadow = (struct kidt_entry64 *)vcpu->idt.base; unsigned count = idtr.limit / sizeof(*shadow); for (unsigned n = 0; n < count; ++n) memcpy(&shadow[n], ¤t[n], sizeof(*shadow)); vcpu_put_idt(vcpu, cs, X86_TRAP_VE, __ept_violation); u8 msr_off = 0; if (__readmsr(MSR_IA32_VMX_BASIC) & VMX_BASIC_TRUE_CTLS) msr_off = 0xC; u64 vm_entry = VM_ENTRY_IA32E_MODE;// | VM_ENTRY_LOAD_IA32_PAT; adjust_ctl_val(MSR_IA32_VMX_ENTRY_CTLS + msr_off, &vm_entry); u64 vm_exit = VM_EXIT_ACK_INTR_ON_EXIT | VM_EXIT_HOST_ADDR_SPACE_SIZE; adjust_ctl_val(MSR_IA32_VMX_EXIT_CTLS + msr_off, &vm_exit); u64 vm_pinctl = 0; adjust_ctl_val(MSR_IA32_VMX_PINBASED_CTLS + msr_off, &vm_pinctl); u64 vm_cpuctl = CPU_BASED_ACTIVATE_SECONDARY_CONTROLS | CPU_BASED_USE_MSR_BITMAPS | CPU_BASED_MOV_DR_EXITING | CPU_BASED_USE_TSC_OFFSETING; adjust_ctl_val(MSR_IA32_VMX_PROCBASED_CTLS + msr_off, &vm_cpuctl); u64 vm_2ndctl = SECONDARY_EXEC_ENABLE_EPT | SECONDARY_EXEC_TSC_SCALING | SECONDARY_EXEC_DESC_TABLE_EXITING | SECONDARY_EXEC_XSAVES | SECONDARY_EXEC_RDTSCP | SECONDARY_EXEC_ENABLE_VMFUNC | SECONDARY_EXEC_ENABLE_VE; adjust_ctl_val(MSR_IA32_VMX_PROCBASED_CTLS2, &vm_2ndctl); /* Processor control fields */ err |= __vmx_vmwrite(PIN_BASED_VM_EXEC_CONTROL, vm_pinctl); err |= __vmx_vmwrite(CPU_BASED_VM_EXEC_CONTROL, vm_cpuctl); err |= __vmx_vmwrite(EXCEPTION_BITMAP, __EXCEPTION_BITMAP); err |= __vmx_vmwrite(PAGE_FAULT_ERROR_CODE_MASK, 0); err |= __vmx_vmwrite(PAGE_FAULT_ERROR_CODE_MATCH, 0); err |= __vmx_vmwrite(CR3_TARGET_COUNT, 0); err |= __vmx_vmwrite(VM_EXIT_CONTROLS, vm_exit); err |= __vmx_vmwrite(VM_EXIT_MSR_STORE_COUNT, 0); err |= __vmx_vmwrite(VM_EXIT_MSR_LOAD_COUNT, 0); err |= __vmx_vmwrite(VM_ENTRY_CONTROLS, vm_entry); err |= __vmx_vmwrite(VM_ENTRY_MSR_LOAD_COUNT, 0); err |= __vmx_vmwrite(VM_ENTRY_INTR_INFO_FIELD, 0); err |= __vmx_vmwrite(SECONDARY_VM_EXEC_CONTROL, vm_2ndctl); /* Control Fields */ err |= __vmx_vmwrite(IO_BITMAP_A, 0); err |= __vmx_vmwrite(IO_BITMAP_B, 0); err |= __vmx_vmwrite(MSR_BITMAP, __pa(ksm.msr_bitmap)); err |= __vmx_vmwrite(EPT_POINTER, EPTP(ept, EPTP_DEFAULT)); err |= __vmx_vmwrite(VM_FUNCTION_CTRL, VM_FUNCTION_CTL_EPTP_SWITCHING); err |= __vmx_vmwrite(EPTP_INDEX, EPTP_DEFAULT); err |= __vmx_vmwrite(EPTP_LIST_ADDRESS, __pa(ept->ptr_list)); err |= __vmx_vmwrite(VE_INFO_ADDRESS, __pa(vcpu->ve)); err |= __vmx_vmwrite(CR0_GUEST_HOST_MASK, __CR0_GUEST_HOST_MASK); err |= __vmx_vmwrite(CR4_GUEST_HOST_MASK, __CR4_GUEST_HOST_MASK); err |= __vmx_vmwrite(CR0_READ_SHADOW, cr0); err |= __vmx_vmwrite(CR4_READ_SHADOW, cr4); err |= __vmx_vmwrite(VMCS_LINK_POINTER, -1ULL); /* Guest */ err |= __vmx_vmwrite(GUEST_ES_SELECTOR, es); err |= __vmx_vmwrite(GUEST_CS_SELECTOR, cs); err |= __vmx_vmwrite(GUEST_SS_SELECTOR, ss); err |= __vmx_vmwrite(GUEST_DS_SELECTOR, ds); err |= __vmx_vmwrite(GUEST_FS_SELECTOR, fs); err |= __vmx_vmwrite(GUEST_GS_SELECTOR, gs); err |= __vmx_vmwrite(GUEST_LDTR_SELECTOR, ldt); err |= __vmx_vmwrite(GUEST_TR_SELECTOR, tr); err |= __vmx_vmwrite(GUEST_ES_LIMIT, __segmentlimit(es)); err |= __vmx_vmwrite(GUEST_CS_LIMIT, __segmentlimit(cs)); err |= __vmx_vmwrite(GUEST_SS_LIMIT, __segmentlimit(ss)); err |= __vmx_vmwrite(GUEST_DS_LIMIT, __segmentlimit(ds)); err |= __vmx_vmwrite(GUEST_FS_LIMIT, __segmentlimit(fs)); err |= __vmx_vmwrite(GUEST_GS_LIMIT, __segmentlimit(gs)); err |= __vmx_vmwrite(GUEST_LDTR_LIMIT, __segmentlimit(ldt)); err |= __vmx_vmwrite(GUEST_TR_LIMIT, __segmentlimit(tr)); err |= __vmx_vmwrite(GUEST_GDTR_LIMIT, gdtr.limit); err |= __vmx_vmwrite(GUEST_IDTR_LIMIT, idtr.limit); err |= __vmx_vmwrite(GUEST_ES_AR_BYTES, __accessright(es)); err |= __vmx_vmwrite(GUEST_CS_AR_BYTES, __accessright(cs)); err |= __vmx_vmwrite(GUEST_SS_AR_BYTES, __accessright(ss)); err |= __vmx_vmwrite(GUEST_DS_AR_BYTES, __accessright(ds)); err |= __vmx_vmwrite(GUEST_FS_AR_BYTES, __accessright(fs)); err |= __vmx_vmwrite(GUEST_GS_AR_BYTES, __accessright(gs)); err |= __vmx_vmwrite(GUEST_LDTR_AR_BYTES, __accessright(ldt)); err |= __vmx_vmwrite(GUEST_TR_AR_BYTES, __accessright(tr)); err |= __vmx_vmwrite(GUEST_INTERRUPTIBILITY_INFO, 0); err |= __vmx_vmwrite(GUEST_ACTIVITY_STATE, 0); err |= __vmx_vmwrite(GUEST_IA32_DEBUGCTL, __readmsr(MSR_IA32_DEBUGCTLMSR)); err |= __vmx_vmwrite(GUEST_SYSENTER_CS, __readmsr(MSR_IA32_SYSENTER_CS)); err |= __vmx_vmwrite(GUEST_CR0, cr0); err |= __vmx_vmwrite(GUEST_CR3, ksm.origin_cr3); err |= __vmx_vmwrite(GUEST_CR4, cr4); err |= __vmx_vmwrite(GUEST_ES_BASE, 0); err |= __vmx_vmwrite(GUEST_CS_BASE, 0); err |= __vmx_vmwrite(GUEST_SS_BASE, 0); err |= __vmx_vmwrite(GUEST_DS_BASE, 0); err |= __vmx_vmwrite(GUEST_FS_BASE, __readmsr(MSR_IA32_FS_BASE)); err |= __vmx_vmwrite(GUEST_GS_BASE, __readmsr(MSR_IA32_GS_BASE)); err |= __vmx_vmwrite(GUEST_LDTR_BASE, __segmentbase(gdtr.base, ldt)); err |= __vmx_vmwrite(GUEST_TR_BASE, __segmentbase(gdtr.base, tr)); err |= __vmx_vmwrite(GUEST_GDTR_BASE, gdtr.base); err |= __vmx_vmwrite(GUEST_IDTR_BASE, vcpu->idt.base); err |= __vmx_vmwrite(GUEST_DR7, __readdr(7)); err |= __vmx_vmwrite(GUEST_RSP, sp); err |= __vmx_vmwrite(GUEST_RIP, ip); err |= __vmx_vmwrite(GUEST_RFLAGS, __readeflags()); err |= __vmx_vmwrite(GUEST_SYSENTER_ESP, __readmsr(MSR_IA32_SYSENTER_ESP)); err |= __vmx_vmwrite(GUEST_SYSENTER_EIP, __readmsr(MSR_IA32_SYSENTER_EIP)); /* Host */ err |= __vmx_vmwrite(HOST_ES_SELECTOR, es & 0xf8); err |= __vmx_vmwrite(HOST_CS_SELECTOR, cs & 0xf8); err |= __vmx_vmwrite(HOST_SS_SELECTOR, ss & 0xf8); err |= __vmx_vmwrite(HOST_DS_SELECTOR, ds & 0xf8); err |= __vmx_vmwrite(HOST_FS_SELECTOR, fs & 0xf8); err |= __vmx_vmwrite(HOST_GS_SELECTOR, gs & 0xf8); err |= __vmx_vmwrite(HOST_TR_SELECTOR, tr & 0xf8); err |= __vmx_vmwrite(HOST_CR0, cr0); err |= __vmx_vmwrite(HOST_CR3, ksm.kernel_cr3); err |= __vmx_vmwrite(HOST_CR4, cr4); err |= __vmx_vmwrite(HOST_FS_BASE, __readmsr(MSR_IA32_FS_BASE)); err |= __vmx_vmwrite(HOST_GS_BASE, __readmsr(MSR_IA32_GS_BASE)); err |= __vmx_vmwrite(HOST_TR_BASE, __segmentbase(gdtr.base, tr)); err |= __vmx_vmwrite(HOST_GDTR_BASE, gdtr.base); err |= __vmx_vmwrite(HOST_IDTR_BASE, idtr.base); err |= __vmx_vmwrite(HOST_IA32_SYSENTER_CS, __readmsr(MSR_IA32_SYSENTER_CS)); err |= __vmx_vmwrite(HOST_IA32_SYSENTER_ESP, __readmsr(MSR_IA32_SYSENTER_ESP)); err |= __vmx_vmwrite(HOST_IA32_SYSENTER_EIP, __readmsr(MSR_IA32_SYSENTER_EIP)); err |= __vmx_vmwrite(HOST_RSP, stack_base); err |= __vmx_vmwrite(HOST_RIP, (uintptr_t)__vmx_entrypoint); return err == 0; }