fs: Enhance read-only filesystem error notification mechanism

This update introduces a new function, deepin_check_and_notify_ro_fs_err_paths, which allows for error notifications to be sent for multiple paths during filesystem operations. The existing error notification system has been refactored to improve clarity and efficiency, including the integration of a notifier chain for OverlayFS errors.

Key changes:
- Added support for notifying about read-only filesystem errors during rename operations.
- Refactored error notification handling to utilize filesystem callbacks for improved modularity.
- Introduced a new header and source file for OverlayFS error notifications, allowing external modules to register for error notifications.

This enhancement aims to provide better error handling and notification capabilities for read-only filesystem operations.

Author: electricface

fs/deepin_err_notify.c

@@ -1,194 +1,133 @@
 // SPDX-License-Identifier: GPL-2.0
 /*
- * fs/deepin_ro_fs_err_notify.c - Deepin read-only filesystem error notification
+ * Deepin filesystem error notification
  *
- * This module provides notification functionality for read-only filesystem
- * errors, specifically targeting overlay filesystems mounted on /usr.
+ * This module provides notification functionality for filesystem errors,
+ * especially for read-only filesystem errors.
  */
 
 #include <linux/init.h>
 #include <linux/slab.h>
 #include <linux/fs.h>
-#include <linux/namei.h>
-#include <linux/mount.h>
 #include <linux/path.h>
 #include <linux/dcache.h>
-#include <linux/sched.h>
 #include <linux/printk.h>
-#include <linux/string.h>
 #include <linux/err.h>
-#include <linux/limits.h>
 #include <linux/sysctl.h>
-#include <linux/ratelimit.h>
-#include <linux/build_bug.h>
-#include <net/netlink.h>
-#include <net/genetlink.h>
 
 #include "internal.h"
-#include "mount.h"
-
-/* Family name (max GENL_NAMSIZ characters, including null terminator) */
-#define DEEPIN_ERR_NOTIFY_FAMILY_NAME "DEEPIN_ENOTIFY"
-
-/* Define netlink message types and attributes */
-enum {
-	DEEPIN_ERR_NOTIFY_ATTR_UNSPEC,
-	DEEPIN_ERR_NOTIFY_ATTR_FILENAME, /* Filename */
-	DEEPIN_ERR_NOTIFY_ATTR_PID, /* Process ID */
-	DEEPIN_ERR_NOTIFY_ATTR_COMM, /* Process Name */
-	DEEPIN_ERR_NOTIFY_ATTR_FUNC_NAME, /* Function Name */
-	__DEEPIN_ERR_NOTIFY_ATTR_MAX,
-};
-
-#define DEEPIN_ERR_NOTIFY_ATTR_MAX (__DEEPIN_ERR_NOTIFY_ATTR_MAX - 1)
-
-enum {
-	DEEPIN_ERR_NOTIFY_CMD_UNSPEC,
-	DEEPIN_ERR_NOTIFY_CMD_NOTIFY, /* Error Notify Command */
-	__DEEPIN_ERR_NOTIFY_CMD_MAX,
-};
-
-#define DEEPIN_ERR_NOTIFY_CMD_MAX (__DEEPIN_ERR_NOTIFY_CMD_MAX - 1)
-
-/* Track deepin error notification initialization status */
-static bool deepin_err_notify_initialized __read_mostly;
 
 /* Runtime control variable for deepin error notification */
 static int deepin_err_notify_enable __read_mostly = 0;
 
 int deepin_err_notify_enabled(void)
 {
-	return deepin_err_notify_initialized && deepin_err_notify_enable;
+	return deepin_err_notify_enable;
 }
 
