util: implement simple iova tree (eecf5eed) · Commits · SUMMER2020 / students / proj-2021291

MAINTAINERS

+6 −0

Original line number	Diff line number	Diff line
		@@ -1783,6 +1783,12 @@ F: include/sysemu/replay.h
		F: docs/replay.txt
		F: stubs/replay.c

		IOVA Tree
		M: Peter Xu <peterx@redhat.com>
		S: Maintained
		F: include/qemu/iova-tree.h
		F: util/iova-tree.c

		Usermode Emulation
		------------------
		Overall

include/qemu/iova-tree.h

0 → 100644

+134 −0

Original line number	Diff line number	Diff line
		/*
		* An very simplified iova tree implementation based on GTree.
		*
		* Copyright 2018 Red Hat, Inc.
		*
		* Authors:
		* Peter Xu <peterx@redhat.com>
		*
		* This work is licensed under the terms of the GNU GPL, version 2 or later.
		*/
		#ifndef IOVA_TREE_H
		#define IOVA_TREE_H

		/*
		* Currently the iova tree will only allow to keep ranges
		* information, and no extra user data is allowed for each element. A
		* benefit is that we can merge adjacent ranges internally within the
		* tree. It can save a lot of memory when the ranges are splitted but
		* mostly continuous.
		*
		* Note that current implementation does not provide any thread
		* protections. Callers of the iova tree should be responsible
		* for the thread safety issue.
		*/

		#include "qemu/osdep.h"
		#include "exec/memory.h"
		#include "exec/hwaddr.h"

		#define IOVA_OK (0)
		#define IOVA_ERR_INVALID (-1) /* Invalid parameters */
		#define IOVA_ERR_OVERLAP (-2) /* IOVA range overlapped */

		typedef struct IOVATree IOVATree;
		typedef struct DMAMap {
		hwaddr iova;
		hwaddr translated_addr;
		hwaddr size; /* Inclusive */
		IOMMUAccessFlags perm;
		} QEMU_PACKED DMAMap;
		typedef gboolean (iova_tree_iterator)(DMAMap map);

		/**
		* iova_tree_new:
		*
		* Create a new iova tree.
		*
		* Returns: the tree pointer when succeeded, or NULL if error.
		*/
		IOVATree *iova_tree_new(void);

		/**
		* iova_tree_insert:
		*
		* @tree: the iova tree to insert
		* @map: the mapping to insert
		*
		* Insert an iova range to the tree. If there is overlapped
		* ranges, IOVA_ERR_OVERLAP will be returned.
		*
		* Return: 0 if succeeded, or <0 if error.
		*/
		int iova_tree_insert(IOVATree tree, DMAMap map);

		/**
		* iova_tree_remove:
		*
		* @tree: the iova tree to remove range from
		* @map: the map range to remove
		*
		* Remove mappings from the tree that are covered by the map range
		* provided. The range does not need to be exactly what has inserted,
		* all the mappings that are included in the provided range will be
		* removed from the tree. Here map->translated_addr is meaningless.
		*
		* Return: 0 if succeeded, or <0 if error.
		*/
		int iova_tree_remove(IOVATree tree, DMAMap map);

		/**
		* iova_tree_find:
		*
		* @tree: the iova tree to search from
		* @map: the mapping to search
		*
		* Search for a mapping in the iova tree that overlaps with the
		* mapping range specified. Only the first found mapping will be
		* returned.
		*
		* Return: DMAMap pointer if found, or NULL if not found. Note that
		* the returned DMAMap pointer is maintained internally. User should
		* only read the content but never modify or free the content. Also,
		* user is responsible to make sure the pointer is valid (say, no
		* concurrent deletion in progress).
		*/
		DMAMap iova_tree_find(IOVATree tree, DMAMap *map);

		/**
		* iova_tree_find_address:
		*
		* @tree: the iova tree to search from
		* @iova: the iova address to find
		*
		* Similar to iova_tree_find(), but it tries to find mapping with
		* range iova=iova & size=0.
		*
		* Return: same as iova_tree_find().
		*/
		DMAMap iova_tree_find_address(IOVATree tree, hwaddr iova);

		/**
		* iova_tree_foreach:
		*
		* @tree: the iova tree to iterate on
		* @iterator: the interator for the mappings, return true to stop
		*
		* Iterate over the iova tree.
		*
		* Return: 1 if found any overlap, 0 if not, <0 if error.
		*/
		void iova_tree_foreach(IOVATree *tree, iova_tree_iterator iterator);

		/**
		* iova_tree_destroy:
		*
		* @tree: the iova tree to destroy
		*
		* Destroy an existing iova tree.
		*
		* Return: None.
		*/
		void iova_tree_destroy(IOVATree *tree);

		#endif

