vm_unmap_aliases(9) [centos man page]

VM_UNMAP_ALIASES(9)					    Memory Management in Linux					       VM_UNMAP_ALIASES(9)

NAME

       vm_unmap_aliases - unmap outstanding lazy aliases in the vmap layer

SYNOPSIS

       void vm_unmap_aliases(void);

ARGUMENTS

       void
	   no arguments

DESCRIPTION

       The vmap/vmalloc layer lazily flushes kernel virtual mappings primarily to amortize TLB flushing overheads. What this means is that any
       page you have now, may, in a former life, have been mapped into kernel virtual address by the vmap layer and so there might be some CPUs
       with TLB entries still referencing that page (additional to the regular 1:1 kernel mapping).

       vm_unmap_aliases flushes all such lazy mappings. After it returns, we can be sure that none of the pages we have control over will have any
       aliases from the vmap layer.

COPYRIGHT

Kernel Hackers Manual 3.10					     June 2014						       VM_UNMAP_ALIASES(9)

SF_BUF(9)						   BSD Kernel Developer's Manual						 SF_BUF(9)

NAME

     sf_buf -- manage temporary kernel address space mapping for memory pages

SYNOPSIS

     #include <sys/sf_buf.h>

     struct sf_buf *
     sf_buf_alloc(struct vm_page *m, int flags);

     void
     sf_buf_free(struct sf_buf *sf);

     vm_offset_t
     sf_buf_kva(struct sf_buf *sf);

     struct vm_page *
     sf_buf_page(struct sf_buf *sf);

DESCRIPTION

     The sf_buf interface, historically the sendfile(2) buffer interface, allows kernel subsystems to manage temporary kernel address space map-
     pings for physical memory pages.  On systems with a direct memory map region (allowing all physical pages to be visible in the kernel address
     space at all times), the struct sf_buf will point to an address in the direct map region; on systems without a direct memory map region, the
     struct sf_buf will manage a temporary kernel address space mapping valid for the lifetime of the struct sf_buf.

     Call sf_buf_alloc() to allocate a struct sf_buf for a physical memory page.  sf_buf_alloc() is not responsible for arranging for the page to
     be present in physical memory; the caller should already have arranged for the page to be wired, i.e., by calling vm_page_wire(9).  Several
     flags may be passed to sf_buf_alloc():

     SFB_CATCH	     Cause sf_buf_alloc() to abort and return NULL if a signal is received waiting for a struct sf_buf to become available.

     SFB_NOWAIT      Cause sf_buf_alloc() to return NULL rather than sleeping if a struct sf_buf is not immediately available.

     SFB_CPUPRIVATE  Cause sf_buf_alloc() to only arrange that the temporary mapping be valid on the current CPU, avoiding unnecessary TLB shoot-
		     downs for mappings that will only be accessed on a single CPU at a time.  The caller must ensure that accesses to the virtual
		     address occur only on the CPU from which sf_buf_alloc() was invoked, perhaps by using sched_pin().

     Call sf_buf_kva() to return a kernel mapped address for the page.

     Call sf_buf_page() to return a pointer to the page originally passed into sf_buf_alloc().

     Call sf_buf_free() to release the struct sf_buf reference.  The caller is responsible for releasing any wiring they have previously acquired
     on the physical page; sf_buf_free() releases only the temporary kernel address space mapping, not the page itself.

     Uses of this interface include managing mappings of borrowed pages from user memory, such as in zero-copy socket I/O, or pages of memory from
     the buffer cache referenced by mbuf external storage for sendfile(2).

SEE ALSO

     sendfile(2), vm_page_wire(9)

AUTHORS

     The struct sf_buf API was designed and implemented by Alan L. Cox.  This manual page was written by Robert N. M. Watson.

BSD
								 January 28, 2007							       BSD