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