Gecko [ www.thearyasamaj.org ]

Name	Size	Permission
audit_user.h	145 B	-rw-r--r--
fsnotify_events.c	3.5 KB	-rw-r--r--
fsnotify_events.h	353 B	-rw-r--r--
fsnotify_listener.c	9.61 KB	-rw-r--r--
fsnotify_listener.h	1.09 KB	-rw-r--r--
ftrace_events.c	15.25 KB	-rw-r--r--
ftrace_events.h	625 B	-rw-r--r--

Code Editor : fsnotify_events.c

/**
@file     fsnotify_events.h
@brief    fsnotify events
@details  Copyright (c) 2024 Acronis International GmbH
@author   Denis Kopyrin (denis.kopyrin@acronis.com)
@since    $Id: $
*/

#include "fsnotify_events.h"

#include <linux/fsnotify.h>
#include <linux/fsnotify_backend.h>

#include "fs_event.h"
#include "lsm_common.h"
#include "path_tools.h"
#include "task_info_map.h"
#include "task_tools.h"

static void send_fsnotify_event(const struct inode* inode, uint64_t flags)
{
	task_info_t* task_info;
	transport_ids_t transport_ids;
	msg_type_t type;
	file_key_t key;

if (flags & FS_CREATE)
		type = FP_SI_OT_NOTIFY_FSNOTIFY_CREATE;

if (flags & (FS_DELETE | FS_DELETE_SELF))
		type = FP_SI_OT_NOTIFY_FSNOTIFY_UNLINK;

if (flags & FS_MOVE_SELF)
		type = FP_SI_OT_NOTIFY_FSNOTIFY_RENAME;

if (flags & FS_OPEN)
		type = FP_SI_OT_NOTIFY_FSNOTIFY_OPEN;

if (!(transport_global_get_combined_mask() & MSG_TYPE_TO_EVENT_MASK(type)))
		return;

task_info = task_info_map_get(current);
	if (!task_info)
		return;

transport_global_get_ids(&transport_ids);
	if (task_info_can_skip(task_info, &transport_ids, MSG_TYPE_TO_EVENT_MASK(type)))
		goto out;

make_key_from_inode(&key, inode);
	fs_event_fsnotify(task_info, &key, flags, type);

out:
	task_info_put(task_info);
}

static const struct inode *fsnotify_event_handler_to_inode(const void *data, int data_type)
{
	if (!data)
		return NULL;

switch (data_type)
	{
		case FSNOTIFY_EVENT_PATH:
		{
			const struct path *path = (const struct path *)data;
			const struct dentry* dentry = path->dentry;
			if (!dentry)
				return NULL;

return dentry->d_inode;
		}
		case FSNOTIFY_EVENT_INODE:
		{
			return (const struct inode *)data;
		}
#ifdef HAVE_FSNOTIFY_EVENT_DENTRY
		case FSNOTIFY_EVENT_DENTRY:
		{
			const struct dentry *dentry = (const struct dentry *)data;
			return dentry->d_inode;
		}
#endif
		default:
			return NULL;
	}
}

static void pre_close(const struct path *path, bool modified)
{
	task_info_t* task_info;
	transport_ids_t transport_ids;
	int flags = modified ? O_RDWR : O_RDONLY;
	const uint64_t generatedEventsMask = MSG_TYPE_TO_EVENT_MASK(FP_SI_OT_SYNC_FILE_PRE_CLOSE)
	                                   | MSG_TYPE_TO_EVENT_MASK(FP_SI_OT_NOTIFY_FILE_PRE_CLOSE);

if (!(transport_global_get_combined_mask() & generatedEventsMask)
	   || transport_is_control_tgid(current->tgid)) {
		return;
	}

task_info = task_info_map_get(current);
	if (!task_info)
		return;

transport_global_get_ids(&transport_ids);
	refresh_task(task_info, &transport_ids);

if (task_info_can_skip(task_info, &transport_ids, generatedEventsMask))
		goto err_skipped;

if (!path_is_valid(path))
		goto err_skipped;

DPRINTF("calling fs_event_pre_close(flags=0o%o/0x%x)", flags, flags);
	fs_event_pre_close(task_info, flags, path);
	DPRINTF("finished fs_event_pre_close(flags=0o%o/0x%x)", flags, flags);

err_skipped:
	task_info_put(task_info);
}

void handle_fsnotify_event(u32 mask, const void *data, int data_type)
{
	const struct inode* child;
	uint32_t want_mask;
	if (data_type == FSNOTIFY_EVENT_PATH && (mask & (FS_CLOSE_NOWRITE | FS_CLOSE_WRITE)))
	{
		const struct path *path = (const struct path *)data;
		return pre_close(path, (mask & FS_CLOSE_WRITE) != 0);
	}

want_mask = wanted_fsnotify_events();
	if (!(mask & want_mask))
		return;

child = fsnotify_event_handler_to_inode(data, data_type);

if (!inode_is_valid(child))
		return;

send_fsnotify_event(child, mask);
	if (mask & (FS_DELETE_SELF | FS_CREATE))
	{
		file_key_t key;
		make_key_from_inode(&key, child);
		remove_common_cache_all(&key);
	}
}

${this.title}

Code Editor : fsnotify_events.c