kernel/vm/vm.cpp

600 		// It also makes sense to move it from the inactive to the active, since
846 		// Transfer the concerned pages from the first cache.
1324 	supplied with a \a cookie retrieved from a successful call to
2288 			// prefetches at max 10 MB starting from "offset"
2464 			// map in all pages from source
2512 	// At this point the area is removed from the global hash table, but
2579 /*!	Creates a new cache on top of given cache, moves all areas from
2602 	// We need to separate the cache from its areas. The cache goes one level
2626 	// We now need to remap all pages from all of the cache's areas read-only,
2966 				// Since this cache now lives from the pages in its source cache,
3118 /*!	Removes all mappings from a page.
3119 	After you've called this function, the page is unmapped from memory and
3228 			"  -p or --physical only allows memory from a single page to be "
4094 /*!	Frees all previously kernel arguments areas from the kernel_args structure.
4590 		// this keeps a user space thread from passing a buffer that crosses
4726 	locked as well as all caches starting from the top cache to at least the
4782 				dprintf("reading page from cache %p returned: %s!\n",
4830 		// from our source cache -- if possible, that is.
4947 		// At first, the top most cache from the area is investigated.
4965 		// from top to bottom).
5028 					// have a page from a lower cache mapped while an upper
5501 vm_memcpy_from_physical(void* to, phys_addr_t from, size_t length, bool user)
5503 	return sPhysicalPageMapper->MemcpyFromPhysical(to, from, length, user);
5516 vm_memcpy_physical_page(phys_addr_t to, phys_addr_t from)
5518 	return sPhysicalPageMapper->MemcpyPhysicalPage(to, from);
5522 /*!	Copies a range of memory directly from/to a page that might not be mapped
5527 	and copies from/to it directly.
5537 		from/to.
5538 	\param buffer A safely accessible kernel buffer to be copied from/to.
5540 	\param copyToUnsafe If \c true, memory is copied from \a buffer to
5584 		// to get it from lower caches.
5594 	// copy from/to physical memory
5629 user_memcpy(void* to, const void* from, size_t size)
5631 	if (!validate_memory_range(to, size) || !validate_memory_range(from, size))
5634 	if (arch_cpu_user_memcpy(to, from, size) < B_OK)
5641 /*!	\brief Copies at most (\a size - 1) characters from the string in \a from to
5645 	\param from Pointer to the source C-string.
5648 	\return strlen(\a from).
5651 user_strlcpy(char* to, const char* from, size_t size)
5655 	if (from == NULL)
5658 	// Protect the source address from overflows.
5660 	if ((addr_t)from + maxSize < (addr_t)from)
5661 		maxSize -= (addr_t)from + maxSize;
5662 	if (IS_USER_ADDRESS(from) && !IS_USER_ADDRESS((addr_t)from + maxSize))
5663 		maxSize = USER_TOP - (addr_t)from;
5668 	ssize_t result = arch_cpu_user_strlcpy(to, from, maxSize);
5823 	// remove the wired range from the range
5852 		requests that the range must be wired writable ("read from device
6535 	// TODO: do we want to prevent userland from seeing kernel protections?
6712 	// that you have created yourself from userland.
6861 	// Second round: If the protections differ from that of the area, create a
7271 /*!	The type of the \a physicalAddress parameter has changed from void* to