forked from ~ljy/RK356X_SDK_RELEASE

blame | history | patch | commit | commitdiff
hc
2024-10-22 8ac6c7a54ed1b98d142dce24b11c6de6a1e239a5 
 kernel/fs/kernfs/inode.c
....@@ -1,11 +1,10 @@
1
+// SPDX-License-Identifier: GPL-2.0-only
12 /*
23  * fs/kernfs/inode.c - kernfs inode implementation
34  *
45  * Copyright (c) 2001-3 Patrick Mochel
56  * Copyright (c) 2007 SUSE Linux Products GmbH
67  * Copyright (c) 2007, 2013 Tejun Heo <tj@kernel.org>
7
- *
8
- * This file is released under the GPLv2.
98  */
109 
1110 #include <linux/pagemap.h>
....@@ -31,64 +30,68 @@
3130 	.listxattr	= kernfs_iop_listxattr,
3231 };
3332 
34
-static struct kernfs_iattrs *kernfs_iattrs(struct kernfs_node *kn)
33
+static struct kernfs_iattrs *__kernfs_iattrs(struct kernfs_node *kn, int alloc)
3534 {
3635 	static DEFINE_MUTEX(iattr_mutex);
3736 	struct kernfs_iattrs *ret;
38
-	struct iattr *iattrs;
3937 
4038 	mutex_lock(&iattr_mutex);
4139 
42
-	if (kn->iattr)
40
+	if (kn->iattr || !alloc)
4341 		goto out_unlock;
4442 
45
-	kn->iattr = kzalloc(sizeof(struct kernfs_iattrs), GFP_KERNEL);
43
+	kn->iattr = kmem_cache_zalloc(kernfs_iattrs_cache, GFP_KERNEL);
4644 	if (!kn->iattr)
4745 		goto out_unlock;
48
-	iattrs = &kn->iattr->ia_iattr;
4946 
5047 	/* assign default attributes */
51
-	iattrs->ia_mode = kn->mode;
52
-	iattrs->ia_uid = GLOBAL_ROOT_UID;
53
-	iattrs->ia_gid = GLOBAL_ROOT_GID;
48
+	kn->iattr->ia_uid = GLOBAL_ROOT_UID;
49
+	kn->iattr->ia_gid = GLOBAL_ROOT_GID;
5450 
55
-	ktime_get_real_ts64(&iattrs->ia_atime);
56
-	iattrs->ia_mtime = iattrs->ia_atime;
57
-	iattrs->ia_ctime = iattrs->ia_atime;
51
+	ktime_get_real_ts64(&kn->iattr->ia_atime);
52
+	kn->iattr->ia_mtime = kn->iattr->ia_atime;
53
+	kn->iattr->ia_ctime = kn->iattr->ia_atime;
5854 
5955 	simple_xattrs_init(&kn->iattr->xattrs);
56
+	atomic_set(&kn->iattr->nr_user_xattrs, 0);
57
+	atomic_set(&kn->iattr->user_xattr_size, 0);
6058 out_unlock:
6159 	ret = kn->iattr;
6260 	mutex_unlock(&iattr_mutex);
6361 	return ret;
6462 }
6563 
64
+static struct kernfs_iattrs *kernfs_iattrs(struct kernfs_node *kn)
65
+{
66
+	return __kernfs_iattrs(kn, 1);
67
+}
68
+
69
+static struct kernfs_iattrs *kernfs_iattrs_noalloc(struct kernfs_node *kn)
70
+{
71
+	return __kernfs_iattrs(kn, 0);
72
+}
73
+
6674 int __kernfs_setattr(struct kernfs_node *kn, const struct iattr *iattr)
6775 {
6876 	struct kernfs_iattrs *attrs;
69
-	struct iattr *iattrs;
7077 	unsigned int ia_valid = iattr->ia_valid;
7178 
7279 	attrs = kernfs_iattrs(kn);
7380 	if (!attrs)
7481 		return -ENOMEM;
7582 
76
-	iattrs = &attrs->ia_iattr;
77
-
7883 	if (ia_valid & ATTR_UID)
79
-		iattrs->ia_uid = iattr->ia_uid;
84
+		attrs->ia_uid = iattr->ia_uid;
8085 	if (ia_valid & ATTR_GID)
81
-		iattrs->ia_gid = iattr->ia_gid;
86
+		attrs->ia_gid = iattr->ia_gid;
8287 	if (ia_valid & ATTR_ATIME)
83
-		iattrs->ia_atime = iattr->ia_atime;
88
+		attrs->ia_atime = iattr->ia_atime;
8489 	if (ia_valid & ATTR_MTIME)
85
-		iattrs->ia_mtime = iattr->ia_mtime;
90
+		attrs->ia_mtime = iattr->ia_mtime;
8691 	if (ia_valid & ATTR_CTIME)
87
-		iattrs->ia_ctime = iattr->ia_ctime;
88
-	if (ia_valid & ATTR_MODE) {
89
-		umode_t mode = iattr->ia_mode;
90
-		iattrs->ia_mode = kn->mode = mode;
91
-	}
92
+		attrs->ia_ctime = iattr->ia_ctime;
93
+	if (ia_valid & ATTR_MODE)
94
+		kn->mode = iattr->ia_mode;
9295 	return 0;
9396 }
9497 
....@@ -135,23 +138,6 @@
135138 	return error;
136139 }
137140 
138
-static int kernfs_node_setsecdata(struct kernfs_iattrs *attrs, void **secdata,
139
-				  u32 *secdata_len)
140
-{
141
-	void *old_secdata;
142
-	size_t old_secdata_len;
143
-
144
-	old_secdata = attrs->ia_secdata;
145
-	old_secdata_len = attrs->ia_secdata_len;
146
-
147
-	attrs->ia_secdata = *secdata;
148
-	attrs->ia_secdata_len = *secdata_len;
149
-
150
-	*secdata = old_secdata;
151
-	*secdata_len = old_secdata_len;
152
-	return 0;
153
-}
154
-
155141 ssize_t kernfs_iop_listxattr(struct dentry *dentry, char *buf, size_t size)
156142 {
157143 	struct kernfs_node *kn = kernfs_dentry_node(dentry);
....@@ -171,14 +157,14 @@
171157 		inode->i_ctime = current_time(inode);
172158 }
173159 
174
-static inline void set_inode_attr(struct inode *inode, struct iattr *iattr)
160
+static inline void set_inode_attr(struct inode *inode,
161
+				  struct kernfs_iattrs *attrs)
175162 {
176
-	struct super_block *sb = inode->i_sb;
177
-	inode->i_uid = iattr->ia_uid;
178
-	inode->i_gid = iattr->ia_gid;
179
-	inode->i_atime = timespec64_trunc(iattr->ia_atime, sb->s_time_gran);
180
-	inode->i_mtime = timespec64_trunc(iattr->ia_mtime, sb->s_time_gran);
181
-	inode->i_ctime = timespec64_trunc(iattr->ia_ctime, sb->s_time_gran);
163
+	inode->i_uid = attrs->ia_uid;
164
+	inode->i_gid = attrs->ia_gid;
165
+	inode->i_atime = attrs->ia_atime;
166
+	inode->i_mtime = attrs->ia_mtime;
167
+	inode->i_ctime = attrs->ia_ctime;
182168 }
183169 
184170 static void kernfs_refresh_inode(struct kernfs_node *kn, struct inode *inode)
....@@ -186,15 +172,12 @@
186172 	struct kernfs_iattrs *attrs = kn->iattr;
187173 
188174 	inode->i_mode = kn->mode;
189
-	if (attrs) {
175
+	if (attrs)
190176 		/*
191177 		 * kernfs_node has non-default attributes get them from
192178 		 * persistent copy in kernfs_node.
193179 		 */
194
-		set_inode_attr(inode, &attrs->ia_iattr);
195
-		security_inode_notifysecctx(inode, attrs->ia_secdata,
196
-					    attrs->ia_secdata_len);
197
-	}
180
+		set_inode_attr(inode, attrs);
198181 
199182 	if (kernfs_type(kn) == KERNFS_DIR)
200183 		set_nlink(inode, kn->dir.subdirs + 2);
....@@ -220,7 +203,7 @@
220203 	inode->i_private = kn;
221204 	inode->i_mapping->a_ops = &kernfs_aops;
222205 	inode->i_op = &kernfs_iops;
223
-	inode->i_generation = kn->id.generation;
206
+	inode->i_generation = kernfs_gen(kn);
224207 
225208 	set_default_inode_attr(inode, kn->mode);
226209 	kernfs_refresh_inode(kn, inode);
....@@ -266,7 +249,7 @@
266249 {
267250 	struct inode *inode;
268251 
269
-	inode = iget_locked(sb, kn->id.ino);
252
+	inode = iget_locked(sb, kernfs_ino(kn));
270253 	if (inode && (inode->i_state & I_NEW))
271254 		kernfs_init_inode(kn, inode);
272255 
....@@ -305,82 +288,149 @@
305288 	return generic_permission(inode, mask);
306289 }
307290 
308
-static int kernfs_xattr_get(const struct xattr_handler *handler,
309
-			    struct dentry *unused, struct inode *inode,
310
-			    const char *suffix, void *value, size_t size)
291
+int kernfs_xattr_get(struct kernfs_node *kn, const char *name,
292
+		     void *value, size_t size)
311293 {
312
-	const char *name = xattr_full_name(handler, suffix);
313
-	struct kernfs_node *kn = inode->i_private;
314
-	struct kernfs_iattrs *attrs;
315
-
316
-	attrs = kernfs_iattrs(kn);
294
+	struct kernfs_iattrs *attrs = kernfs_iattrs_noalloc(kn);
317295 	if (!attrs)
318
-		return -ENOMEM;
296
+		return -ENODATA;
319297 
320298 	return simple_xattr_get(&attrs->xattrs, name, value, size);
321299 }
322300 
323
-static int kernfs_xattr_set(const struct xattr_handler *handler,
324
-			    struct dentry *unused, struct inode *inode,
325
-			    const char *suffix, const void *value,
326
-			    size_t size, int flags)
301
+int kernfs_xattr_set(struct kernfs_node *kn, const char *name,
302
+		     const void *value, size_t size, int flags)
327303 {
328
-	const char *name = xattr_full_name(handler, suffix);
329
-	struct kernfs_node *kn = inode->i_private;
330
-	struct kernfs_iattrs *attrs;
331
-
332
-	attrs = kernfs_iattrs(kn);
304
+	struct kernfs_iattrs *attrs = kernfs_iattrs(kn);
333305 	if (!attrs)
334306 		return -ENOMEM;
335307 
336
-	return simple_xattr_set(&attrs->xattrs, name, value, size, flags);
308
+	return simple_xattr_set(&attrs->xattrs, name, value, size, flags, NULL);
337309 }
338310 
339
-static const struct xattr_handler kernfs_trusted_xattr_handler = {
340
-	.prefix = XATTR_TRUSTED_PREFIX,
341
-	.get = kernfs_xattr_get,
342
-	.set = kernfs_xattr_set,
343
-};
311
+static int kernfs_vfs_xattr_get(const struct xattr_handler *handler,
312
+				struct dentry *unused, struct inode *inode,
313
+				const char *suffix, void *value, size_t size,
314
+				int flags)
315
+{
316
+	const char *name = xattr_full_name(handler, suffix);
317
+	struct kernfs_node *kn = inode->i_private;
344318 
345
-static int kernfs_security_xattr_set(const struct xattr_handler *handler,
319
+	return kernfs_xattr_get(kn, name, value, size);
320
+}
321
+
322
+static int kernfs_vfs_xattr_set(const struct xattr_handler *handler,
323
+				struct dentry *unused, struct inode *inode,
324
+				const char *suffix, const void *value,
325
+				size_t size, int flags)
326
+{
327
+	const char *name = xattr_full_name(handler, suffix);
328
+	struct kernfs_node *kn = inode->i_private;
329
+
330
+	return kernfs_xattr_set(kn, name, value, size, flags);
331
+}
332
+
333
+static int kernfs_vfs_user_xattr_add(struct kernfs_node *kn,
334
+				     const char *full_name,
335
+				     struct simple_xattrs *xattrs,
336
+				     const void *value, size_t size, int flags)
337
+{
338
+	atomic_t *sz = &kn->iattr->user_xattr_size;
339
+	atomic_t *nr = &kn->iattr->nr_user_xattrs;
340
+	ssize_t removed_size;
341
+	int ret;
342
+
343
+	if (atomic_inc_return(nr) > KERNFS_MAX_USER_XATTRS) {
344
+		ret = -ENOSPC;
345
+		goto dec_count_out;
346
+	}
347
+
348
+	if (atomic_add_return(size, sz) > KERNFS_USER_XATTR_SIZE_LIMIT) {
349
+		ret = -ENOSPC;
350
+		goto dec_size_out;
351
+	}
352
+
353
+	ret = simple_xattr_set(xattrs, full_name, value, size, flags,
354
+			       &removed_size);
355
+
356
+	if (!ret && removed_size >= 0)
357
+		size = removed_size;
358
+	else if (!ret)
359
+		return 0;
360
+dec_size_out:
361
+	atomic_sub(size, sz);
362
+dec_count_out:
363
+	atomic_dec(nr);
364
+	return ret;
365
+}
366
+
367
+static int kernfs_vfs_user_xattr_rm(struct kernfs_node *kn,
368
+				    const char *full_name,
369
+				    struct simple_xattrs *xattrs,
370
+				    const void *value, size_t size, int flags)
371
+{
372
+	atomic_t *sz = &kn->iattr->user_xattr_size;
373
+	atomic_t *nr = &kn->iattr->nr_user_xattrs;
374
+	ssize_t removed_size;
375
+	int ret;
376
+
377
+	ret = simple_xattr_set(xattrs, full_name, value, size, flags,
378
+			       &removed_size);
379
+
380
+	if (removed_size >= 0) {
381
+		atomic_sub(removed_size, sz);
382
+		atomic_dec(nr);
383
+	}
384
+
385
+	return ret;
386
+}
387
+
388
+static int kernfs_vfs_user_xattr_set(const struct xattr_handler *handler,
346389 				     struct dentry *unused, struct inode *inode,
347390 				     const char *suffix, const void *value,
348391 				     size_t size, int flags)
349392 {
393
+	const char *full_name = xattr_full_name(handler, suffix);
350394 	struct kernfs_node *kn = inode->i_private;
351395 	struct kernfs_iattrs *attrs;
352
-	void *secdata;
353
-	u32 secdata_len = 0;
354
-	int error;
396
+
397
+	if (!(kernfs_root(kn)->flags & KERNFS_ROOT_SUPPORT_USER_XATTR))
398
+		return -EOPNOTSUPP;
355399 
356400 	attrs = kernfs_iattrs(kn);
357401 	if (!attrs)
358402 		return -ENOMEM;
359403 
360
-	error = security_inode_setsecurity(inode, suffix, value, size, flags);
361
-	if (error)
362
-		return error;
363
-	error = security_inode_getsecctx(inode, &secdata, &secdata_len);
364
-	if (error)
365
-		return error;
404
+	if (value)
405
+		return kernfs_vfs_user_xattr_add(kn, full_name, &attrs->xattrs,
406
+						 value, size, flags);
407
+	else
408
+		return kernfs_vfs_user_xattr_rm(kn, full_name, &attrs->xattrs,
409
+						value, size, flags);
366410 
367
-	mutex_lock(&kernfs_mutex);
368
-	error = kernfs_node_setsecdata(attrs, &secdata, &secdata_len);
369
-	mutex_unlock(&kernfs_mutex);
370
-
371
-	if (secdata)
372
-		security_release_secctx(secdata, secdata_len);
373
-	return error;
374411 }
412
+
413
+static const struct xattr_handler kernfs_trusted_xattr_handler = {
414
+	.prefix = XATTR_TRUSTED_PREFIX,
415
+	.get = kernfs_vfs_xattr_get,
416
+	.set = kernfs_vfs_xattr_set,
417
+};
375418 
376419 static const struct xattr_handler kernfs_security_xattr_handler = {
377420 	.prefix = XATTR_SECURITY_PREFIX,
378
-	.get = kernfs_xattr_get,
379
-	.set = kernfs_security_xattr_set,
421
+	.get = kernfs_vfs_xattr_get,
422
+	.set = kernfs_vfs_xattr_set,
423
+};
424
+
425
+static const struct xattr_handler kernfs_user_xattr_handler = {
426
+	.prefix = XATTR_USER_PREFIX,
427
+	.get = kernfs_vfs_xattr_get,
428
+	.set = kernfs_vfs_user_xattr_set,
380429 };
381430 
382431 const struct xattr_handler *kernfs_xattr_handlers[] = {
383432 	&kernfs_trusted_xattr_handler,
384433 	&kernfs_security_xattr_handler,
434
+	&kernfs_user_xattr_handler,
385435 	NULL
386436 };