util/Makefile.objs

+1 −0

Original line number	Diff line number	Diff line
		@@ -47,4 +47,5 @@ util-obj-y += qht.o
		util-obj-y += range.o
		util-obj-y += stats64.o
		util-obj-y += systemd.o
		util-obj-y += iova-tree.o
		util-obj-$(CONFIG_LINUX) += vfio-helpers.o

util/iova-tree.c

0 → 100644

+114 −0

Original line number	Diff line number	Diff line
		/*
		* IOVA tree implementation based on GTree.
		*
		* Copyright 2018 Red Hat, Inc.
		*
		* Authors:
		* Peter Xu <peterx@redhat.com>
		*
		* This work is licensed under the terms of the GNU GPL, version 2 or later.
		*/

		#include <glib.h>
		#include "qemu/iova-tree.h"

		struct IOVATree {
		GTree *tree;
		};

		static int iova_tree_compare(gconstpointer a, gconstpointer b, gpointer data)
		{
		const DMAMap m1 = a, m2 = b;

		if (m1->iova > m2->iova + m2->size) {
		return 1;
		}

		if (m1->iova + m1->size < m2->iova) {
		return -1;
		}

		/* Overlapped */
		return 0;
		}

		IOVATree *iova_tree_new(void)
		{
		IOVATree *iova_tree = g_new0(IOVATree, 1);

		/* We don't have values actually, no need to free */
		iova_tree->tree = g_tree_new_full(iova_tree_compare, NULL, g_free, NULL);

		return iova_tree;
		}

		DMAMap iova_tree_find(IOVATree tree, DMAMap *map)
		{
		return g_tree_lookup(tree->tree, map);
		}

		DMAMap iova_tree_find_address(IOVATree tree, hwaddr iova)
		{
		DMAMap map = { .iova = iova, .size = 0 };

		return iova_tree_find(tree, &map);
		}

		static inline void iova_tree_insert_internal(GTree gtree, DMAMap range)
		{
		/* Key and value are sharing the same range data */
		g_tree_insert(gtree, range, range);
		}

		int iova_tree_insert(IOVATree tree, DMAMap map)
		{
		DMAMap *new;

		if (map->iova + map->size < map->iova \|\| map->perm == IOMMU_NONE) {
		return IOVA_ERR_INVALID;
		}

		/* We don't allow to insert range that overlaps with existings */
		if (iova_tree_find(tree, map)) {
		return IOVA_ERR_OVERLAP;
		}

		new = g_new0(DMAMap, 1);
		memcpy(new, map, sizeof(*new));
		iova_tree_insert_internal(tree->tree, new);

		return IOVA_OK;
		}

		static gboolean iova_tree_traverse(gpointer key, gpointer value,
		gpointer data)
		{
		iova_tree_iterator iterator = data;
		DMAMap *map = key;

		g_assert(key == value);

		return iterator(map);
		}

		void iova_tree_foreach(IOVATree *tree, iova_tree_iterator iterator)
		{
		g_tree_foreach(tree->tree, iova_tree_traverse, iterator);
		}

		int iova_tree_remove(IOVATree tree, DMAMap map)
		{
		DMAMap *overlap;

		while ((overlap = iova_tree_find(tree, map))) {
		g_tree_remove(tree->tree, overlap);
		}

		return IOVA_OK;
		}

		void iova_tree_destroy(IOVATree *tree)
		{
		g_tree_destroy(tree->tree);
		g_free(tree);
		}