xref: /openbmc/linux/fs/ntfs3/xattr.c (revision 801543b2)
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  *
4  * Copyright (C) 2019-2021 Paragon Software GmbH, All rights reserved.
5  *
6  */
7 
8 #include <linux/fs.h>
9 #include <linux/posix_acl.h>
10 #include <linux/posix_acl_xattr.h>
11 #include <linux/xattr.h>
12 
13 #include "debug.h"
14 #include "ntfs.h"
15 #include "ntfs_fs.h"
16 
17 // clang-format off
18 #define SYSTEM_DOS_ATTRIB    "system.dos_attrib"
19 #define SYSTEM_NTFS_ATTRIB   "system.ntfs_attrib"
20 #define SYSTEM_NTFS_SECURITY "system.ntfs_security"
21 // clang-format on
22 
23 static inline size_t unpacked_ea_size(const struct EA_FULL *ea)
24 {
25 	return ea->size ? le32_to_cpu(ea->size)
26 			: ALIGN(struct_size(ea, name,
27 					    1 + ea->name_len +
28 						    le16_to_cpu(ea->elength)),
29 				4);
30 }
31 
32 static inline size_t packed_ea_size(const struct EA_FULL *ea)
33 {
34 	return struct_size(ea, name,
35 			   1 + ea->name_len + le16_to_cpu(ea->elength)) -
36 	       offsetof(struct EA_FULL, flags);
37 }
38 
39 /*
40  * find_ea
41  *
42  * Assume there is at least one xattr in the list.
43  */
44 static inline bool find_ea(const struct EA_FULL *ea_all, u32 bytes,
45 			   const char *name, u8 name_len, u32 *off)
46 {
47 	*off = 0;
48 
49 	if (!ea_all || !bytes)
50 		return false;
51 
52 	for (;;) {
53 		const struct EA_FULL *ea = Add2Ptr(ea_all, *off);
54 		u32 next_off = *off + unpacked_ea_size(ea);
55 
56 		if (next_off > bytes)
57 			return false;
58 
59 		if (ea->name_len == name_len &&
60 		    !memcmp(ea->name, name, name_len))
61 			return true;
62 
63 		*off = next_off;
64 		if (next_off >= bytes)
65 			return false;
66 	}
67 }
68 
69 /*
70  * ntfs_read_ea - Read all extended attributes.
71  * @ea:		New allocated memory.
72  * @info:	Pointer into resident data.
73  */
74 static int ntfs_read_ea(struct ntfs_inode *ni, struct EA_FULL **ea,
75 			size_t add_bytes, const struct EA_INFO **info)
76 {
77 	int err;
78 	struct ntfs_sb_info *sbi = ni->mi.sbi;
79 	struct ATTR_LIST_ENTRY *le = NULL;
80 	struct ATTRIB *attr_info, *attr_ea;
81 	void *ea_p;
82 	u32 size;
83 
84 	static_assert(le32_to_cpu(ATTR_EA_INFO) < le32_to_cpu(ATTR_EA));
85 
86 	*ea = NULL;
87 	*info = NULL;
88 
89 	attr_info =
90 		ni_find_attr(ni, NULL, &le, ATTR_EA_INFO, NULL, 0, NULL, NULL);
91 	attr_ea =
92 		ni_find_attr(ni, attr_info, &le, ATTR_EA, NULL, 0, NULL, NULL);
93 
94 	if (!attr_ea || !attr_info)
95 		return 0;
96 
97 	*info = resident_data_ex(attr_info, sizeof(struct EA_INFO));
98 	if (!*info)
99 		return -EINVAL;
100 
101 	/* Check Ea limit. */
102 	size = le32_to_cpu((*info)->size);
103 	if (size > sbi->ea_max_size)
104 		return -EFBIG;
105 
106 	if (attr_size(attr_ea) > sbi->ea_max_size)
107 		return -EFBIG;
108 
109 	/* Allocate memory for packed Ea. */
110 	ea_p = kmalloc(size + add_bytes, GFP_NOFS);
111 	if (!ea_p)
112 		return -ENOMEM;
113 
114 	if (!size) {
115 		/* EA info persists, but xattr is empty. Looks like EA problem. */
116 	} else if (attr_ea->non_res) {
117 		struct runs_tree run;
118 
119 		run_init(&run);
120 
121 		err = attr_load_runs_range(ni, ATTR_EA, NULL, 0, &run, 0, size);
122 		if (!err)
123 			err = ntfs_read_run_nb(sbi, &run, 0, ea_p, size, NULL);
124 		run_close(&run);
125 
126 		if (err)
127 			goto out;
128 	} else {
129 		void *p = resident_data_ex(attr_ea, size);
130 
131 		if (!p) {
132 			err = -EINVAL;
133 			goto out;
134 		}
135 		memcpy(ea_p, p, size);
136 	}
137 
138 	memset(Add2Ptr(ea_p, size), 0, add_bytes);
139 	*ea = ea_p;
140 	return 0;
141 
142 out:
143 	kfree(ea_p);
144 	*ea = NULL;
145 	return err;
146 }
147 
148 /*
149  * ntfs_list_ea
150  *
151  * Copy a list of xattrs names into the buffer
152  * provided, or compute the buffer size required.
153  *
154  * Return:
155  * * Number of bytes used / required on
156  * * -ERRNO - on failure
157  */
158 static ssize_t ntfs_list_ea(struct ntfs_inode *ni, char *buffer,
159 			    size_t bytes_per_buffer)
160 {
161 	const struct EA_INFO *info;
162 	struct EA_FULL *ea_all = NULL;
163 	const struct EA_FULL *ea;
164 	u32 off, size;
165 	int err;
166 	size_t ret;
167 
168 	err = ntfs_read_ea(ni, &ea_all, 0, &info);
169 	if (err)
170 		return err;
171 
172 	if (!info || !ea_all)
173 		return 0;
174 
175 	size = le32_to_cpu(info->size);
176 
177 	/* Enumerate all xattrs. */
178 	for (ret = 0, off = 0; off < size; off += unpacked_ea_size(ea)) {
179 		ea = Add2Ptr(ea_all, off);
180 
181 		if (buffer) {
182 			if (ret + ea->name_len + 1 > bytes_per_buffer) {
183 				err = -ERANGE;
184 				goto out;
185 			}
186 
187 			memcpy(buffer + ret, ea->name, ea->name_len);
188 			buffer[ret + ea->name_len] = 0;
189 		}
190 
191 		ret += ea->name_len + 1;
192 	}
193 
194 out:
195 	kfree(ea_all);
196 	return err ? err : ret;
197 }
198 
199 static int ntfs_get_ea(struct inode *inode, const char *name, size_t name_len,
200 		       void *buffer, size_t size, size_t *required)
201 {
202 	struct ntfs_inode *ni = ntfs_i(inode);
203 	const struct EA_INFO *info;
204 	struct EA_FULL *ea_all = NULL;
205 	const struct EA_FULL *ea;
206 	u32 off, len;
207 	int err;
208 
209 	if (!(ni->ni_flags & NI_FLAG_EA))
210 		return -ENODATA;
211 
212 	if (!required)
213 		ni_lock(ni);
214 
215 	len = 0;
216 
217 	if (name_len > 255) {
218 		err = -ENAMETOOLONG;
219 		goto out;
220 	}
221 
222 	err = ntfs_read_ea(ni, &ea_all, 0, &info);
223 	if (err)
224 		goto out;
225 
226 	if (!info)
227 		goto out;
228 
229 	/* Enumerate all xattrs. */
230 	if (!find_ea(ea_all, le32_to_cpu(info->size), name, name_len, &off)) {
231 		err = -ENODATA;
232 		goto out;
233 	}
234 	ea = Add2Ptr(ea_all, off);
235 
236 	len = le16_to_cpu(ea->elength);
237 	if (!buffer) {
238 		err = 0;
239 		goto out;
240 	}
241 
242 	if (len > size) {
243 		err = -ERANGE;
244 		if (required)
245 			*required = len;
246 		goto out;
247 	}
248 
249 	memcpy(buffer, ea->name + ea->name_len + 1, len);
250 	err = 0;
251 
252 out:
253 	kfree(ea_all);
254 	if (!required)
255 		ni_unlock(ni);
256 
257 	return err ? err : len;
258 }
259 
260 static noinline int ntfs_set_ea(struct inode *inode, const char *name,
261 				size_t name_len, const void *value,
262 				size_t val_size, int flags, bool locked)
263 {
264 	struct ntfs_inode *ni = ntfs_i(inode);
265 	struct ntfs_sb_info *sbi = ni->mi.sbi;
266 	int err;
267 	struct EA_INFO ea_info;
268 	const struct EA_INFO *info;
269 	struct EA_FULL *new_ea;
270 	struct EA_FULL *ea_all = NULL;
271 	size_t add, new_pack;
272 	u32 off, size;
273 	__le16 size_pack;
274 	struct ATTRIB *attr;
275 	struct ATTR_LIST_ENTRY *le;
276 	struct mft_inode *mi;
277 	struct runs_tree ea_run;
278 	u64 new_sz;
279 	void *p;
280 
281 	if (!locked)
282 		ni_lock(ni);
283 
284 	run_init(&ea_run);
285 
286 	if (name_len > 255) {
287 		err = -ENAMETOOLONG;
288 		goto out;
289 	}
290 
291 	add = ALIGN(struct_size(ea_all, name, 1 + name_len + val_size), 4);
292 
293 	err = ntfs_read_ea(ni, &ea_all, add, &info);
294 	if (err)
295 		goto out;
296 
297 	if (!info) {
298 		memset(&ea_info, 0, sizeof(ea_info));
299 		size = 0;
300 		size_pack = 0;
301 	} else {
302 		memcpy(&ea_info, info, sizeof(ea_info));
303 		size = le32_to_cpu(ea_info.size);
304 		size_pack = ea_info.size_pack;
305 	}
306 
307 	if (info && find_ea(ea_all, size, name, name_len, &off)) {
308 		struct EA_FULL *ea;
309 		size_t ea_sz;
310 
311 		if (flags & XATTR_CREATE) {
312 			err = -EEXIST;
313 			goto out;
314 		}
315 
316 		ea = Add2Ptr(ea_all, off);
317 
318 		/*
319 		 * Check simple case when we try to insert xattr with the same value
320 		 * e.g. ntfs_save_wsl_perm
321 		 */
322 		if (val_size && le16_to_cpu(ea->elength) == val_size &&
323 		    !memcmp(ea->name + ea->name_len + 1, value, val_size)) {
324 			/* xattr already contains the required value. */
325 			goto out;
326 		}
327 
328 		/* Remove current xattr. */
329 		if (ea->flags & FILE_NEED_EA)
330 			le16_add_cpu(&ea_info.count, -1);
331 
332 		ea_sz = unpacked_ea_size(ea);
333 
334 		le16_add_cpu(&ea_info.size_pack, 0 - packed_ea_size(ea));
335 
336 		memmove(ea, Add2Ptr(ea, ea_sz), size - off - ea_sz);
337 
338 		size -= ea_sz;
339 		memset(Add2Ptr(ea_all, size), 0, ea_sz);
340 
341 		ea_info.size = cpu_to_le32(size);
342 
343 		if ((flags & XATTR_REPLACE) && !val_size) {
344 			/* Remove xattr. */
345 			goto update_ea;
346 		}
347 	} else {
348 		if (flags & XATTR_REPLACE) {
349 			err = -ENODATA;
350 			goto out;
351 		}
352 
353 		if (!ea_all) {
354 			ea_all = kzalloc(add, GFP_NOFS);
355 			if (!ea_all) {
356 				err = -ENOMEM;
357 				goto out;
358 			}
359 		}
360 	}
361 
362 	/* Append new xattr. */
363 	new_ea = Add2Ptr(ea_all, size);
364 	new_ea->size = cpu_to_le32(add);
365 	new_ea->flags = 0;
366 	new_ea->name_len = name_len;
367 	new_ea->elength = cpu_to_le16(val_size);
368 	memcpy(new_ea->name, name, name_len);
369 	new_ea->name[name_len] = 0;
370 	memcpy(new_ea->name + name_len + 1, value, val_size);
371 	new_pack = le16_to_cpu(ea_info.size_pack) + packed_ea_size(new_ea);
372 	ea_info.size_pack = cpu_to_le16(new_pack);
373 	/* New size of ATTR_EA. */
374 	size += add;
375 	ea_info.size = cpu_to_le32(size);
376 
377 	/*
378 	 * 1. Check ea_info.size_pack for overflow.
379 	 * 2. New attibute size must fit value from $AttrDef
380 	 */
381 	if (new_pack > 0xffff || size > sbi->ea_max_size) {
382 		ntfs_inode_warn(
383 			inode,
384 			"The size of extended attributes must not exceed 64KiB");
385 		err = -EFBIG; // -EINVAL?
386 		goto out;
387 	}
388 
389 update_ea:
390 
391 	if (!info) {
392 		/* Create xattr. */
393 		if (!size) {
394 			err = 0;
395 			goto out;
396 		}
397 
398 		err = ni_insert_resident(ni, sizeof(struct EA_INFO),
399 					 ATTR_EA_INFO, NULL, 0, NULL, NULL,
400 					 NULL);
401 		if (err)
402 			goto out;
403 
404 		err = ni_insert_resident(ni, 0, ATTR_EA, NULL, 0, NULL, NULL,
405 					 NULL);
406 		if (err)
407 			goto out;
408 	}
409 
410 	new_sz = size;
411 	err = attr_set_size(ni, ATTR_EA, NULL, 0, &ea_run, new_sz, &new_sz,
412 			    false, NULL);
413 	if (err)
414 		goto out;
415 
416 	le = NULL;
417 	attr = ni_find_attr(ni, NULL, &le, ATTR_EA_INFO, NULL, 0, NULL, &mi);
418 	if (!attr) {
419 		err = -EINVAL;
420 		goto out;
421 	}
422 
423 	if (!size) {
424 		/* Delete xattr, ATTR_EA_INFO */
425 		ni_remove_attr_le(ni, attr, mi, le);
426 	} else {
427 		p = resident_data_ex(attr, sizeof(struct EA_INFO));
428 		if (!p) {
429 			err = -EINVAL;
430 			goto out;
431 		}
432 		memcpy(p, &ea_info, sizeof(struct EA_INFO));
433 		mi->dirty = true;
434 	}
435 
436 	le = NULL;
437 	attr = ni_find_attr(ni, NULL, &le, ATTR_EA, NULL, 0, NULL, &mi);
438 	if (!attr) {
439 		err = -EINVAL;
440 		goto out;
441 	}
442 
443 	if (!size) {
444 		/* Delete xattr, ATTR_EA */
445 		ni_remove_attr_le(ni, attr, mi, le);
446 	} else if (attr->non_res) {
447 		err = attr_load_runs_range(ni, ATTR_EA, NULL, 0, &ea_run, 0,
448 					   size);
449 		if (err)
450 			goto out;
451 
452 		err = ntfs_sb_write_run(sbi, &ea_run, 0, ea_all, size, 0);
453 		if (err)
454 			goto out;
455 	} else {
456 		p = resident_data_ex(attr, size);
457 		if (!p) {
458 			err = -EINVAL;
459 			goto out;
460 		}
461 		memcpy(p, ea_all, size);
462 		mi->dirty = true;
463 	}
464 
465 	/* Check if we delete the last xattr. */
466 	if (size)
467 		ni->ni_flags |= NI_FLAG_EA;
468 	else
469 		ni->ni_flags &= ~NI_FLAG_EA;
470 
471 	if (ea_info.size_pack != size_pack)
472 		ni->ni_flags |= NI_FLAG_UPDATE_PARENT;
473 	mark_inode_dirty(&ni->vfs_inode);
474 
475 out:
476 	if (!locked)
477 		ni_unlock(ni);
478 
479 	run_close(&ea_run);
480 	kfree(ea_all);
481 
482 	return err;
483 }
484 
485 #ifdef CONFIG_NTFS3_FS_POSIX_ACL
486 static struct posix_acl *ntfs_get_acl_ex(struct user_namespace *mnt_userns,
487 					 struct inode *inode, int type,
488 					 int locked)
489 {
490 	struct ntfs_inode *ni = ntfs_i(inode);
491 	const char *name;
492 	size_t name_len;
493 	struct posix_acl *acl;
494 	size_t req;
495 	int err;
496 	void *buf;
497 
498 	/* Allocate PATH_MAX bytes. */
499 	buf = __getname();
500 	if (!buf)
501 		return ERR_PTR(-ENOMEM);
502 
503 	/* Possible values of 'type' was already checked above. */
504 	if (type == ACL_TYPE_ACCESS) {
505 		name = XATTR_NAME_POSIX_ACL_ACCESS;
506 		name_len = sizeof(XATTR_NAME_POSIX_ACL_ACCESS) - 1;
507 	} else {
508 		name = XATTR_NAME_POSIX_ACL_DEFAULT;
509 		name_len = sizeof(XATTR_NAME_POSIX_ACL_DEFAULT) - 1;
510 	}
511 
512 	if (!locked)
513 		ni_lock(ni);
514 
515 	err = ntfs_get_ea(inode, name, name_len, buf, PATH_MAX, &req);
516 
517 	if (!locked)
518 		ni_unlock(ni);
519 
520 	/* Translate extended attribute to acl. */
521 	if (err >= 0) {
522 		acl = posix_acl_from_xattr(mnt_userns, buf, err);
523 	} else if (err == -ENODATA) {
524 		acl = NULL;
525 	} else {
526 		acl = ERR_PTR(err);
527 	}
528 
529 	if (!IS_ERR(acl))
530 		set_cached_acl(inode, type, acl);
531 
532 	__putname(buf);
533 
534 	return acl;
535 }
536 
537 /*
538  * ntfs_get_acl - inode_operations::get_acl
539  */
540 struct posix_acl *ntfs_get_acl(struct inode *inode, int type, bool rcu)
541 {
542 	if (rcu)
543 		return ERR_PTR(-ECHILD);
544 
545 	/* TODO: init_user_ns? */
546 	return ntfs_get_acl_ex(&init_user_ns, inode, type, 0);
547 }
548 
549 static noinline int ntfs_set_acl_ex(struct user_namespace *mnt_userns,
550 				    struct inode *inode, struct posix_acl *acl,
551 				    int type, bool init_acl)
552 {
553 	const char *name;
554 	size_t size, name_len;
555 	void *value;
556 	int err;
557 	int flags;
558 	umode_t mode;
559 
560 	if (S_ISLNK(inode->i_mode))
561 		return -EOPNOTSUPP;
562 
563 	mode = inode->i_mode;
564 	switch (type) {
565 	case ACL_TYPE_ACCESS:
566 		/* Do not change i_mode if we are in init_acl */
567 		if (acl && !init_acl) {
568 			err = posix_acl_update_mode(mnt_userns, inode, &mode,
569 						    &acl);
570 			if (err)
571 				return err;
572 		}
573 		name = XATTR_NAME_POSIX_ACL_ACCESS;
574 		name_len = sizeof(XATTR_NAME_POSIX_ACL_ACCESS) - 1;
575 		break;
576 
577 	case ACL_TYPE_DEFAULT:
578 		if (!S_ISDIR(inode->i_mode))
579 			return acl ? -EACCES : 0;
580 		name = XATTR_NAME_POSIX_ACL_DEFAULT;
581 		name_len = sizeof(XATTR_NAME_POSIX_ACL_DEFAULT) - 1;
582 		break;
583 
584 	default:
585 		return -EINVAL;
586 	}
587 
588 	if (!acl) {
589 		/* Remove xattr if it can be presented via mode. */
590 		size = 0;
591 		value = NULL;
592 		flags = XATTR_REPLACE;
593 	} else {
594 		size = posix_acl_xattr_size(acl->a_count);
595 		value = kmalloc(size, GFP_NOFS);
596 		if (!value)
597 			return -ENOMEM;
598 		err = posix_acl_to_xattr(mnt_userns, acl, value, size);
599 		if (err < 0)
600 			goto out;
601 		flags = 0;
602 	}
603 
604 	err = ntfs_set_ea(inode, name, name_len, value, size, flags, 0);
605 	if (err == -ENODATA && !size)
606 		err = 0; /* Removing non existed xattr. */
607 	if (!err) {
608 		set_cached_acl(inode, type, acl);
609 		if (inode->i_mode != mode) {
610 			inode->i_mode = mode;
611 			mark_inode_dirty(inode);
612 		}
613 	}
614 
615 out:
616 	kfree(value);
617 
618 	return err;
619 }
620 
621 /*
622  * ntfs_set_acl - inode_operations::set_acl
623  */
624 int ntfs_set_acl(struct user_namespace *mnt_userns, struct inode *inode,
625 		 struct posix_acl *acl, int type)
626 {
627 	return ntfs_set_acl_ex(mnt_userns, inode, acl, type, false);
628 }
629 
630 static int ntfs_xattr_get_acl(struct user_namespace *mnt_userns,
631 			      struct inode *inode, int type, void *buffer,
632 			      size_t size)
633 {
634 	struct posix_acl *acl;
635 	int err;
636 
637 	if (!(inode->i_sb->s_flags & SB_POSIXACL)) {
638 		ntfs_inode_warn(inode, "add mount option \"acl\" to use acl");
639 		return -EOPNOTSUPP;
640 	}
641 
642 	acl = ntfs_get_acl(inode, type, false);
643 	if (IS_ERR(acl))
644 		return PTR_ERR(acl);
645 
646 	if (!acl)
647 		return -ENODATA;
648 
649 	err = posix_acl_to_xattr(mnt_userns, acl, buffer, size);
650 	posix_acl_release(acl);
651 
652 	return err;
653 }
654 
655 static int ntfs_xattr_set_acl(struct user_namespace *mnt_userns,
656 			      struct inode *inode, int type, const void *value,
657 			      size_t size)
658 {
659 	struct posix_acl *acl;
660 	int err;
661 
662 	if (!(inode->i_sb->s_flags & SB_POSIXACL)) {
663 		ntfs_inode_warn(inode, "add mount option \"acl\" to use acl");
664 		return -EOPNOTSUPP;
665 	}
666 
667 	if (!inode_owner_or_capable(mnt_userns, inode))
668 		return -EPERM;
669 
670 	if (!value) {
671 		acl = NULL;
672 	} else {
673 		acl = posix_acl_from_xattr(mnt_userns, value, size);
674 		if (IS_ERR(acl))
675 			return PTR_ERR(acl);
676 
677 		if (acl) {
678 			err = posix_acl_valid(mnt_userns, acl);
679 			if (err)
680 				goto release_and_out;
681 		}
682 	}
683 
684 	err = ntfs_set_acl(mnt_userns, inode, acl, type);
685 
686 release_and_out:
687 	posix_acl_release(acl);
688 	return err;
689 }
690 
691 /*
692  * ntfs_init_acl - Initialize the ACLs of a new inode.
693  *
694  * Called from ntfs_create_inode().
695  */
696 int ntfs_init_acl(struct user_namespace *mnt_userns, struct inode *inode,
697 		  struct inode *dir)
698 {
699 	struct posix_acl *default_acl, *acl;
700 	int err;
701 
702 	err = posix_acl_create(dir, &inode->i_mode, &default_acl, &acl);
703 	if (err)
704 		return err;
705 
706 	if (default_acl) {
707 		err = ntfs_set_acl_ex(mnt_userns, inode, default_acl,
708 				      ACL_TYPE_DEFAULT, true);
709 		posix_acl_release(default_acl);
710 	} else {
711 		inode->i_default_acl = NULL;
712 	}
713 
714 	if (acl) {
715 		if (!err)
716 			err = ntfs_set_acl_ex(mnt_userns, inode, acl,
717 					      ACL_TYPE_ACCESS, true);
718 		posix_acl_release(acl);
719 	} else {
720 		inode->i_acl = NULL;
721 	}
722 
723 	return err;
724 }
725 #endif
726 
727 /*
728  * ntfs_acl_chmod - Helper for ntfs3_setattr().
729  */
730 int ntfs_acl_chmod(struct user_namespace *mnt_userns, struct inode *inode)
731 {
732 	struct super_block *sb = inode->i_sb;
733 
734 	if (!(sb->s_flags & SB_POSIXACL))
735 		return 0;
736 
737 	if (S_ISLNK(inode->i_mode))
738 		return -EOPNOTSUPP;
739 
740 	return posix_acl_chmod(mnt_userns, inode, inode->i_mode);
741 }
742 
743 /*
744  * ntfs_permission - inode_operations::permission
745  */
746 int ntfs_permission(struct user_namespace *mnt_userns, struct inode *inode,
747 		    int mask)
748 {
749 	if (ntfs_sb(inode->i_sb)->options->noacsrules) {
750 		/* "No access rules" mode - Allow all changes. */
751 		return 0;
752 	}
753 
754 	return generic_permission(mnt_userns, inode, mask);
755 }
756 
757 /*
758  * ntfs_listxattr - inode_operations::listxattr
759  */
760 ssize_t ntfs_listxattr(struct dentry *dentry, char *buffer, size_t size)
761 {
762 	struct inode *inode = d_inode(dentry);
763 	struct ntfs_inode *ni = ntfs_i(inode);
764 	ssize_t ret;
765 
766 	if (!(ni->ni_flags & NI_FLAG_EA)) {
767 		/* no xattr in file */
768 		return 0;
769 	}
770 
771 	ni_lock(ni);
772 
773 	ret = ntfs_list_ea(ni, buffer, size);
774 
775 	ni_unlock(ni);
776 
777 	return ret;
778 }
779 
780 static int ntfs_getxattr(const struct xattr_handler *handler, struct dentry *de,
781 			 struct inode *inode, const char *name, void *buffer,
782 			 size_t size)
783 {
784 	int err;
785 	struct ntfs_inode *ni = ntfs_i(inode);
786 	size_t name_len = strlen(name);
787 
788 	/* Dispatch request. */
789 	if (name_len == sizeof(SYSTEM_DOS_ATTRIB) - 1 &&
790 	    !memcmp(name, SYSTEM_DOS_ATTRIB, sizeof(SYSTEM_DOS_ATTRIB))) {
791 		/* system.dos_attrib */
792 		if (!buffer) {
793 			err = sizeof(u8);
794 		} else if (size < sizeof(u8)) {
795 			err = -ENODATA;
796 		} else {
797 			err = sizeof(u8);
798 			*(u8 *)buffer = le32_to_cpu(ni->std_fa);
799 		}
800 		goto out;
801 	}
802 
803 	if (name_len == sizeof(SYSTEM_NTFS_ATTRIB) - 1 &&
804 	    !memcmp(name, SYSTEM_NTFS_ATTRIB, sizeof(SYSTEM_NTFS_ATTRIB))) {
805 		/* system.ntfs_attrib */
806 		if (!buffer) {
807 			err = sizeof(u32);
808 		} else if (size < sizeof(u32)) {
809 			err = -ENODATA;
810 		} else {
811 			err = sizeof(u32);
812 			*(u32 *)buffer = le32_to_cpu(ni->std_fa);
813 		}
814 		goto out;
815 	}
816 
817 	if (name_len == sizeof(SYSTEM_NTFS_SECURITY) - 1 &&
818 	    !memcmp(name, SYSTEM_NTFS_SECURITY, sizeof(SYSTEM_NTFS_SECURITY))) {
819 		/* system.ntfs_security*/
820 		struct SECURITY_DESCRIPTOR_RELATIVE *sd = NULL;
821 		size_t sd_size = 0;
822 
823 		if (!is_ntfs3(ni->mi.sbi)) {
824 			/* We should get nt4 security. */
825 			err = -EINVAL;
826 			goto out;
827 		} else if (le32_to_cpu(ni->std_security_id) <
828 			   SECURITY_ID_FIRST) {
829 			err = -ENOENT;
830 			goto out;
831 		}
832 
833 		err = ntfs_get_security_by_id(ni->mi.sbi, ni->std_security_id,
834 					      &sd, &sd_size);
835 		if (err)
836 			goto out;
837 
838 		if (!is_sd_valid(sd, sd_size)) {
839 			ntfs_inode_warn(
840 				inode,
841 				"looks like you get incorrect security descriptor id=%u",
842 				ni->std_security_id);
843 		}
844 
845 		if (!buffer) {
846 			err = sd_size;
847 		} else if (size < sd_size) {
848 			err = -ENODATA;
849 		} else {
850 			err = sd_size;
851 			memcpy(buffer, sd, sd_size);
852 		}
853 		kfree(sd);
854 		goto out;
855 	}
856 
857 #ifdef CONFIG_NTFS3_FS_POSIX_ACL
858 	if ((name_len == sizeof(XATTR_NAME_POSIX_ACL_ACCESS) - 1 &&
859 	     !memcmp(name, XATTR_NAME_POSIX_ACL_ACCESS,
860 		     sizeof(XATTR_NAME_POSIX_ACL_ACCESS))) ||
861 	    (name_len == sizeof(XATTR_NAME_POSIX_ACL_DEFAULT) - 1 &&
862 	     !memcmp(name, XATTR_NAME_POSIX_ACL_DEFAULT,
863 		     sizeof(XATTR_NAME_POSIX_ACL_DEFAULT)))) {
864 		/* TODO: init_user_ns? */
865 		err = ntfs_xattr_get_acl(
866 			&init_user_ns, inode,
867 			name_len == sizeof(XATTR_NAME_POSIX_ACL_ACCESS) - 1
868 				? ACL_TYPE_ACCESS
869 				: ACL_TYPE_DEFAULT,
870 			buffer, size);
871 		goto out;
872 	}
873 #endif
874 	/* Deal with NTFS extended attribute. */
875 	err = ntfs_get_ea(inode, name, name_len, buffer, size, NULL);
876 
877 out:
878 	return err;
879 }
880 
881 /*
882  * ntfs_setxattr - inode_operations::setxattr
883  */
884 static noinline int ntfs_setxattr(const struct xattr_handler *handler,
885 				  struct user_namespace *mnt_userns,
886 				  struct dentry *de, struct inode *inode,
887 				  const char *name, const void *value,
888 				  size_t size, int flags)
889 {
890 	int err = -EINVAL;
891 	struct ntfs_inode *ni = ntfs_i(inode);
892 	size_t name_len = strlen(name);
893 	enum FILE_ATTRIBUTE new_fa;
894 
895 	/* Dispatch request. */
896 	if (name_len == sizeof(SYSTEM_DOS_ATTRIB) - 1 &&
897 	    !memcmp(name, SYSTEM_DOS_ATTRIB, sizeof(SYSTEM_DOS_ATTRIB))) {
898 		if (sizeof(u8) != size)
899 			goto out;
900 		new_fa = cpu_to_le32(*(u8 *)value);
901 		goto set_new_fa;
902 	}
903 
904 	if (name_len == sizeof(SYSTEM_NTFS_ATTRIB) - 1 &&
905 	    !memcmp(name, SYSTEM_NTFS_ATTRIB, sizeof(SYSTEM_NTFS_ATTRIB))) {
906 		if (size != sizeof(u32))
907 			goto out;
908 		new_fa = cpu_to_le32(*(u32 *)value);
909 
910 		if (S_ISREG(inode->i_mode)) {
911 			/* Process compressed/sparsed in special way. */
912 			ni_lock(ni);
913 			err = ni_new_attr_flags(ni, new_fa);
914 			ni_unlock(ni);
915 			if (err)
916 				goto out;
917 		}
918 set_new_fa:
919 		/*
920 		 * Thanks Mark Harmstone:
921 		 * Keep directory bit consistency.
922 		 */
923 		if (S_ISDIR(inode->i_mode))
924 			new_fa |= FILE_ATTRIBUTE_DIRECTORY;
925 		else
926 			new_fa &= ~FILE_ATTRIBUTE_DIRECTORY;
927 
928 		if (ni->std_fa != new_fa) {
929 			ni->std_fa = new_fa;
930 			if (new_fa & FILE_ATTRIBUTE_READONLY)
931 				inode->i_mode &= ~0222;
932 			else
933 				inode->i_mode |= 0222;
934 			/* Std attribute always in primary record. */
935 			ni->mi.dirty = true;
936 			mark_inode_dirty(inode);
937 		}
938 		err = 0;
939 
940 		goto out;
941 	}
942 
943 	if (name_len == sizeof(SYSTEM_NTFS_SECURITY) - 1 &&
944 	    !memcmp(name, SYSTEM_NTFS_SECURITY, sizeof(SYSTEM_NTFS_SECURITY))) {
945 		/* system.ntfs_security*/
946 		__le32 security_id;
947 		bool inserted;
948 		struct ATTR_STD_INFO5 *std;
949 
950 		if (!is_ntfs3(ni->mi.sbi)) {
951 			/*
952 			 * We should replace ATTR_SECURE.
953 			 * Skip this way cause it is nt4 feature.
954 			 */
955 			err = -EINVAL;
956 			goto out;
957 		}
958 
959 		if (!is_sd_valid(value, size)) {
960 			err = -EINVAL;
961 			ntfs_inode_warn(
962 				inode,
963 				"you try to set invalid security descriptor");
964 			goto out;
965 		}
966 
967 		err = ntfs_insert_security(ni->mi.sbi, value, size,
968 					   &security_id, &inserted);
969 		if (err)
970 			goto out;
971 
972 		ni_lock(ni);
973 		std = ni_std5(ni);
974 		if (!std) {
975 			err = -EINVAL;
976 		} else if (std->security_id != security_id) {
977 			std->security_id = ni->std_security_id = security_id;
978 			/* Std attribute always in primary record. */
979 			ni->mi.dirty = true;
980 			mark_inode_dirty(&ni->vfs_inode);
981 		}
982 		ni_unlock(ni);
983 		goto out;
984 	}
985 
986 #ifdef CONFIG_NTFS3_FS_POSIX_ACL
987 	if ((name_len == sizeof(XATTR_NAME_POSIX_ACL_ACCESS) - 1 &&
988 	     !memcmp(name, XATTR_NAME_POSIX_ACL_ACCESS,
989 		     sizeof(XATTR_NAME_POSIX_ACL_ACCESS))) ||
990 	    (name_len == sizeof(XATTR_NAME_POSIX_ACL_DEFAULT) - 1 &&
991 	     !memcmp(name, XATTR_NAME_POSIX_ACL_DEFAULT,
992 		     sizeof(XATTR_NAME_POSIX_ACL_DEFAULT)))) {
993 		err = ntfs_xattr_set_acl(
994 			mnt_userns, inode,
995 			name_len == sizeof(XATTR_NAME_POSIX_ACL_ACCESS) - 1
996 				? ACL_TYPE_ACCESS
997 				: ACL_TYPE_DEFAULT,
998 			value, size);
999 		goto out;
1000 	}
1001 #endif
1002 	/* Deal with NTFS extended attribute. */
1003 	err = ntfs_set_ea(inode, name, name_len, value, size, flags, 0);
1004 
1005 out:
1006 	inode->i_ctime = current_time(inode);
1007 	mark_inode_dirty(inode);
1008 
1009 	return err;
1010 }
1011 
1012 /*
1013  * ntfs_save_wsl_perm
1014  *
1015  * save uid/gid/mode in xattr
1016  */
1017 int ntfs_save_wsl_perm(struct inode *inode)
1018 {
1019 	int err;
1020 	__le32 value;
1021 	struct ntfs_inode *ni = ntfs_i(inode);
1022 
1023 	ni_lock(ni);
1024 	value = cpu_to_le32(i_uid_read(inode));
1025 	err = ntfs_set_ea(inode, "$LXUID", sizeof("$LXUID") - 1, &value,
1026 			  sizeof(value), 0, true); /* true == already locked. */
1027 	if (err)
1028 		goto out;
1029 
1030 	value = cpu_to_le32(i_gid_read(inode));
1031 	err = ntfs_set_ea(inode, "$LXGID", sizeof("$LXGID") - 1, &value,
1032 			  sizeof(value), 0, true);
1033 	if (err)
1034 		goto out;
1035 
1036 	value = cpu_to_le32(inode->i_mode);
1037 	err = ntfs_set_ea(inode, "$LXMOD", sizeof("$LXMOD") - 1, &value,
1038 			  sizeof(value), 0, true);
1039 	if (err)
1040 		goto out;
1041 
1042 	if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) {
1043 		value = cpu_to_le32(inode->i_rdev);
1044 		err = ntfs_set_ea(inode, "$LXDEV", sizeof("$LXDEV") - 1, &value,
1045 				  sizeof(value), 0, true);
1046 		if (err)
1047 			goto out;
1048 	}
1049 
1050 out:
1051 	ni_unlock(ni);
1052 	/* In case of error should we delete all WSL xattr? */
1053 	return err;
1054 }
1055 
1056 /*
1057  * ntfs_get_wsl_perm
1058  *
1059  * get uid/gid/mode from xattr
1060  * it is called from ntfs_iget5->ntfs_read_mft
1061  */
1062 void ntfs_get_wsl_perm(struct inode *inode)
1063 {
1064 	size_t sz;
1065 	__le32 value[3];
1066 
1067 	if (ntfs_get_ea(inode, "$LXUID", sizeof("$LXUID") - 1, &value[0],
1068 			sizeof(value[0]), &sz) == sizeof(value[0]) &&
1069 	    ntfs_get_ea(inode, "$LXGID", sizeof("$LXGID") - 1, &value[1],
1070 			sizeof(value[1]), &sz) == sizeof(value[1]) &&
1071 	    ntfs_get_ea(inode, "$LXMOD", sizeof("$LXMOD") - 1, &value[2],
1072 			sizeof(value[2]), &sz) == sizeof(value[2])) {
1073 		i_uid_write(inode, (uid_t)le32_to_cpu(value[0]));
1074 		i_gid_write(inode, (gid_t)le32_to_cpu(value[1]));
1075 		inode->i_mode = le32_to_cpu(value[2]);
1076 
1077 		if (ntfs_get_ea(inode, "$LXDEV", sizeof("$$LXDEV") - 1,
1078 				&value[0], sizeof(value),
1079 				&sz) == sizeof(value[0])) {
1080 			inode->i_rdev = le32_to_cpu(value[0]);
1081 		}
1082 	}
1083 }
1084 
1085 static bool ntfs_xattr_user_list(struct dentry *dentry)
1086 {
1087 	return true;
1088 }
1089 
1090 // clang-format off
1091 static const struct xattr_handler ntfs_xattr_handler = {
1092 	.prefix	= "",
1093 	.get	= ntfs_getxattr,
1094 	.set	= ntfs_setxattr,
1095 	.list	= ntfs_xattr_user_list,
1096 };
1097 
1098 const struct xattr_handler *ntfs_xattr_handlers[] = {
1099 	&ntfs_xattr_handler,
1100 	NULL,
1101 };
1102 // clang-format on
1103