+/* Rate limiting: allow 100 calls per 5 seconds */
+static DEFINE_RATELIMIT_STATE(deepin_ro_fs_err_ratelimit,
+			      5 * HZ, /* 5 seconds interval */
+			      100); /* 100 calls per interval */
+
 /* Check if overlay filesystem is mounted on /usr and send read only error notification */
 void deepin_check_and_notify_ro_fs_err(const struct path *path,
 				       const char *func_name)
 {
 	char *path_buf = NULL;
-	char *full_path = "";
-	/* Rate limiting: allow 100 calls per 5 seconds */
-	static DEFINE_RATELIMIT_STATE(deepin_ro_fs_err_ratelimit,
-				      5 * HZ, /* 5 seconds interval */
-				      100); /* 100 calls per interval */
-
-	/* Check rate limit before proceeding */
-	if (!__ratelimit(&deepin_ro_fs_err_ratelimit))
-		return;
+	const char *filename = "";
 
-	/* Early return if path or path->mnt is invalid */
-	if (!path || !path->mnt || !path->mnt->mnt_sb)
+	/* Early return if path is invalid or filesystem doesn't implement the callback */
+	if (!path || !path->mnt || !path->mnt->mnt_sb ||
+	    !path->mnt->mnt_sb->s_op ||
+	    !path->mnt->mnt_sb->s_op->deepin_notify_error)
 		return;
 
-	/* Use filesystem callback to decide if notification should be sent.
-	 * If filesystem implements the callback, use it.
-	 */
-	if (path->mnt->mnt_sb->s_op &&
-	    path->mnt->mnt_sb->s_op->deepin_should_notify_error) {
-		if (!path->mnt->mnt_sb->s_op->deepin_should_notify_error(path->mnt->mnt_sb))
-			return;
-	} else {
-		/* If filesystem does not implement the callback, return immediately. */
+	/* Check rate limit before proceeding */
+	if (!__ratelimit(&deepin_ro_fs_err_ratelimit))
 		return;
-	}
 
-	/* Attempt to get the full path.
-	 * Dynamic allocation is used to avoid excessive frame size.
-	 */
+	/* Convert path to filename string */
 	if (path->dentry) {
 		path_buf = kmalloc(PATH_MAX, GFP_KERNEL);
 		if (path_buf) {
-			char *p = NULL;
-
-			p = d_path(path, path_buf, PATH_MAX);
+			char *p = d_path(path, path_buf, PATH_MAX);
 			if (!IS_ERR(p))
-				full_path = p;
+				filename = p;
 		}
 	}
 
-	deepin_send_ro_fs_err_notification(full_path, func_name);
-
+	/* Use filesystem callback to handle error notification */
+	path->mnt->mnt_sb->s_op->deepin_notify_error(
+		path->mnt->mnt_sb, &filename, 1, func_name);
 	kfree(path_buf);
 }
 
