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;
}
