static void checkStubs(void* addr) { vm_prot_t perm = getPermission(addr); if ( (perm == 0) || ((perm & VM_PROT_WRITE) != 0) ) { FAIL("read-only-stubs: bad permissions %d at address %p", perm, addr); exit(0); } }
/** * @brief * * @param print_buffer */ static void uart_dev_write(char *print_buffer) { if(getPermission(DEVICE_ID) == 1){ serial_puts(print_buffer); }else{ serial_puts("\n\rSW: No Permission to access UART device \r\n"); } return; }
bool Block::handlePageFault(task_t* i_task, uint64_t i_addr, bool i_store) { // Check containment, call down chain if address isn't in this block. if (!isContained(i_addr)) { return (iv_nextBlock ? iv_nextBlock->handlePageFault(i_task, i_addr, i_store) : false); } // Calculate page aligned virtual address. uint64_t l_addr_palign = (i_addr / PAGESIZE) * PAGESIZE; ShadowPTE* pte = getPTE(l_addr_palign); // If the page table entry has default permission settings if (getPermission(pte) == NO_ACCESS) { printkd("handle page fault.. Permission not set for addr = 0x%.lX\n", (uint64_t)l_addr_palign); // return false because permission have not been set. return false; } // Mark the page as dirty if this is a store to it. if (i_store) { if (pte->isWritable()) { pte->setDirty(true); } else // Store to non-writable page! This is a permission fault, so // return unhandled. { return false; } } if (!pte->isPresent()) { if (this->iv_readMsgHdlr != NULL) { void* l_page = reinterpret_cast<void*>(pte->getPageAddr()); //If the page data is zero, create the page if (pte->getPage() == 0) { l_page = PageManager::allocatePage(); //Add to ShadowPTE pte->setPageAddr(reinterpret_cast<uint64_t>(l_page)); } this->iv_readMsgHdlr->sendMessage(MSG_MM_RP_READ, reinterpret_cast<void*>(l_addr_palign),l_page,i_task); //Done(waiting for response) return true; } else if (pte->isAllocateFromZero()) { void* l_page = PageManager::allocatePage(); // set the permission of the physical address pte entry to // READ_ONLY now that we have handled the page fault and // have a SPTE entry for that VA. if (BaseSegment::mmSetPermission(reinterpret_cast<void*>(l_page), 0, READ_ONLY)) { // Did not set permission.. printkd("handle page fault.. Set Permission failed for physical" " addr = 0x%.lX\n", (uint64_t)l_page); } memset(l_page, '\0', PAGESIZE); pte->setPageAddr(reinterpret_cast<uint64_t>(l_page)); pte->setPresent(true); } else { return false; } } // Determine access type. uint64_t l_access = (iv_mappedToPhysical ? BYPASS_HRMOR : 0); if (pte->isExecutable()) { l_access |= EXECUTABLE; } else if (pte->isWritable() && pte->isDirty()) { l_access |= WRITABLE; } else { l_access |= READ_ONLY; } PageTableManager::addEntry( l_addr_palign, pte->getPage(), l_access); return true; }
int Block::setPermSPTE( ShadowPTE* i_spte, uint64_t i_access_type) { // If read_only if ( i_access_type & READ_ONLY) { // If the writable, executable, write_tracked // or allocate from zero access bits are set // we have an invalid combination.. return error if ((i_access_type & WRITABLE) || (i_access_type & EXECUTABLE) || (i_access_type & WRITE_TRACKED) || (i_access_type & ALLOCATE_FROM_ZERO)) { return -EINVAL; } // Set the bits after we have verified // the valid combinations so if we are setting // permissions on a range only the first page would // get set to READ_ONLY before we fail. i_spte->setReadable(true); i_spte->setExecutable(false); i_spte->setWritable(false); } // if writable else if ( i_access_type & WRITABLE) { if (i_access_type & EXECUTABLE) { return -EINVAL; } i_spte->setReadable(true); i_spte->setWritable(true); i_spte->setExecutable(false); } // if executable else if ( i_access_type & EXECUTABLE) { i_spte->setReadable(true); i_spte->setExecutable(true); i_spte->setWritable(false); } // if write_tracked if ( i_access_type & WRITE_TRACKED) { // If the page is already READ_ONLY // you cannot set to WRITE_TRACKED if (getPermission(i_spte) == READ_ONLY) { return -EINVAL; } else if (NULL == iv_writeMsgHdlr) { return -EINVAL; } i_spte->setWriteTracked(true); } else { i_spte->setWriteTracked(false); } // if Allocate from zero if ( i_access_type & ALLOCATE_FROM_ZERO) { // If the page is already READ_ONLY // you cannot set to ALLOCATE_FROM_ZERO if (getPermission(i_spte) == READ_ONLY) { return -EINVAL; } i_spte->setAllocateFromZero(true); } // not allocated from zero else { i_spte->setAllocateFromZero(false); } // if no access if ( i_access_type & NO_ACCESS) { i_spte->setReadable(false); i_spte->setExecutable(false); i_spte->setWritable(false); i_spte->setAllocateFromZero(false); i_spte->setWriteTracked(false); } return 0; }
void PermissionManager::checkPermissionThrows( const String& rName, camp::Value& rValue, const String& rSrc ) { if( ClientPlugin::isOfflineMode() ) return; getPermission( rName ).checkPermissionThrows( rValue, rSrc ); }
bool PermissionManager::checkPermissionAllowed( const String& rName, camp::Value& rValue ) { if( ClientPlugin::isOfflineMode() ) return true; return getPermission( rName ).checkPermissionAllowed( rValue ); }
Permission::ResultType PermissionManager::checkPermission( const String& rName, camp::Value& rValue ) { if( ClientPlugin::isOfflineMode() ) return Permission::Permission_Allowed; return getPermission( rName ).checkPermission( rValue ); }
QString AdobeDRM::getPermissionString( dpdoc::Document* doc, const char* type , bool* drmFile ) { QString perm_str; Permission perm; if (!m_proc || !doc) return QString(); perm = getPermission(doc, type); qDebug() << Q_FUNC_INFO << perm; if(!perm.valid) { perm_str.append("Not allowed"); if(drmFile) *drmFile = true; return perm_str; } // Legal device ? if( perm.type == QString("print")) { perm_str.append("Any Device"); return perm_str; } if( perm.type == QString("excerpt")) { perm_str.append("Any Device"); return perm_str; } if(perm.deviceId.isEmpty()) { perm_str.append("Any Device"); } else { bool isLegalDevice = false; dp::list<dpdrm::Activation> activations = m_proc->getActivations(); unsigned int size = activations.length(); for (unsigned int i = 0; i < size; ++i) { dp::ref<dpdrm::Activation> activation = activations[i]; QString deviceId = QString::fromUtf8(activation->getDeviceID().utf8()); if( deviceId == perm.deviceId ) { isLegalDevice = true; break; } } if(isLegalDevice) perm_str.append("Only this Device"); else perm_str.append("Not this Device"); } // Expiration ? if(perm.maxResolution != 0 && perm.type == QString("print")) { perm_str.append(QString(", Max. resolution is %1 dpi").arg(perm.maxResolution)); } if(perm.expiration.toTime_t() != 0) { perm_str.append(", Until "); perm_str.append(perm.expiration.toLocalTime().toString(Qt::SystemLocaleDate)); } if(drmFile) { QString drm_string("Any Device"); if(perm_str.compare(drm_string, Qt::CaseSensitive)!= 0) *drmFile = true; else *drmFile = false; } return perm_str; }
//print permission, name, owner, size and last modification time void Directory :: outputLong() const { cout << getPermission() + " " + getName() + " " + getOwner() + " " << getSize() << " " + getTime() << endl; }