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

@@ -27,29 +27,6 @@
 #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;
 
@@ -61,134 +38,112 @@ int deepin_err_notify_enabled(void)
 	return deepin_err_notify_initialized && 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",
-	},
-};
-
-/* 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),
-};
-
-/* Send read only filesystem error notification */
-void deepin_send_ro_fs_err_notification(const char *filename,
-					const char *func_name)
+/* 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)
 {
-	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;
-	}
+	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;
 
-	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;
-	}
+		sb = paths[i]->mnt->mnt_sb;
+		s_op = sb->s_op;
 
-	error = nla_put_string(skb, DEEPIN_ERR_NOTIFY_ATTR_FILENAME, filename);
-	if (error)
-		goto attr_err_out;
+		if (s_op && s_op->deepin_notify_error) {
+			/* Found a filesystem with the callback */
+			break;
+		}
 
-	error = nla_put_u32(skb, DEEPIN_ERR_NOTIFY_ATTR_PID, pid);
-	if (error)
-		goto attr_err_out;
+		/* Reset for next iteration */
+		sb = NULL;
+		s_op = NULL;
+	}
 
-	error = nla_put_string(skb, DEEPIN_ERR_NOTIFY_ATTR_COMM, comm);
-	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_FUNC_NAME,
-			       func_name);
-	if (error)
-		goto attr_err_out;
+	/* Check rate limit before proceeding */
+	if (!__ratelimit(&deepin_ro_fs_err_ratelimit))
+		return;
 
-	genlmsg_end(skb, msg_head);
+	/* 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)
+			continue;
+		
+		if (!paths[i]->dentry)
+			continue;
+
+		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 +171,14 @@ 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,6 +69,7 @@ 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);
 
 /*

fs/namei.c

@@ -5005,6 +5005,53 @@ int vfs_rename(struct renamedata *rd)
 }
 EXPORT_SYMBOL(vfs_rename);
 
+#ifdef CONFIG_DEEPIN_ERR_NOTIFY
+/*
+ * notify_rename_ro_fs_err - Notify read-only filesystem errors during rename
+ * @old_last: qstr for old filename
+ * @new_last: qstr for new filename
+ * @old_path: path of old parent directory
+ * @new_path: path of new parent directory
+ *
+ * This function is called when a rename operation fails with EROFS error.
+ * It attempts to look up the old and new paths and send error notification
+ * if both paths are valid.
+ */
+static void notify_rename_ro_fs_err(const struct qstr *old_last,
+				    const struct qstr *new_last,
+				    const struct path *old_path,
+				    const struct path *new_path)
+{
+	struct path old_file_path = { .mnt = NULL, .dentry = NULL };
+	struct path new_file_path = { .mnt = NULL, .dentry = NULL };
+	struct dentry *old_dentry_tmp = NULL;
+	struct dentry *new_dentry_tmp = NULL;
+
+	old_dentry_tmp = lookup_one_qstr_excl(old_last, old_path->dentry, 0);
+	if (!IS_ERR(old_dentry_tmp) && d_is_positive(old_dentry_tmp)) {
+		old_file_path.mnt = old_path->mnt;
+		old_file_path.dentry = old_dentry_tmp;
+	}
+
+	new_dentry_tmp = lookup_one_qstr_excl(new_last, new_path->dentry, 0);
+	if (!IS_ERR(new_dentry_tmp)) {
+		new_file_path.mnt = new_path->mnt;
+		new_file_path.dentry = new_dentry_tmp;
+	}
+
+	/* Call notification with both paths only if both are valid */
+	if (old_file_path.dentry && new_file_path.dentry) {
+		deepin_check_and_notify_ro_fs_err_paths(
+			&old_file_path, &new_file_path, "rename");
+	}
+
+	if (!IS_ERR(old_dentry_tmp))
+		dput(old_dentry_tmp);
+	if (!IS_ERR(new_dentry_tmp))
+		dput(new_dentry_tmp);
+}
+#endif /* CONFIG_DEEPIN_ERR_NOTIFY */
+
 int do_renameat2(int olddfd, struct filename *from, int newdfd,
 		 struct filename *to, unsigned int flags)
 {
@@ -5134,20 +5181,8 @@ int do_renameat2(int olddfd, struct filename *from, int newdfd,
 	mnt_drop_write(old_path.mnt);
 exit2:
 #ifdef CONFIG_DEEPIN_ERR_NOTIFY
-	if (unlikely((error == -EROFS) && deepin_err_notify_enabled())) {
-		old_dentry =
-			lookup_one_qstr_excl(&old_last, old_path.dentry, 0);
-		if (!IS_ERR(old_dentry)) {
-			if (d_is_positive(old_dentry)) {
-				struct path file_path = { .mnt = old_path.mnt,
-							  .dentry =
-								  old_dentry };
-				deepin_check_and_notify_ro_fs_err(&file_path,
-								  "rename");
-			}
-			dput(old_dentry);
-		}
-	}
+	if (unlikely((error == -EROFS) && deepin_err_notify_enabled()))
+		notify_rename_ro_fs_err(&old_last, &new_last, &old_path, &new_path);
 #endif /* CONFIG_DEEPIN_ERR_NOTIFY */
 	if (retry_estale(error, lookup_flags))
 		should_retry = true;

fs/overlayfs/Makefile

@@ -7,3 +7,7 @@ obj-$(CONFIG_OVERLAY_FS) += overlay.o
 
 overlay-objs := super.o namei.o util.o inode.o file.o dir.o readdir.o \
 		copy_up.o export.o params.o
+
+ifeq ($(CONFIG_DEEPIN_ERR_NOTIFY),y)
+overlay-objs += deepin_ovl_err_notify.o
+endif