testcases/kernel/syscalls/fanotify/fanotify15.c - platform/external/ltp - Git at Google

 // SPDX-License-Identifier: GPL-2.0-or-later
 /*
  * Copyright (c) 2019 CTERA Networks. All Rights Reserved.
  *
  * Started by Amir Goldstein <amir73il@gmail.com>
  * Modified by Matthew Bobrowski <mbobrowski@mbobrowski.org>
  *
  * DESCRIPTION
  *	Test file that has been purposely designed to verify
  *	FAN_REPORT_FID functionality while using newly defined dirent
  *	events.
  */
 #define _GNU_SOURCE
 #include "config.h"

 #include <string.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <sys/statfs.h>
 #include <sys/types.h>

 #include "tst_test.h"
 #include "fanotify.h"

 #if defined(HAVE_SYS_FANOTIFY_H)
 #include <sys/fanotify.h>

 #define BUF_SIZE 256
 #define EVENT_MAX 256

 #define MOUNT_POINT "mntpoint"
 #define TEST_DIR MOUNT_POINT"/test_dir"
 #define DIR1 TEST_DIR"/dir1"
 #define DIR2 TEST_DIR"/dir2"
 #define FILE1 TEST_DIR"/file1"
 #define FILE2 TEST_DIR"/file2"

 #if defined(HAVE_NAME_TO_HANDLE_AT)
 struct event_t {
 	unsigned long long mask;
 	__kernel_fsid_t fsid;
 	struct file_handle handle;
 	char buf[MAX_HANDLE_SZ];
 };

 static int fanotify_fd;
 static char events_buf[BUF_SIZE];
 static struct event_t event_set[EVENT_MAX];

 static void do_test(void)
 {
 	int i, fd, len, count = 0;

 	struct file_handle *event_file_handle;
 	struct fanotify_event_metadata *metadata;
 	struct fanotify_event_info_fid *event_fid;

 	if (fanotify_mark(fanotify_fd, FAN_MARK_ADD | FAN_MARK_FILESYSTEM,
 				FAN_CREATE | FAN_DELETE | FAN_ATTRIB |
 				FAN_MOVED_FROM | FAN_MOVED_TO |
 				FAN_DELETE_SELF | FAN_ONDIR,
 				AT_FDCWD, TEST_DIR) == -1) {
 		if (errno == ENODEV)
 			tst_brk(TCONF,
 				"FAN_REPORT_FID not supported on %s "
 				"filesystem", tst_device->fs_type);
 		tst_brk(TBROK | TERRNO,
 			"fanotify_mark(%d, FAN_MARK_ADD, FAN_CREATE | "
 			"FAN_DELETE | FAN_MOVED_FROM | FAN_MOVED_TO | "
 			"FAN_DELETE_SELF | FAN_ONDIR, AT_FDCWD, %s) failed",
 			fanotify_fd, TEST_DIR);
 	}

 	/* Generate a sequence of events */
 	event_set[count].mask = FAN_CREATE | FAN_MOVED_FROM | FAN_MOVED_TO | \
 				FAN_DELETE;
 	event_set[count].handle.handle_bytes = MAX_HANDLE_SZ;
 	fanotify_get_fid(TEST_DIR, &event_set[count].fsid,
 			 &event_set[count].handle);
 	count++;

 	fd = SAFE_CREAT(FILE1, 0644);
 	SAFE_CLOSE(fd);

 	SAFE_RENAME(FILE1, FILE2);

 	event_set[count].mask = FAN_ATTRIB | FAN_DELETE_SELF;
 	event_set[count].handle.handle_bytes = MAX_HANDLE_SZ;
 	fanotify_get_fid(FILE2, &event_set[count].fsid,
 			 &event_set[count].handle);
 	count++;

 	SAFE_UNLINK(FILE2);

 	/*
 	 * Generate a sequence of events on a directory. Subsequent events
 	 * are merged, so it's required that we set FAN_ONDIR once in
 	 * order to acknowledge that changes related to a subdirectory
 	 * took place. Events on subdirectories are not merged with events
 	 * on non-subdirectories.
 	 */
 	event_set[count].mask = FAN_ONDIR | FAN_CREATE | FAN_MOVED_FROM | \
 				FAN_MOVED_TO | FAN_DELETE;
 	event_set[count].handle.handle_bytes = MAX_HANDLE_SZ;
 	fanotify_get_fid(TEST_DIR, &event_set[count].fsid,
 			 &event_set[count].handle);
 	count++;

 	SAFE_MKDIR(DIR1, 0755);

 	SAFE_RENAME(DIR1, DIR2);

 	event_set[count].mask = FAN_ONDIR | FAN_DELETE_SELF;
 	event_set[count].handle.handle_bytes = MAX_HANDLE_SZ;
 	fanotify_get_fid(DIR2, &event_set[count].fsid,
 			 &event_set[count].handle);
 	count++;

 	SAFE_RMDIR(DIR2);

 	/* Read events from the event queue */
 	len = SAFE_READ(0, fanotify_fd, events_buf, BUF_SIZE);

 	/* Process each event in buffer */
 	for (i = 0, metadata = (struct fanotify_event_metadata *) events_buf;
 		FAN_EVENT_OK(metadata, len);
 		metadata = FAN_EVENT_NEXT(metadata,len), i++) {
 		event_fid = (struct fanotify_event_info_fid *) (metadata + 1);
 		event_file_handle = (struct file_handle *) event_fid->handle;

 		if (i >= count) {
 			tst_res(TFAIL,
 				"got unnecessary event: mask=%llx "
 				"pid=%u fd=%d",
 				(unsigned long long) metadata->mask,
 				metadata->pid,
 				metadata->fd);
 			metadata->mask = 0;
 		} else if (metadata->fd != FAN_NOFD) {
 			tst_res(TFAIL,
 				"Received unexpected file descriptor %d in "
 				"event. Expected to get FAN_NOFD(%d)",
 				metadata->fd, FAN_NOFD);
 		} else if (metadata->mask != event_set[i].mask) {
 			tst_res(TFAIL,
 				"Got event: mask=%llx (expected %llx) "
 				"pid=%u fd=%d",
 				(unsigned long long) metadata->mask,
 				event_set[i].mask,
 				(unsigned) metadata->pid,
 				metadata->fd);
 		} else if (metadata->pid != getpid()) {
 			tst_res(TFAIL,
 				"Got event: mask=%llx pid=%u "
 				"(expected %u) fd=%d",
 				(unsigned long long) metadata->mask,
 				(unsigned) metadata->pid,
 				(unsigned) getpid(),
 				metadata->fd);
 		} else if (event_file_handle->handle_bytes !=
 				event_set[i].handle.handle_bytes) {
 			tst_res(TFAIL,
 				"Got event: handle_bytes (%x) returned in "
 				"event does not equal handle_bytes (%x) "
 				"retunred in name_to_handle_at(2)",
 				event_file_handle->handle_bytes,
 				event_set[i].handle.handle_bytes);
 		} else if (event_file_handle->handle_type !=
 				event_set[i].handle.handle_type) {
 			tst_res(TFAIL,
 				"handle_type (%x) returned in event does not "
 				"equal to handle_type (%x) returned in "
 				"name_to_handle_at(2)",
 				event_file_handle->handle_type,
 				event_set[i].handle.handle_type);
 		} else if (memcmp(event_file_handle->f_handle,
 					event_set[i].handle.f_handle,
 					event_set[i].handle.handle_bytes)
 					!= 0) {
 			tst_res(TFAIL,
 				"event_file_handle->f_handle does not match "
 				"handle.f_handle returned in "
 				"name_to_handle_at(2)");
 		} else if (memcmp(&event_fid->fsid, &event_set[i].fsid,
 					sizeof(event_set[i].fsid)) != 0) {
 			tst_res(TFAIL,
 				"event_fid->fsid != stats.f_fsid that was "
 				"obtained via statfs(2)");
 		} else {
 			tst_res(TPASS,
 				"Got event: mask=%llx, pid=%u, "
 				"fid=%x.%x.%lx values",
 				metadata->mask,
 				getpid(),
 				FSID_VAL_MEMBER(event_fid->fsid, 0),
 				FSID_VAL_MEMBER(event_fid->fsid, 1),
 				*(unsigned long *)
 				event_file_handle->f_handle);
 		}
 	}

 	for (; i < count; i++)
 		tst_res(TFAIL,
 			"Didn't receive event: mask=%llx",
 			event_set[i].mask);
 }

 static void do_setup(void)
 {
 	int fd;

 	/* Check kernel for fanotify support */
 	fd = SAFE_FANOTIFY_INIT(FAN_CLASS_NOTIF, O_RDONLY);
 	SAFE_CLOSE(fd);

 	fanotify_fd = fanotify_init(FAN_REPORT_FID, O_RDONLY);
 	if (fanotify_fd == -1) {
 		if (errno == EINVAL)
 			tst_brk(TCONF,
 				"FAN_REPORT_FID not supported in kernel");
 		tst_brk(TBROK | TERRNO,
 			"fanotify_init(FAN_REPORT_FID, O_RDONLY) failed");
 	}

 	SAFE_MKDIR(TEST_DIR, 0755);
 }

 static void do_cleanup(void)
 {
 	if (fanotify_fd > 0)
 		SAFE_CLOSE(fanotify_fd);
 }

 static struct tst_test test = {
 	.needs_root = 1,
 	.mount_device = 1,
 	.mntpoint = MOUNT_POINT,
 	.all_filesystems = 1,
 	.test_all = do_test,
 	.setup = do_setup,
 	.cleanup = do_cleanup
 };

 #else
 	TST_TEST_TCONF("System does not have required name_to_handle_at() support");
 #endif
 #else
 	TST_TEST_TCONF("System does not have required fanotify support");
 #endif
	// SPDX-License-Identifier: GPL-2.0-or-later
	/*
	* Copyright (c) 2019 CTERA Networks. All Rights Reserved.
	*
	* Started by Amir Goldstein <amir73il@gmail.com>
	* Modified by Matthew Bobrowski <mbobrowski@mbobrowski.org>
	*
	* DESCRIPTION
	* Test file that has been purposely designed to verify
	* FAN_REPORT_FID functionality while using newly defined dirent
	* events.
	*/
	#define _GNU_SOURCE
	#include "config.h"

	#include <string.h>
	#include <errno.h>
	#include <fcntl.h>
	#include <sys/statfs.h>
	#include <sys/types.h>

	#include "tst_test.h"
	#include "fanotify.h"

	#if defined(HAVE_SYS_FANOTIFY_H)
	#include <sys/fanotify.h>

	#define BUF_SIZE 256
	#define EVENT_MAX 256

	#define MOUNT_POINT "mntpoint"
	#define TEST_DIR MOUNT_POINT"/test_dir"
	#define DIR1 TEST_DIR"/dir1"
	#define DIR2 TEST_DIR"/dir2"
	#define FILE1 TEST_DIR"/file1"
	#define FILE2 TEST_DIR"/file2"

	#if defined(HAVE_NAME_TO_HANDLE_AT)
	struct event_t {
	unsigned long long mask;
	__kernel_fsid_t fsid;
	struct file_handle handle;
	char buf[MAX_HANDLE_SZ];
	};

	static int fanotify_fd;
	static char events_buf[BUF_SIZE];
	static struct event_t event_set[EVENT_MAX];

	static void do_test(void)
	{
	int i, fd, len, count = 0;

	struct file_handle *event_file_handle;
	struct fanotify_event_metadata *metadata;
	struct fanotify_event_info_fid *event_fid;

	if (fanotify_mark(fanotify_fd, FAN_MARK_ADD \| FAN_MARK_FILESYSTEM,
	FAN_CREATE \| FAN_DELETE \| FAN_ATTRIB \|
	FAN_MOVED_FROM \| FAN_MOVED_TO \|
	FAN_DELETE_SELF \| FAN_ONDIR,
	AT_FDCWD, TEST_DIR) == -1) {
	if (errno == ENODEV)
	tst_brk(TCONF,
	"FAN_REPORT_FID not supported on %s "
	"filesystem", tst_device->fs_type);
	tst_brk(TBROK \| TERRNO,
	"fanotify_mark(%d, FAN_MARK_ADD, FAN_CREATE \| "
	"FAN_DELETE \| FAN_MOVED_FROM \| FAN_MOVED_TO \| "
	"FAN_DELETE_SELF \| FAN_ONDIR, AT_FDCWD, %s) failed",
	fanotify_fd, TEST_DIR);
	}

	/* Generate a sequence of events */
	event_set[count].mask = FAN_CREATE \| FAN_MOVED_FROM \| FAN_MOVED_TO \| \
	FAN_DELETE;
	event_set[count].handle.handle_bytes = MAX_HANDLE_SZ;
	fanotify_get_fid(TEST_DIR, &event_set[count].fsid,
	&event_set[count].handle);
	count++;

	fd = SAFE_CREAT(FILE1, 0644);
	SAFE_CLOSE(fd);

	SAFE_RENAME(FILE1, FILE2);

	event_set[count].mask = FAN_ATTRIB \| FAN_DELETE_SELF;
	event_set[count].handle.handle_bytes = MAX_HANDLE_SZ;
	fanotify_get_fid(FILE2, &event_set[count].fsid,
	&event_set[count].handle);
	count++;

	SAFE_UNLINK(FILE2);

	/*
	* Generate a sequence of events on a directory. Subsequent events
	* are merged, so it's required that we set FAN_ONDIR once in
	* order to acknowledge that changes related to a subdirectory
	* took place. Events on subdirectories are not merged with events
	* on non-subdirectories.
	*/
	event_set[count].mask = FAN_ONDIR \| FAN_CREATE \| FAN_MOVED_FROM \| \
	FAN_MOVED_TO \| FAN_DELETE;
	event_set[count].handle.handle_bytes = MAX_HANDLE_SZ;
	fanotify_get_fid(TEST_DIR, &event_set[count].fsid,
	&event_set[count].handle);
	count++;

	SAFE_MKDIR(DIR1, 0755);

	SAFE_RENAME(DIR1, DIR2);

	event_set[count].mask = FAN_ONDIR \| FAN_DELETE_SELF;
	event_set[count].handle.handle_bytes = MAX_HANDLE_SZ;
	fanotify_get_fid(DIR2, &event_set[count].fsid,
	&event_set[count].handle);
	count++;

	SAFE_RMDIR(DIR2);

	/* Read events from the event queue */
	len = SAFE_READ(0, fanotify_fd, events_buf, BUF_SIZE);

	/* Process each event in buffer */
	for (i = 0, metadata = (struct fanotify_event_metadata *) events_buf;
	FAN_EVENT_OK(metadata, len);
	metadata = FAN_EVENT_NEXT(metadata,len), i++) {
	event_fid = (struct fanotify_event_info_fid *) (metadata + 1);
	event_file_handle = (struct file_handle *) event_fid->handle;

	if (i >= count) {
	tst_res(TFAIL,
	"got unnecessary event: mask=%llx "
	"pid=%u fd=%d",
	(unsigned long long) metadata->mask,
	metadata->pid,
	metadata->fd);
	metadata->mask = 0;
	} else if (metadata->fd != FAN_NOFD) {
	tst_res(TFAIL,
	"Received unexpected file descriptor %d in "
	"event. Expected to get FAN_NOFD(%d)",
	metadata->fd, FAN_NOFD);
	} else if (metadata->mask != event_set[i].mask) {
	tst_res(TFAIL,
	"Got event: mask=%llx (expected %llx) "
	"pid=%u fd=%d",
	(unsigned long long) metadata->mask,
	event_set[i].mask,
	(unsigned) metadata->pid,
	metadata->fd);
	} else if (metadata->pid != getpid()) {
	tst_res(TFAIL,
	"Got event: mask=%llx pid=%u "
	"(expected %u) fd=%d",
	(unsigned long long) metadata->mask,
	(unsigned) metadata->pid,
	(unsigned) getpid(),
	metadata->fd);
	} else if (event_file_handle->handle_bytes !=
	event_set[i].handle.handle_bytes) {
	tst_res(TFAIL,
	"Got event: handle_bytes (%x) returned in "
	"event does not equal handle_bytes (%x) "
	"retunred in name_to_handle_at(2)",
	event_file_handle->handle_bytes,
	event_set[i].handle.handle_bytes);
	} else if (event_file_handle->handle_type !=
	event_set[i].handle.handle_type) {
	tst_res(TFAIL,
	"handle_type (%x) returned in event does not "
	"equal to handle_type (%x) returned in "
	"name_to_handle_at(2)",
	event_file_handle->handle_type,
	event_set[i].handle.handle_type);
	} else if (memcmp(event_file_handle->f_handle,
	event_set[i].handle.f_handle,
	event_set[i].handle.handle_bytes)
	!= 0) {
	tst_res(TFAIL,
	"event_file_handle->f_handle does not match "
	"handle.f_handle returned in "
	"name_to_handle_at(2)");
	} else if (memcmp(&event_fid->fsid, &event_set[i].fsid,
	sizeof(event_set[i].fsid)) != 0) {
	tst_res(TFAIL,
	"event_fid->fsid != stats.f_fsid that was "
	"obtained via statfs(2)");
	} else {
	tst_res(TPASS,
	"Got event: mask=%llx, pid=%u, "
	"fid=%x.%x.%lx values",
	metadata->mask,
	getpid(),
	FSID_VAL_MEMBER(event_fid->fsid, 0),
	FSID_VAL_MEMBER(event_fid->fsid, 1),
	(unsigned long )
	event_file_handle->f_handle);
	}
	}

	for (; i < count; i++)
	tst_res(TFAIL,
	"Didn't receive event: mask=%llx",
	event_set[i].mask);
	}

	static void do_setup(void)
	{
	int fd;

	/* Check kernel for fanotify support */
	fd = SAFE_FANOTIFY_INIT(FAN_CLASS_NOTIF, O_RDONLY);
	SAFE_CLOSE(fd);

	fanotify_fd = fanotify_init(FAN_REPORT_FID, O_RDONLY);
	if (fanotify_fd == -1) {
	if (errno == EINVAL)
	tst_brk(TCONF,
	"FAN_REPORT_FID not supported in kernel");
	tst_brk(TBROK \| TERRNO,
	"fanotify_init(FAN_REPORT_FID, O_RDONLY) failed");
	}

	SAFE_MKDIR(TEST_DIR, 0755);
	}

	static void do_cleanup(void)
	{
	if (fanotify_fd > 0)
	SAFE_CLOSE(fanotify_fd);
	}

	static struct tst_test test = {
	.needs_root = 1,
	.mount_device = 1,
	.mntpoint = MOUNT_POINT,
	.all_filesystems = 1,
	.test_all = do_test,
	.setup = do_setup,
	.cleanup = do_cleanup
	};

	#else
	TST_TEST_TCONF("System does not have required name_to_handle_at() support");
	#endif
	#else
	TST_TEST_TCONF("System does not have required fanotify support");
	#endif