À l'origine, il fait partie du code source du noyau Linux, il sera donc traité comme GPLv2 (reconnaissance qu'il devrait l'être).
https://www.kernel.org/doc/html/latest/index.html
Licensing documentation
The following describes the license of the Linux kernel source code (GPLv2), how to properly mark the license of individual files in the source tree, as well as links to the full license text.
https://www.kernel.org/doc/html/latest/process/license-rules.html#kernel-licensing
https://www.kernel.org/doc/html/latest/vm/page_frags.html
Page fragments
A page fragment is an arbitrary-length arbitrary-offset area of memory which resides within a 0 or higher order compound page. Multiple fragments within that page are individually refcounted, in the page’s reference counter.
Un fragment de page est une zone de mémoire de n'importe quelle longueur, avec n'importe quel décalage, et existe dans une page composite de 0 ou plus. Plusieurs fragments sont référencés individuellement et comptés dans le compteur de références de page.
The page_frag functions, page_frag_alloc and page_frag_free, provide a simple allocation framework for page fragments. This is used by the network stack and network device drivers to provide a backing region of memory for use as either an sk_buff->head, or to be used in the “frags” portion of skb_shared_info.
Les fonctions page_flag de page_frag_alloc et page_frag_free fournissent un cadre d'allocation simple pour les fragments de page. Ceci est utilisé par les piles réseau et les pilotes de périphériques réseau pour fournir une région de sauvegarde de la mémoire pour sk_buff-> head. Il est également utilisé dans la position «frags» de skb_shared_info.
In order to make use of the page fragment APIs a backing page fragment cache is needed. This provides a central point for the fragment allocation and tracks allows multiple calls to make use of a cached page. The advantage to doing this is that multiple calls to get_page can be avoided which can be expensive at allocation time. However due to the nature of this caching it is required that any calls to the cache be protected by either a per-cpu limitation, or a per-cpu limitation and forcing interrupts to be disabled when executing the fragment allocation.
Le cache de fragment de page de sauvegarde est requis pour utiliser l'API de fragment de page. Il fournit une position centrale pour l'allocation de fragments et rend les pages mises en cache disponibles dans plusieurs appels. L'avantage de ceci est que vous pouvez éviter plusieurs appels à get_page. Il est très coûteux de gagner du temps. Cependant, en raison de la nature de ce cache, les appels au cache doivent soit protéger le cache avec des limites par processeur, soit des limites par processeur et désactiver de force les interruptions lors de l'allocation de fragments.
The network stack uses two separate caches per CPU to handle fragment allocation. The netdev_alloc_cache is used by callers making use of the __netdev_alloc_frag and __netdev_alloc_skb calls. The napi_alloc_cache is used by callers of the __napi_alloc_frag and __napi_alloc_skb calls. The main difference between these two calls is the context in which they may be called. The “netdev” prefixed functions are usable in any context as these functions will disable interrupts, while the “napi” prefixed functions are only usable within the softirq context.
La pile réseau utilise deux caches différents pour chaque CPU pour contrôler l'allocation des fragments. netdrv_alloc_cache est utilisé par les appelants dont les appelants appellent __netdev_alloc_frag ou __net_dev_alloc_skg. napi_alloc_cache est utilisé par l'appelant lors de l'appel de __napi_alloc_frag et __napi_alloc_skb. La principale différence entre les deux appels est le contexte dans lequel ils sont appelés. La fonction de préfixe "netdev" désactive les interruptions et peut être utilisée dans n'importe quel contexte. En revanche, la fonction de préfixe [napi] n'est disponible que dans le contexte softirq.
Many network device drivers use a similar methodology for allocating page fragments, but the page fragments are cached at the ring or descriptor level. In order to enable these cases it is necessary to provide a generic way of tearing down a page cache. For this reason __page_frag_cache_drain was implemented. It allows for freeing multiple references from a single page via a single call. The advantage to doing this is that it allows for cleaning up the multiple references that were added to a page in order to avoid calling get_page per allocation.
De nombreux pilotes de périphériques réseau utilisent une méthode similaire pour allouer des fragments de page. Cependant, le marquage de page est mis en cache au niveau du lien ou du descripteur. Pour activer ces cas, vous devez fournir un moyen général de détruire le cache de pages.
Pour cette raison, __pagE_frag_cache_drain a été introduit. Il vous permet de libérer plusieurs références à partir d'une seule page avec un seul appel. L'avantage de faire cela est que vous n'appelez pas get_page sur le devoir, vous pouvez donc nettoyer plusieurs références ajoutées à la page.
Alexander Duyck, Nov 29, 2016.