xref: /openbmc/linux/fs/ntfs3/attrlist.c (revision 2bdd5238)
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/blkdev.h>
9 #include <linux/buffer_head.h>
10 #include <linux/fs.h>
11 #include <linux/nls.h>
12 
13 #include "debug.h"
14 #include "ntfs.h"
15 #include "ntfs_fs.h"
16 
17 /*
18  * al_is_valid_le
19  *
20  * Return: True if @le is valid.
21  */
22 static inline bool al_is_valid_le(const struct ntfs_inode *ni,
23 				  struct ATTR_LIST_ENTRY *le)
24 {
25 	if (!le || !ni->attr_list.le || !ni->attr_list.size)
26 		return false;
27 
28 	return PtrOffset(ni->attr_list.le, le) + le16_to_cpu(le->size) <=
29 	       ni->attr_list.size;
30 }
31 
32 void al_destroy(struct ntfs_inode *ni)
33 {
34 	run_close(&ni->attr_list.run);
35 	kfree(ni->attr_list.le);
36 	ni->attr_list.le = NULL;
37 	ni->attr_list.size = 0;
38 	ni->attr_list.dirty = false;
39 }
40 
41 /*
42  * ntfs_load_attr_list
43  *
44  * This method makes sure that the ATTRIB list, if present,
45  * has been properly set up.
46  */
47 int ntfs_load_attr_list(struct ntfs_inode *ni, struct ATTRIB *attr)
48 {
49 	int err;
50 	size_t lsize;
51 	void *le = NULL;
52 
53 	if (ni->attr_list.size)
54 		return 0;
55 
56 	if (!attr->non_res) {
57 		lsize = le32_to_cpu(attr->res.data_size);
58 		le = kmalloc(al_aligned(lsize), GFP_NOFS);
59 		if (!le) {
60 			err = -ENOMEM;
61 			goto out;
62 		}
63 		memcpy(le, resident_data(attr), lsize);
64 	} else if (attr->nres.svcn) {
65 		err = -EINVAL;
66 		goto out;
67 	} else {
68 		u16 run_off = le16_to_cpu(attr->nres.run_off);
69 
70 		lsize = le64_to_cpu(attr->nres.data_size);
71 
72 		run_init(&ni->attr_list.run);
73 
74 		err = run_unpack_ex(&ni->attr_list.run, ni->mi.sbi, ni->mi.rno,
75 				    0, le64_to_cpu(attr->nres.evcn), 0,
76 				    Add2Ptr(attr, run_off),
77 				    le32_to_cpu(attr->size) - run_off);
78 		if (err < 0)
79 			goto out;
80 
81 		le = kmalloc(al_aligned(lsize), GFP_NOFS);
82 		if (!le) {
83 			err = -ENOMEM;
84 			goto out;
85 		}
86 
87 		err = ntfs_read_run_nb(ni->mi.sbi, &ni->attr_list.run, 0, le,
88 				       lsize, NULL);
89 		if (err)
90 			goto out;
91 	}
92 
93 	ni->attr_list.size = lsize;
94 	ni->attr_list.le = le;
95 
96 	return 0;
97 
98 out:
99 	ni->attr_list.le = le;
100 	al_destroy(ni);
101 
102 	return err;
103 }
104 
105 /*
106  * al_enumerate
107  *
108  * Return:
109  * * The next list le.
110  * * If @le is NULL then return the first le.
111  */
112 struct ATTR_LIST_ENTRY *al_enumerate(struct ntfs_inode *ni,
113 				     struct ATTR_LIST_ENTRY *le)
114 {
115 	size_t off;
116 	u16 sz;
117 
118 	if (!le) {
119 		le = ni->attr_list.le;
120 	} else {
121 		sz = le16_to_cpu(le->size);
122 		if (sz < sizeof(struct ATTR_LIST_ENTRY)) {
123 			/* Impossible 'cause we should not return such le. */
124 			return NULL;
125 		}
126 		le = Add2Ptr(le, sz);
127 	}
128 
129 	/* Check boundary. */
130 	off = PtrOffset(ni->attr_list.le, le);
131 	if (off + sizeof(struct ATTR_LIST_ENTRY) > ni->attr_list.size) {
132 		/* The regular end of list. */
133 		return NULL;
134 	}
135 
136 	sz = le16_to_cpu(le->size);
137 
138 	/* Check le for errors. */
139 	if (sz < sizeof(struct ATTR_LIST_ENTRY) ||
140 	    off + sz > ni->attr_list.size ||
141 	    sz < le->name_off + le->name_len * sizeof(short)) {
142 		return NULL;
143 	}
144 
145 	return le;
146 }
147 
148 /*
149  * al_find_le
150  *
151  * Find the first le in the list which matches type, name and VCN.
152  *
153  * Return: NULL if not found.
154  */
155 struct ATTR_LIST_ENTRY *al_find_le(struct ntfs_inode *ni,
156 				   struct ATTR_LIST_ENTRY *le,
157 				   const struct ATTRIB *attr)
158 {
159 	CLST svcn = attr_svcn(attr);
160 
161 	return al_find_ex(ni, le, attr->type, attr_name(attr), attr->name_len,
162 			  &svcn);
163 }
164 
165 /*
166  * al_find_ex
167  *
168  * Find the first le in the list which matches type, name and VCN.
169  *
170  * Return: NULL if not found.
171  */
172 struct ATTR_LIST_ENTRY *al_find_ex(struct ntfs_inode *ni,
173 				   struct ATTR_LIST_ENTRY *le,
174 				   enum ATTR_TYPE type, const __le16 *name,
175 				   u8 name_len, const CLST *vcn)
176 {
177 	struct ATTR_LIST_ENTRY *ret = NULL;
178 	u32 type_in = le32_to_cpu(type);
179 
180 	while ((le = al_enumerate(ni, le))) {
181 		u64 le_vcn;
182 		int diff = le32_to_cpu(le->type) - type_in;
183 
184 		/* List entries are sorted by type, name and VCN. */
185 		if (diff < 0)
186 			continue;
187 
188 		if (diff > 0)
189 			return ret;
190 
191 		if (le->name_len != name_len)
192 			continue;
193 
194 		le_vcn = le64_to_cpu(le->vcn);
195 		if (!le_vcn) {
196 			/*
197 			 * Compare entry names only for entry with vcn == 0.
198 			 */
199 			diff = ntfs_cmp_names(le_name(le), name_len, name,
200 					      name_len, ni->mi.sbi->upcase,
201 					      true);
202 			if (diff < 0)
203 				continue;
204 
205 			if (diff > 0)
206 				return ret;
207 		}
208 
209 		if (!vcn)
210 			return le;
211 
212 		if (*vcn == le_vcn)
213 			return le;
214 
215 		if (*vcn < le_vcn)
216 			return ret;
217 
218 		ret = le;
219 	}
220 
221 	return ret;
222 }
223 
224 /*
225  * al_find_le_to_insert
226  *
227  * Find the first list entry which matches type, name and VCN.
228  */
229 static struct ATTR_LIST_ENTRY *al_find_le_to_insert(struct ntfs_inode *ni,
230 						    enum ATTR_TYPE type,
231 						    const __le16 *name,
232 						    u8 name_len, CLST vcn)
233 {
234 	struct ATTR_LIST_ENTRY *le = NULL, *prev;
235 	u32 type_in = le32_to_cpu(type);
236 
237 	/* List entries are sorted by type, name and VCN. */
238 	while ((le = al_enumerate(ni, prev = le))) {
239 		int diff = le32_to_cpu(le->type) - type_in;
240 
241 		if (diff < 0)
242 			continue;
243 
244 		if (diff > 0)
245 			return le;
246 
247 		if (!le->vcn) {
248 			/*
249 			 * Compare entry names only for entry with vcn == 0.
250 			 */
251 			diff = ntfs_cmp_names(le_name(le), le->name_len, name,
252 					      name_len, ni->mi.sbi->upcase,
253 					      true);
254 			if (diff < 0)
255 				continue;
256 
257 			if (diff > 0)
258 				return le;
259 		}
260 
261 		if (le64_to_cpu(le->vcn) >= vcn)
262 			return le;
263 	}
264 
265 	return prev ? Add2Ptr(prev, le16_to_cpu(prev->size)) : ni->attr_list.le;
266 }
267 
268 /*
269  * al_add_le
270  *
271  * Add an "attribute list entry" to the list.
272  */
273 int al_add_le(struct ntfs_inode *ni, enum ATTR_TYPE type, const __le16 *name,
274 	      u8 name_len, CLST svcn, __le16 id, const struct MFT_REF *ref,
275 	      struct ATTR_LIST_ENTRY **new_le)
276 {
277 	int err;
278 	struct ATTRIB *attr;
279 	struct ATTR_LIST_ENTRY *le;
280 	size_t off;
281 	u16 sz;
282 	size_t asize, new_asize, old_size;
283 	u64 new_size;
284 	typeof(ni->attr_list) *al = &ni->attr_list;
285 
286 	/*
287 	 * Compute the size of the new 'le'
288 	 */
289 	sz = le_size(name_len);
290 	old_size = al->size;
291 	new_size = old_size + sz;
292 	asize = al_aligned(old_size);
293 	new_asize = al_aligned(new_size);
294 
295 	/* Scan forward to the point at which the new 'le' should be inserted. */
296 	le = al_find_le_to_insert(ni, type, name, name_len, svcn);
297 	off = PtrOffset(al->le, le);
298 
299 	if (new_size > asize) {
300 		void *ptr = kmalloc(new_asize, GFP_NOFS);
301 
302 		if (!ptr)
303 			return -ENOMEM;
304 
305 		memcpy(ptr, al->le, off);
306 		memcpy(Add2Ptr(ptr, off + sz), le, old_size - off);
307 		le = Add2Ptr(ptr, off);
308 		kfree(al->le);
309 		al->le = ptr;
310 	} else {
311 		memmove(Add2Ptr(le, sz), le, old_size - off);
312 	}
313 	*new_le = le;
314 
315 	al->size = new_size;
316 
317 	le->type = type;
318 	le->size = cpu_to_le16(sz);
319 	le->name_len = name_len;
320 	le->name_off = offsetof(struct ATTR_LIST_ENTRY, name);
321 	le->vcn = cpu_to_le64(svcn);
322 	le->ref = *ref;
323 	le->id = id;
324 	memcpy(le->name, name, sizeof(short) * name_len);
325 
326 	err = attr_set_size(ni, ATTR_LIST, NULL, 0, &al->run, new_size,
327 			    &new_size, true, &attr);
328 	if (err) {
329 		/* Undo memmove above. */
330 		memmove(le, Add2Ptr(le, sz), old_size - off);
331 		al->size = old_size;
332 		return err;
333 	}
334 
335 	al->dirty = true;
336 
337 	if (attr && attr->non_res) {
338 		err = ntfs_sb_write_run(ni->mi.sbi, &al->run, 0, al->le,
339 					al->size);
340 		if (err)
341 			return err;
342 		al->dirty = false;
343 	}
344 
345 	return 0;
346 }
347 
348 /*
349  * al_remove_le - Remove @le from attribute list.
350  */
351 bool al_remove_le(struct ntfs_inode *ni, struct ATTR_LIST_ENTRY *le)
352 {
353 	u16 size;
354 	size_t off;
355 	typeof(ni->attr_list) *al = &ni->attr_list;
356 
357 	if (!al_is_valid_le(ni, le))
358 		return false;
359 
360 	/* Save on stack the size of 'le' */
361 	size = le16_to_cpu(le->size);
362 	off = PtrOffset(al->le, le);
363 
364 	memmove(le, Add2Ptr(le, size), al->size - (off + size));
365 
366 	al->size -= size;
367 	al->dirty = true;
368 
369 	return true;
370 }
371 
372 /*
373  * al_delete_le - Delete first le from the list which matches its parameters.
374  */
375 bool al_delete_le(struct ntfs_inode *ni, enum ATTR_TYPE type, CLST vcn,
376 		  const __le16 *name, size_t name_len,
377 		  const struct MFT_REF *ref)
378 {
379 	u16 size;
380 	struct ATTR_LIST_ENTRY *le;
381 	size_t off;
382 	typeof(ni->attr_list) *al = &ni->attr_list;
383 
384 	/* Scan forward to the first le that matches the input. */
385 	le = al_find_ex(ni, NULL, type, name, name_len, &vcn);
386 	if (!le)
387 		return false;
388 
389 	off = PtrOffset(al->le, le);
390 
391 next:
392 	if (off >= al->size)
393 		return false;
394 	if (le->type != type)
395 		return false;
396 	if (le->name_len != name_len)
397 		return false;
398 	if (name_len && ntfs_cmp_names(le_name(le), name_len, name, name_len,
399 				       ni->mi.sbi->upcase, true))
400 		return false;
401 	if (le64_to_cpu(le->vcn) != vcn)
402 		return false;
403 
404 	/*
405 	 * The caller specified a segment reference, so we have to
406 	 * scan through the matching entries until we find that segment
407 	 * reference or we run of matching entries.
408 	 */
409 	if (ref && memcmp(ref, &le->ref, sizeof(*ref))) {
410 		off += le16_to_cpu(le->size);
411 		le = Add2Ptr(al->le, off);
412 		goto next;
413 	}
414 
415 	/* Save on stack the size of 'le'. */
416 	size = le16_to_cpu(le->size);
417 	/* Delete the le. */
418 	memmove(le, Add2Ptr(le, size), al->size - (off + size));
419 
420 	al->size -= size;
421 	al->dirty = true;
422 
423 	return true;
424 }
425 
426 int al_update(struct ntfs_inode *ni)
427 {
428 	int err;
429 	struct ATTRIB *attr;
430 	typeof(ni->attr_list) *al = &ni->attr_list;
431 
432 	if (!al->dirty || !al->size)
433 		return 0;
434 
435 	/*
436 	 * Attribute list increased on demand in al_add_le.
437 	 * Attribute list decreased here.
438 	 */
439 	err = attr_set_size(ni, ATTR_LIST, NULL, 0, &al->run, al->size, NULL,
440 			    false, &attr);
441 	if (err)
442 		goto out;
443 
444 	if (!attr->non_res) {
445 		memcpy(resident_data(attr), al->le, al->size);
446 	} else {
447 		err = ntfs_sb_write_run(ni->mi.sbi, &al->run, 0, al->le,
448 					al->size);
449 		if (err)
450 			goto out;
451 
452 		attr->nres.valid_size = attr->nres.data_size;
453 	}
454 
455 	ni->mi.dirty = true;
456 	al->dirty = false;
457 
458 out:
459 	return err;
460 }
461