include/linux/skbuff.h

407  * skb_frag_must_loop - Test if %p is a high memory page
408  * @p: fragment's page
410 static inline bool skb_frag_must_loop(struct page *p)
425  *	@p:		(temp var) current page
426  *	@p_off:		(temp var) offset from start of current page,
427  *	                           non-zero only on first page.
428  *	@p_len:		(temp var) length in current page,
429  *				   < PAGE_SIZE only on first and last page.
432  *	A fragment can hold a compound page, in which case per-page
434  *	regular page.
518 	/* page references are managed by the ubuf_info, so it's safe to
722  *    to read-only data in the (page, offset, length) format.
740  *                                 + [page frag]
741  *                                 + [page frag]
742  *                                 + [page frag]
743  *                                 + [page frag]       ---------
801  *	@head_frag: skb was allocated from page fragments,
1405 int skb_append_pagefrags(struct sk_buff *skb, struct page *page,
2462 					   struct page *page,
2465 	skb_frag_fill_netmem_desc(frag, page_to_netmem(page), off, size);
2478 					      int i, struct page *page,
2481 	__skb_fill_netmem_desc_noacc(shinfo, i, page_to_netmem(page), off,
2502  * @off: the offset to the data with @page
2506  * offset @off within @page.
2513 	struct page *page = netmem_to_page(netmem);
2517 	/* Propagate page pfmemalloc to the skb if we can. The problem is
2518 	 * that not all callers have unique ownership of the page but rely
2521 	page = compound_head(page);
2522 	if (page_is_pfmemalloc(page))
2527 					struct page *page, int off, int size)
2529 	__skb_fill_netmem_desc(skb, i, page_to_netmem(page), off, size);
2543  * @page: the page to use for this fragment
2544  * @off: the offset to the data with @page
2548  * @skb to point to @size bytes at offset @off within @page. In
2554 				      struct page *page, int off, int size)
2556 	skb_fill_netmem_desc(skb, i, page_to_netmem(page), off, size);
2563  * @page: the page to use for this fragment
2564  * @off: the offset to the data with @page
2568  * pfmemalloc, if page is not owned by us.
2571 					    struct page *page, int off,
2576 	__skb_fill_page_desc_noacc(shinfo, i, page, off, size);
2584 				   struct page *page, int off, int size,
2587 	skb_add_rx_frag_netmem(skb, i, page_to_netmem(page), off, size,
3226  *	page by calling the destructor.
3282  * netdev_alloc_frag - allocate a page fragment
3285  * Allocates a frag from a page for receive buffer.
3378  * __dev_alloc_pages - allocate page for network Rx
3382  * Allocate a new page.
3386 static inline struct page *__dev_alloc_pages_noprof(gfp_t gfp_mask,
3390 	 * 1.  This is for device Rx, therefore a cold page is preferred.
3391 	 * 2.  The expectation is the user wants a compound page.
3392 	 * 3.  If requesting a order 0 page it will not be compound
3406  * __dev_alloc_page - allocate a page for network Rx
3409  * Allocate a new page.
3413 static inline struct page *__dev_alloc_page_noprof(gfp_t gfp_mask)
3422  * dev_page_is_reusable - check whether a page can be reused for network Rx
3423  * @page: the page to test
3425  * A page shouldn't be considered for reusing/recycling if it was allocated
3428  * Returns false if this page should be returned to page allocator, true
3431 static inline bool dev_page_is_reusable(const struct page *page)
3433 	return likely(page_to_nid(page) == numa_mem_id() &&
3434 		      !page_is_pfmemalloc(page));
3438  *	skb_propagate_pfmemalloc - Propagate pfmemalloc if skb is allocated after RX page
3439  *	@page: The page that was allocated from skb_alloc_page
3442 static inline void skb_propagate_pfmemalloc(const struct page *page,
3445 	if (page_is_pfmemalloc(page))
3490  * skb_frag_page - retrieve the page referred to by a paged fragment
3493  * Returns the &struct page associated with @frag.
3495 static inline struct page *skb_frag_page(const skb_frag_t *frag)
3508  * Returns the address of the data within @frag. The page must already
3520  * Returns the address of the data within @frag. Checks that the page
3533  * skb_frag_page_copy() - sets the page in a fragment from another fragment
3534  * @fragto: skb fragment where page is set
3535  * @fragfrom: skb fragment page is copied from
3554  * Maps the page associated with @frag to @device.
3728 				    const struct page *page, int off)
3735 		return page == skb_frag_page(frag) &&