fs: Enhanced error notification mechanism for read-only filesystems

- Added handling for the two paths that need to be reported in the
rename system call.
- Introduced a new macro `deepin_should_notify_ro_fs_err` to simplify
error-checking code.
- Collect more detailed information when an error occurs.
- Replaced the `/proc/sys/fs/deepin-err-notify-enable` file with
multiple netlink commands.
- Reverted modifications to overlayfs; the `deepin_err_notify`
mount option is no longer available.

Link: #1268
Signed-off-by: electricface <[email protected]>

Author: electricface

fs/deepin_err_notify.c

@@ -62,14 +62,35 @@ int do_mkdirat(int dfd, struct filename *name, umode_t mode);
 int do_symlinkat(struct filename *from, int newdfd, struct filename *to);
 int do_linkat(int olddfd, struct filename *old, int newdfd,
 			struct filename *new, int flags);
-int deepin_get_path_for_err_notify(int dfd, struct filename *name, struct path *result_path);
+struct deepin_path_last {
+	struct path path;
+	const char *last;
+};
+
+int deepin_lookup_path_or_parent(int dfd, struct filename *name,
+				 unsigned int flags,
+				 struct deepin_path_last *result_path_last);
 
 /*
  * deepin_err_notify.c
  */
 int deepin_err_notify_enabled(void);
-void deepin_check_and_notify_ro_fs_err(const struct path *path, const char *func_name);
-void deepin_send_ro_fs_err_notification(const char *filename, const char *func_name);
+int deepin_err_notify_should_send(void);
+void deepin_check_and_notify_ro_fs_err(const struct deepin_path_last *path_last,
+					const char *func_name);
+void deepin_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);
+void deepin_put_path_last(struct deepin_path_last *path_last);
+
+#ifdef CONFIG_DEEPIN_ERR_NOTIFY
+/* Check if error is EROFS and notification should be sent */
+#define deepin_should_notify_ro_fs_err(error) \
+	unlikely((error) == -EROFS && deepin_err_notify_should_send())
+#else
+#define deepin_should_notify_ro_fs_err(error) 0
+#endif /* CONFIG_DEEPIN_ERR_NOTIFY */
 
 /*
  * namespace.c

fs/internal.h

@@ -903,10 +903,13 @@ 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()))
-		deepin_check_and_notify_ro_fs_err(&f.file->f_path, "ioctl");
-#endif /* CONFIG_DEEPIN_ERR_NOTIFY */
+	if (deepin_should_notify_ro_fs_err(error)) {
+		struct deepin_path_last tmp_path_last = {
+			.path = f.file->f_path,
+			.last = NULL
+		};
+		deepin_check_and_notify_ro_fs_err(&tmp_path_last, "ioctl");
+	}
 
 out:
 	fdput(f);

fs/ioctl.c

@@ -4073,19 +4073,14 @@ static int do_mknodat(int dfd, struct filename *name, umode_t mode,
 		goto retry;
 	}
 out1:
-#ifdef CONFIG_DEEPIN_ERR_NOTIFY
-	if (unlikely((error == -EROFS) && deepin_err_notify_enabled())) {
-		struct path file_path;
-		int get_path_err;
-
-		get_path_err =
-			deepin_get_path_for_err_notify(dfd, name, &file_path);
-		if (!get_path_err) {
-			deepin_check_and_notify_ro_fs_err(&file_path, "mknod");
-			path_put(&file_path);
+	if (deepin_should_notify_ro_fs_err(error)) {
+		struct deepin_path_last path_last;
+
+		if (!deepin_lookup_path_or_parent(dfd, name, lookup_flags, &path_last)) {
+			deepin_check_and_notify_ro_fs_err(&path_last, "mknod");
+			deepin_put_path_last(&path_last);
 		}
 	}
-#endif /* CONFIG_DEEPIN_ERR_NOTIFY */
 	putname(name);
 	return error;
 }
@@ -4169,19 +4164,14 @@ int do_mkdirat(int dfd, struct filename *name, umode_t mode)
 		goto retry;
 	}
 out_putname:
-#ifdef CONFIG_DEEPIN_ERR_NOTIFY
-	if (unlikely((error == -EROFS) && deepin_err_notify_enabled())) {
-		struct path file_path;
-		int get_path_err;
-
-		get_path_err =
-			deepin_get_path_for_err_notify(dfd, name, &file_path);
-		if (!get_path_err) {
-			deepin_check_and_notify_ro_fs_err(&file_path, "mkdir");
-			path_put(&file_path);
+	if (deepin_should_notify_ro_fs_err(error)) {
+		struct deepin_path_last path_last;
+
+		if (!deepin_lookup_path_or_parent(dfd, name, lookup_flags, &path_last)) {
+			deepin_check_and_notify_ro_fs_err(&path_last, "mkdir");
+			deepin_put_path_last(&path_last);
 		}
 	}
-#endif /* CONFIG_DEEPIN_ERR_NOTIFY */
 	putname(name);
 	return error;
 }
@@ -4299,21 +4289,18 @@ int do_rmdir(int dfd, struct filename *name)
 	inode_unlock(path.dentry->d_inode);
 	mnt_drop_write(path.mnt);
 exit2:
-#ifdef CONFIG_DEEPIN_ERR_NOTIFY
-	if (unlikely((error == -EROFS) && deepin_err_notify_enabled())) {
-		dentry = lookup_one_qstr_excl(&last, path.dentry, 0);
-		if (!IS_ERR(dentry)) {
-			if (d_is_positive(dentry)) {
-				// dentry is positive, so we can get the path
-				struct path file_path = { .mnt = path.mnt,
-							  .dentry = dentry };
-				deepin_check_and_notify_ro_fs_err(&file_path,
+	if (deepin_should_notify_ro_fs_err(error)) {
+		struct deepin_path_last path_last;
+
+		if (!deepin_lookup_path_or_parent(dfd, name, lookup_flags, &path_last)) {
+			if (!path_last.last) {
+				// File exists, notify error
+				deepin_check_and_notify_ro_fs_err(&path_last,
 								  "rmdir");
 			}
-			dput(dentry);
+			deepin_put_path_last(&path_last);
 		}
 	}
-#endif /* CONFIG_DEEPIN_ERR_NOTIFY */
 	path_put(&path);
 	if (retry_estale(error, lookup_flags)) {
 		lookup_flags |= LOOKUP_REVAL;
@@ -4459,21 +4446,18 @@ int do_unlinkat(int dfd, struct filename *name)
 	}
 	mnt_drop_write(path.mnt);
 exit2:
-#ifdef CONFIG_DEEPIN_ERR_NOTIFY
-	if (unlikely((error == -EROFS) && deepin_err_notify_enabled())) {
-		dentry = lookup_one_qstr_excl(&last, path.dentry, 0);
-		if (!IS_ERR(dentry)) {
-			if (d_is_positive(dentry)) {
-				// dentry is positive, so we can get the path
-				struct path file_path = { .mnt = path.mnt,
-							  .dentry = dentry };
-				deepin_check_and_notify_ro_fs_err(&file_path,
+	if (deepin_should_notify_ro_fs_err(error)) {
+		struct deepin_path_last path_last;
+
+		if (!deepin_lookup_path_or_parent(dfd, name, lookup_flags, &path_last)) {
+			if (!path_last.last) {
+				// File exists, notify error
+				deepin_check_and_notify_ro_fs_err(&path_last,
 								  "unlink");
 			}
-			dput(dentry);
+			deepin_put_path_last(&path_last);
 		}
 	}
-#endif /* CONFIG_DEEPIN_ERR_NOTIFY */
 	path_put(&path);
 	if (retry_estale(error, lookup_flags)) {
 		lookup_flags |= LOOKUP_REVAL;
@@ -4574,20 +4558,15 @@ int do_symlinkat(struct filename *from, int newdfd, struct filename *to)
 		goto retry;
 	}
 out_putnames:
-#ifdef CONFIG_DEEPIN_ERR_NOTIFY
-	if (unlikely((error == -EROFS) && deepin_err_notify_enabled())) {
-		struct path file_path;
-		int get_path_err;
-
-		get_path_err =
-			deepin_get_path_for_err_notify(newdfd, to, &file_path);
-		if (!get_path_err) {
-			deepin_check_and_notify_ro_fs_err(&file_path,
+	if (deepin_should_notify_ro_fs_err(error)) {
+		struct deepin_path_last path_last;
+
+		if (!deepin_lookup_path_or_parent(newdfd, to, lookup_flags, &path_last)) {
+			deepin_check_and_notify_ro_fs_err(&path_last,
 							  "symlink");
-			path_put(&file_path);
+			deepin_put_path_last(&path_last);
 		}
 	}
-#endif /* CONFIG_DEEPIN_ERR_NOTIFY */
 	putname(to);
 	putname(from);
 	return error;
@@ -4766,19 +4745,14 @@ int do_linkat(int olddfd, struct filename *old, int newdfd,
 		goto retry;
 	}
 out_putpath:
-#ifdef CONFIG_DEEPIN_ERR_NOTIFY
-	if (unlikely((error == -EROFS) && deepin_err_notify_enabled())) {
-		struct path file_path;
-		int get_path_err;
-
-		get_path_err =
-			deepin_get_path_for_err_notify(newdfd, new, &file_path);
-		if (!get_path_err) {
-			deepin_check_and_notify_ro_fs_err(&file_path, "link");
-			path_put(&file_path);
+	if (deepin_should_notify_ro_fs_err(error)) {
+		struct deepin_path_last path_last;
+
+		if (!deepin_lookup_path_or_parent(newdfd, new, how, &path_last)) {
+			deepin_check_and_notify_ro_fs_err(&path_last, "link");
+			deepin_put_path_last(&path_last);
 		}
 	}
-#endif /* CONFIG_DEEPIN_ERR_NOTIFY */
 	path_put(&old_path);
 out_putnames:
 	putname(old);
@@ -5133,22 +5107,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);
-		}
-	}
-#endif /* CONFIG_DEEPIN_ERR_NOTIFY */
+	if (deepin_should_notify_ro_fs_err(error))
+		deepin_notify_rename_ro_fs_err(&old_last, &new_last, &old_path, &new_path);
 	if (retry_estale(error, lookup_flags))
 		should_retry = true;
 	path_put(&new_path);
@@ -5368,37 +5328,76 @@ const struct inode_operations page_symlink_inode_operations = {
 EXPORT_SYMBOL(page_symlink_inode_operations);
 
 #ifdef CONFIG_DEEPIN_ERR_NOTIFY
-int deepin_get_path_for_err_notify(int dfd, struct filename *name,
-				   struct path *result_path)
+/**
+ * deepin_lookup_path_or_parent - Prepare path info for read-only FS error notification
+ * @dfd: Directory file descriptor used as lookup base
+ * @name: Filename to look up (struct filename)
+ * @flags: Lookup flags (e.g., LOOKUP_DIRECTORY, LOOKUP_FOLLOW)
+ * @result_path_last: Output structure carrying the resolved parent path and
+ *                    optionally the last component string
+ *
+ * Memory/Lifetime management:
+ * - result_path_last->path:
+ *   The path returned by filename_lookup() or filename_parentat() already
+ *   holds a reference count. You MUST release it after use. Preferred:
+ *   deepin_put_path_last(&pl), which will call path_put() for you.
+ *   Alternatively, call path_put() manually if you manage the string separately.
+ *
+ * - result_path_last->last:
+ *   In the -ENOENT (parent found) case, the last component string is duplicated
+ *   via kstrdup() and MUST be freed with kfree(). deepin_put_path_last(&pl)
+ *   will free it for you. If the full path was resolved, this field is set
+ *   to NULL and no extra string free is needed.
+ *
+ * Recommended usage pattern:
+ *   struct deepin_path_last pl;
+ *   if (!deepin_lookup_path_or_parent(dfd, name, lookup_flags, &pl)) {
+ *       deepin_check_and_notify_ro_fs_err(&pl, "op");
+ *       deepin_put_path_last(&pl); // releases path and frees pl.last if allocated
+ *   }
+ *
+ * Return: 0 on success, negative errno on failure.
+ */
+int deepin_lookup_path_or_parent(int dfd, struct filename *name,
+				 unsigned int flags,
+				 struct deepin_path_last *result_path_last)
 {
+	struct path result_path;
+	struct path parent;
 	struct qstr last;
-	struct path parent_path;
 	int type;
-	struct dentry *dentry;
 	int error;
 
-	error = filename_parentat(dfd, name, 0, &parent_path, &last, &type);
+	error = filename_lookup(dfd, name, flags, &result_path, NULL);
+	if (error == -ENOENT) {
+		error = filename_parentat(dfd, name, flags, &parent, &last, &type);
+		if (error)
+			return error;
+		if (unlikely(type != LAST_NORM)) {
+			path_put(&parent);
+			return -EINVAL;
+		}
+		/* Duplicate the filename string to avoid dangling pointer */
+		result_path_last->last = kstrdup((const char *)last.name, GFP_KERNEL);
+		if (!result_path_last->last) {
+			path_put(&parent);
+			return -ENOMEM;
+		}
+		result_path_last->path = parent;
+		return 0;
+	}
+
 	if (error)
 		return error;
 
-	dentry = lookup_one_qstr_excl(&last, parent_path.dentry, 0);
-	if (!IS_ERR(dentry)) {
-		result_path->mnt = parent_path.mnt;
-		result_path->dentry = dentry;
-		path_get(result_path); // Increment reference count
-		dput(dentry);
-	} else {
-		// If the file does not exist, use the parent directory
-		*result_path = parent_path;
-		path_get(result_path);
-	}
-
-	path_put(&parent_path);
+	result_path_last->last = NULL;
+	result_path_last->path = result_path;
 	return 0;
 }
 #else
-int deepin_get_path_for_err_notify(int dfd, struct filename *name,
-				   struct path *result_path)
+int deepin_lookup_path_or_parent(int dfd, struct filename *name,
+				 unsigned int flags,
+				 struct deepin_path_last *result_path_last)
 {
 	return -EOPNOTSUPP;
 }