-/* Define multicast group */
-static const struct genl_multicast_group deepin_err_notify_nl_mcgrps[] = {
-	{
-		.name = "ro_fs_events",
-	},
-};
+/* Check multiple paths and send read-only error notification */
+void deepin_check_and_notify_ro_fs_err_paths(const struct path *path,
+					     const struct path *path_new,
+					     const char *func_name)
+{
+	char *path_bufs[2] = { NULL, NULL };
+	const char *filenames[2] = { "", "" };
+	int filename_count = 0;
+	const struct super_operations *s_op = NULL;
+	struct super_block *sb = NULL;
+	const struct path *paths[2] = { path, path_new };
+	int i;
+
+	/* First pass: find a filesystem that implements deepin_notify_error
+	 * Check both paths and use the first one that has the callback
+	 */
+	for (i = 0; i < 2; i++) {
+		if (!paths[i] || !paths[i]->mnt || !paths[i]->mnt->mnt_sb)
+			continue;
 
-/* Define Generic Netlink family */
-static struct genl_family deepin_err_notify_genl_family __ro_after_init = {
-	.module = THIS_MODULE,
-	.hdrsize = 0,
-	.name = DEEPIN_ERR_NOTIFY_FAMILY_NAME,
-	.version = 1,
-	.maxattr = DEEPIN_ERR_NOTIFY_ATTR_MAX,
-	.mcgrps = deepin_err_notify_nl_mcgrps,
-	.n_mcgrps = ARRAY_SIZE(deepin_err_notify_nl_mcgrps),
-};
+		sb = paths[i]->mnt->mnt_sb;
+		s_op = sb->s_op;
 
-/* Send read only filesystem error notification */
-void deepin_send_ro_fs_err_notification(const char *filename,
-					const char *func_name)
-{
-	pid_t pid = 0;
-	const char *comm = NULL;
-	int msg_size;
-	struct sk_buff *skb = NULL;
-	void *msg_head = NULL;
-	int error;
-
-	pid = current->pid;
-	comm = current->comm;
-
-	msg_size = nla_total_size(strlen(filename) + 1) +
-		   nla_total_size(sizeof(u32)) +
-		   nla_total_size(strlen(comm) + 1) +
-		   nla_total_size(strlen(func_name) + 1);
-
-	/* Use GFP_NOFS to avoid recursion in file system operations. */
-	skb = genlmsg_new(msg_size, GFP_NOFS);
-	if (!skb) {
-		pr_err("deepin_err_notify: Failed to allocate netlink message\n");
-		return;
-	}
+		if (s_op && s_op->deepin_notify_error) {
+			/* Found a filesystem with the callback */
+			break;
+		}
 
-	msg_head = genlmsg_put(skb, 0, 0, &deepin_err_notify_genl_family, 0,
-			       DEEPIN_ERR_NOTIFY_CMD_NOTIFY);
-	if (!msg_head) {
-		pr_err("deepin_err_notify: Failed to put netlink header\n");
-		goto err_out;
+		/* Reset for next iteration */
+		sb = NULL;
+		s_op = NULL;
 	}
 
-	error = nla_put_string(skb, DEEPIN_ERR_NOTIFY_ATTR_FILENAME, filename);
-	if (error)
-		goto attr_err_out;
-
-	error = nla_put_u32(skb, DEEPIN_ERR_NOTIFY_ATTR_PID, pid);
-	if (error)
-		goto attr_err_out;
+	/* Early return if no filesystem has the callback */
+	if (!s_op || !s_op->deepin_notify_error)
+		return;
 
-	error = nla_put_string(skb, DEEPIN_ERR_NOTIFY_ATTR_COMM, comm);
-	if (error)
-		goto attr_err_out;
+	/* Check rate limit before proceeding */
+	if (!__ratelimit(&deepin_ro_fs_err_ratelimit))
+		return;
 
-	error = nla_put_string(skb, DEEPIN_ERR_NOTIFY_ATTR_FUNC_NAME,
-			       func_name);
-	if (error)
-		goto attr_err_out;
+	/* Second pass: collect all valid filenames from both paths
+	 * Only allocate memory now that we know we'll use it
+	 */
+	for (i = 0; i < 2; i++) {
+		if (!paths[i] || !paths[i]->mnt || !paths[i]->mnt->mnt_sb || !paths[i]->dentry)
+			continue;
 
-	genlmsg_end(skb, msg_head);
+		path_bufs[i] = kmalloc(PATH_MAX, GFP_KERNEL);
+		if (path_bufs[i]) {
+			char *p = d_path(paths[i], path_bufs[i], PATH_MAX);
+			if (!IS_ERR(p))
+				filenames[filename_count++] = p;
+		}
+	}
 
-	/* Send multicast message. */
-	genlmsg_multicast(&deepin_err_notify_genl_family, skb, 0, 0, GFP_NOFS);
-	return;
+	/* Call the callback with collected filenames */
+	if (filename_count == 2) {
+		s_op->deepin_notify_error(sb, filenames, filename_count,
+					  func_name);
+	}
 
-attr_err_out:
-	pr_err("deepin_err_notify: Failed to add netlink attributes\n");
-err_out:
-	kfree_skb(skb);
+	/* Free allocated buffers */
+	for (i = 0; i < 2; i++)
+		kfree(path_bufs[i]);
 }
 
 /* sysctl table and initialization */
@@ -216,27 +155,11 @@ static void __init deepin_err_notify_sysctl_init(void)
 /* Deepin error notify initialization */
 static int __init deepin_err_notify_init(void)
 {
-	int error;
-
-	/* Compile-time check for family name length */
-	BUILD_BUG_ON(sizeof(DEEPIN_ERR_NOTIFY_FAMILY_NAME) > GENL_NAMSIZ);
-
-	error = genl_register_family(&deepin_err_notify_genl_family);
-	if (error) {
-		pr_err("deepin_err_notify: Failed to register Generic Netlink family: %d\n",
-		       error);
-		return error;
-	}
-
-	/* Set initialization success flag */
-	deepin_err_notify_initialized = true;
-
 	/* Initialize sysctl interface */
 	deepin_err_notify_sysctl_init();
-
-	pr_info("deepin_err_notify: Generic Netlink family registered successfully\n");
 	return 0;
 }
 
 /* Use fs_initcall to ensure initialization before file system operations */
 fs_initcall(deepin_err_notify_init);
+

fs/internal.h

@@ -69,8 +69,17 @@ int deepin_get_path_for_err_notify(int dfd, struct filename *name, struct path *
  */
 int deepin_err_notify_enabled(void);
 void deepin_check_and_notify_ro_fs_err(const struct path *path, const char *func_name);
+void deepin_check_and_notify_ro_fs_err_paths(const struct path *path, const struct path *path_new, const char *func_name);
 void deepin_send_ro_fs_err_notification(const char *filename, const char *func_name);
 
+#ifdef CONFIG_DEEPIN_ERR_NOTIFY
+/* Check if error is EROFS and notification is enabled */
+#define deepin_should_notify_ro_fs_err(error) \
+	unlikely((error) == -EROFS && deepin_err_notify_enabled())
+#else
+#define deepin_should_notify_ro_fs_err(error) 0
+#endif /* CONFIG_DEEPIN_ERR_NOTIFY */
+
 /*
  * namespace.c
  */

fs/ioctl.c

@@ -903,10 +903,8 @@ SYSCALL_DEFINE3(ioctl, unsigned int, fd, unsigned int, cmd, unsigned long, arg)
 	if (error == -ENOIOCTLCMD)
 		error = vfs_ioctl(f.file, cmd, arg);
 
-#ifdef CONFIG_DEEPIN_ERR_NOTIFY
-	if (unlikely((error == -EROFS) && deepin_err_notify_enabled()))
+	if (deepin_should_notify_ro_fs_err(error))
 		deepin_check_and_notify_ro_fs_err(&f.file->f_path, "ioctl");
-#endif /* CONFIG_DEEPIN_ERR_NOTIFY */
 
 out:
 	fdput(f);