write in 30M

hc

2024-02-20 ea08eeccae9297f7aabd2ef7f0c2517ac4549acc

 kernel/fs/fuse/xattr.c
..
..
@@ -14,29 +14,29 @@
14
14
 int fuse_setxattr(struct inode *inode, const char *name, const void *value,
15
15
 		  size_t size, int flags)
16
16
 {
17
-	struct fuse_conn *fc = get_fuse_conn(inode);
17
+	struct fuse_mount *fm = get_fuse_mount(inode);
18
18
 	FUSE_ARGS(args);
19
19
 	struct fuse_setxattr_in inarg;
20
20
 	int err;
21
21
 
22
-	if (fc->no_setxattr)
22
+	if (fm->fc->no_setxattr)
23
23
 		return -EOPNOTSUPP;
24
24
 
25
25
 	memset(&inarg, 0, sizeof(inarg));
26
26
 	inarg.size = size;
27
27
 	inarg.flags = flags;
28
-	args.in.h.opcode = FUSE_SETXATTR;
29
-	args.in.h.nodeid = get_node_id(inode);
30
-	args.in.numargs = 3;
31
-	args.in.args[0].size = sizeof(inarg);
32
-	args.in.args[0].value = &inarg;
33
-	args.in.args[1].size = strlen(name) + 1;
34
-	args.in.args[1].value = name;
35
-	args.in.args[2].size = size;
36
-	args.in.args[2].value = value;
37
-	err = fuse_simple_request(fc, &args);
28
+	args.opcode = FUSE_SETXATTR;
29
+	args.nodeid = get_node_id(inode);
30
+	args.in_numargs = 3;
31
+	args.in_args[0].size = sizeof(inarg);
32
+	args.in_args[0].value = &inarg;
33
+	args.in_args[1].size = strlen(name) + 1;
34
+	args.in_args[1].value = name;
35
+	args.in_args[2].size = size;
36
+	args.in_args[2].value = value;
37
+	err = fuse_simple_request(fm, &args);
38
38
 	if (err == -ENOSYS) {
39
-		fc->no_setxattr = 1;
39
+		fm->fc->no_setxattr = 1;
40
40
 		err = -EOPNOTSUPP;
41
41
 	}
42
42
 	if (!err) {
..
..
@@ -49,39 +49,39 @@
49
49
 ssize_t fuse_getxattr(struct inode *inode, const char *name, void *value,
50
50
 		      size_t size)
51
51
 {
52
-	struct fuse_conn *fc = get_fuse_conn(inode);
52
+	struct fuse_mount *fm = get_fuse_mount(inode);
53
53
 	FUSE_ARGS(args);
54
54
 	struct fuse_getxattr_in inarg;
55
55
 	struct fuse_getxattr_out outarg;
56
56
 	ssize_t ret;
57
57
 
58
-	if (fc->no_getxattr)
58
+	if (fm->fc->no_getxattr)
59
59
 		return -EOPNOTSUPP;
60
60
 
61
61
 	memset(&inarg, 0, sizeof(inarg));
62
62
 	inarg.size = size;
63
-	args.in.h.opcode = FUSE_GETXATTR;
64
-	args.in.h.nodeid = get_node_id(inode);
65
-	args.in.numargs = 2;
66
-	args.in.args[0].size = sizeof(inarg);
67
-	args.in.args[0].value = &inarg;
68
-	args.in.args[1].size = strlen(name) + 1;
69
-	args.in.args[1].value = name;
63
+	args.opcode = FUSE_GETXATTR;
64
+	args.nodeid = get_node_id(inode);
65
+	args.in_numargs = 2;
66
+	args.in_args[0].size = sizeof(inarg);
67
+	args.in_args[0].value = &inarg;
68
+	args.in_args[1].size = strlen(name) + 1;
69
+	args.in_args[1].value = name;
70
70
 	/* This is really two different operations rolled into one */
71
-	args.out.numargs = 1;
71
+	args.out_numargs = 1;
72
72
 	if (size) {
73
-		args.out.argvar = 1;
74
-		args.out.args[0].size = size;
75
-		args.out.args[0].value = value;
73
+		args.out_argvar = true;
74
+		args.out_args[0].size = size;
75
+		args.out_args[0].value = value;
76
76
 	} else {
77
-		args.out.args[0].size = sizeof(outarg);
78
-		args.out.args[0].value = &outarg;
77
+		args.out_args[0].size = sizeof(outarg);
78
+		args.out_args[0].value = &outarg;
79
79
 	}
80
-	ret = fuse_simple_request(fc, &args);
80
+	ret = fuse_simple_request(fm, &args);
81
81
 	if (!ret && !size)
82
82
 		ret = min_t(ssize_t, outarg.size, XATTR_SIZE_MAX);
83
83
 	if (ret == -ENOSYS) {
84
-		fc->no_getxattr = 1;
84
+		fm->fc->no_getxattr = 1;
85
85
 		ret = -EOPNOTSUPP;
86
86
 	}
87
87
 	return ret;
..
..
@@ -107,7 +107,7 @@
107
107
 ssize_t fuse_listxattr(struct dentry *entry, char *list, size_t size)
108
108
 {
109
109
 	struct inode *inode = d_inode(entry);
110
-	struct fuse_conn *fc = get_fuse_conn(inode);
110
+	struct fuse_mount *fm = get_fuse_mount(inode);
111
111
 	FUSE_ARGS(args);
112
112
 	struct fuse_getxattr_in inarg;
113
113
 	struct fuse_getxattr_out outarg;
..
..
@@ -116,36 +116,36 @@
116
116
 	if (fuse_is_bad(inode))
117
117
 		return -EIO;
118
118
 
119
-	if (!fuse_allow_current_process(fc))
119
+	if (!fuse_allow_current_process(fm->fc))
120
120
 		return -EACCES;
121
121
 
122
-	if (fc->no_listxattr)
122
+	if (fm->fc->no_listxattr)
123
123
 		return -EOPNOTSUPP;
124
124
 
125
125
 	memset(&inarg, 0, sizeof(inarg));
126
126
 	inarg.size = size;
127
-	args.in.h.opcode = FUSE_LISTXATTR;
128
-	args.in.h.nodeid = get_node_id(inode);
129
-	args.in.numargs = 1;
130
-	args.in.args[0].size = sizeof(inarg);
131
-	args.in.args[0].value = &inarg;
127
+	args.opcode = FUSE_LISTXATTR;
128
+	args.nodeid = get_node_id(inode);
129
+	args.in_numargs = 1;
130
+	args.in_args[0].size = sizeof(inarg);
131
+	args.in_args[0].value = &inarg;
132
132
 	/* This is really two different operations rolled into one */
133
-	args.out.numargs = 1;
133
+	args.out_numargs = 1;
134
134
 	if (size) {
135
-		args.out.argvar = 1;
136
-		args.out.args[0].size = size;
137
-		args.out.args[0].value = list;
135
+		args.out_argvar = true;
136
+		args.out_args[0].size = size;
137
+		args.out_args[0].value = list;
138
138
 	} else {
139
-		args.out.args[0].size = sizeof(outarg);
140
-		args.out.args[0].value = &outarg;
139
+		args.out_args[0].size = sizeof(outarg);
140
+		args.out_args[0].value = &outarg;
141
141
 	}
142
-	ret = fuse_simple_request(fc, &args);
142
+	ret = fuse_simple_request(fm, &args);
143
143
 	if (!ret && !size)
144
144
 		ret = min_t(ssize_t, outarg.size, XATTR_LIST_MAX);
145
145
 	if (ret > 0 && size)
146
146
 		ret = fuse_verify_xattr_list(list, ret);
147
147
 	if (ret == -ENOSYS) {
148
-		fc->no_listxattr = 1;
148
+		fm->fc->no_listxattr = 1;
149
149
 		ret = -EOPNOTSUPP;
150
150
 	}
151
151
 	return ret;
..
..
@@ -153,21 +153,21 @@
153
153
 
154
154
 int fuse_removexattr(struct inode *inode, const char *name)
155
155
 {
156
-	struct fuse_conn *fc = get_fuse_conn(inode);
156
+	struct fuse_mount *fm = get_fuse_mount(inode);
157
157
 	FUSE_ARGS(args);
158
158
 	int err;
159
159
 
160
-	if (fc->no_removexattr)
160
+	if (fm->fc->no_removexattr)
161
161
 		return -EOPNOTSUPP;
162
162
 
163
-	args.in.h.opcode = FUSE_REMOVEXATTR;
164
-	args.in.h.nodeid = get_node_id(inode);
165
-	args.in.numargs = 1;
166
-	args.in.args[0].size = strlen(name) + 1;
167
-	args.in.args[0].value = name;
168
-	err = fuse_simple_request(fc, &args);
163
+	args.opcode = FUSE_REMOVEXATTR;
164
+	args.nodeid = get_node_id(inode);
165
+	args.in_numargs = 1;
166
+	args.in_args[0].size = strlen(name) + 1;
167
+	args.in_args[0].value = name;
168
+	err = fuse_simple_request(fm, &args);
169
169
 	if (err == -ENOSYS) {
170
-		fc->no_removexattr = 1;
170
+		fm->fc->no_removexattr = 1;
171
171
 		err = -EOPNOTSUPP;
172
172
 	}
173
173
 	if (!err) {
..
..
@@ -179,7 +179,7 @@
179
179
 
180
180
 static int fuse_xattr_get(const struct xattr_handler *handler,
181
181
 			 struct dentry *dentry, struct inode *inode,
182
-			 const char *name, void *value, size_t size)
182
+			 const char *name, void *value, size_t size, int flags)
183
183
 {
184
184
 	if (fuse_is_bad(inode))
185
185
 		return -EIO;
..
..
@@ -208,7 +208,7 @@
208
208
 
209
209
 static int no_xattr_get(const struct xattr_handler *handler,
210
210
 			struct dentry *dentry, struct inode *inode,
211
-			const char *name, void *value, size_t size)
211
+			const char *name, void *value, size_t size, int flags)
212
212
 {
213
213
 	return -EOPNOTSUPP;
214
214
 }