tools/testing/selftests/mm/hugetlb_dio.c

Source file repositories/reference/linux-study-clean/tools/testing/selftests/mm/hugetlb_dio.c

File Facts

System
Linux kernel
Corpus path
tools/testing/selftests/mm/hugetlb_dio.c
Extension
.c
Size
4754 bytes
Lines
173
Domain
Support Tooling And Documentation
Bucket
tools
Inferred role
Support Tooling And Documentation: implementation source
Status
source implementation candidate

Why This File Exists

Repository support layer: documentation, build tooling, samples, user-space helper tools, generated initramfs support, licenses, and validation utilities.

Dependency Surface

Detected Declarations

Annotated Snippet

// SPDX-License-Identifier: GPL-2.0
/*
 * This program tests for hugepage leaks after DIO writes to a file using a
 * hugepage as the user buffer. During DIO, the user buffer is pinned and
 * should be properly unpinned upon completion. This patch verifies that the
 * kernel correctly unpins the buffer at DIO completion for both aligned and
 * unaligned user buffer offsets (w.r.t page boundary), ensuring the hugepage
 * is freed upon unmapping.
 */

#define _GNU_SOURCE
#include <stdio.h>
#include <sys/stat.h>
#include <stdlib.h>
#include <fcntl.h>
#include <stdint.h>
#include <unistd.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/syscall.h>
#include "vm_util.h"
#include "kselftest.h"

#ifndef STATX_DIOALIGN
#define STATX_DIOALIGN		0x00002000U
#endif

static int get_dio_alignment(int fd)
{
	struct statx stx;
	int ret;

	ret = syscall(__NR_statx, fd, "", AT_EMPTY_PATH, STATX_DIOALIGN, &stx);
	if (ret < 0)
		return -1;

	/*
	 * If STATX_DIOALIGN is unsupported, assume no alignment
	 * constraint and let the test proceed.
	 */
	if (!(stx.stx_mask & STATX_DIOALIGN) || !stx.stx_dio_offset_align)
		return 1;

	return stx.stx_dio_offset_align;
}

static bool check_dio_alignment(unsigned int start_off,
				unsigned int end_off, unsigned int align)
{
	unsigned int writesize = end_off - start_off;

	/*
	 * The kernel's DIO path checks that file offset, length, and
	 * buffer address are all multiples of dio_offset_align.  When
	 * this test case's parameters don't satisfy that, the write
	 * would fail with -EINVAL before exercising the hugetlb unpin
	 * path, so skip.
	 */
	if (start_off % align != 0 || writesize % align != 0) {
		ksft_test_result_skip("DIO align=%u incompatible with offset %u writesize %u\n",
				align, start_off, writesize);
		return false;
	}

	return true;
}

static void run_dio_using_hugetlb(int fd, unsigned int start_off,
				unsigned int end_off, unsigned int align)
{
	char *buffer =  NULL;
	char *orig_buffer = NULL;
	size_t h_pagesize = 0;
	size_t writesize;
	int free_hpage_b = 0;
	int free_hpage_a = 0;
	const int mmap_flags = MAP_PRIVATE | MAP_ANONYMOUS | MAP_HUGETLB;
	const int mmap_prot  = PROT_READ | PROT_WRITE;

	if (!check_dio_alignment(start_off, end_off, align))
		return;

	writesize = end_off - start_off;

	/* Get the default huge page size */
	h_pagesize = default_huge_page_size();
	if (!h_pagesize)
		ksft_exit_fail_msg("Unable to determine huge page size\n");

	/* Reset file position since fd is shared across tests */

Annotation

Implementation Notes