xref: /haiku/src/add-ons/kernel/file_systems/ntfs/libntfs/inode.c (revision a5c0d1a80e18f50987966fda2005210092d7671b)
1 /**
2  * inode.c - Inode handling code. Originated from the Linux-NTFS project.
3  *
4  * Copyright (c) 2002-2005 Anton Altaparmakov
5  * Copyright (c) 2002-2008 Szabolcs Szakacsits
6  * Copyright (c) 2004-2007 Yura Pakhuchiy
7  * Copyright (c) 2004-2005 Richard Russon
8  * Copyright (c) 2009-2010 Jean-Pierre Andre
9  *
10  * This program/include file is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU General Public License as published
12  * by the Free Software Foundation; either version 2 of the License, or
13  * (at your option) any later version.
14  *
15  * This program/include file is distributed in the hope that it will be
16  * useful, but WITHOUT ANY WARRANTY; without even the implied warranty
17  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program (in the main directory of the NTFS-3G
22  * distribution in the file COPYING); if not, write to the Free Software
23  * Foundation,Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
24  */
25 
26 #ifdef HAVE_CONFIG_H
27 #include "config.h"
28 #endif
29 
30 #ifdef HAVE_STDLIB_H
31 #include <stdlib.h>
32 #endif
33 #ifdef HAVE_STRING_H
34 #include <string.h>
35 #endif
36 #ifdef HAVE_ERRNO_H
37 #include <errno.h>
38 #endif
39 
40 #include "param.h"
41 #include "compat.h"
42 #include "types.h"
43 #include "volume.h"
44 #include "cache.h"
45 #include "inode.h"
46 #include "attrib.h"
47 #include "debug.h"
48 #include "mft.h"
49 #include "attrlist.h"
50 #include "runlist.h"
51 #include "lcnalloc.h"
52 #include "index.h"
53 #include "dir.h"
54 #include "ntfstime.h"
55 #include "logging.h"
56 #include "misc.h"
57 #include "xattrs.h"
58 
59 ntfs_inode *ntfs_inode_base(ntfs_inode *ni)
60 {
61 	if (ni->nr_extents == -1)
62 		return ni->base_ni;
63 	return ni;
64 }
65 
66 /**
67  * ntfs_inode_mark_dirty - set the inode (and its base inode if it exists) dirty
68  * @ni:		ntfs inode to set dirty
69  *
70  * Set the inode @ni dirty so it is written out later (at the latest at
71  * ntfs_inode_close() time). If @ni is an extent inode, set the base inode
72  * dirty, too.
73  *
74  * This function cannot fail.
75  */
76 void ntfs_inode_mark_dirty(ntfs_inode *ni)
77 {
78 	NInoSetDirty(ni);
79 	if (ni->nr_extents == -1)
80 		NInoSetDirty(ni->base_ni);
81 }
82 
83 /**
84  * __ntfs_inode_allocate - Create and initialise an NTFS inode object
85  * @vol:
86  *
87  * Description...
88  *
89  * Returns:
90  */
91 static ntfs_inode *__ntfs_inode_allocate(ntfs_volume *vol)
92 {
93 	ntfs_inode *ni;
94 
95 	ni = (ntfs_inode*)ntfs_calloc(sizeof(ntfs_inode));
96 	if (ni)
97 		ni->vol = vol;
98 	return ni;
99 }
100 
101 /**
102  * ntfs_inode_allocate - Create an NTFS inode object
103  * @vol:
104  *
105  * Description...
106  *
107  * Returns:
108  */
109 ntfs_inode *ntfs_inode_allocate(ntfs_volume *vol)
110 {
111 	return __ntfs_inode_allocate(vol);
112 }
113 
114 /**
115  * __ntfs_inode_release - Destroy an NTFS inode object
116  * @ni:
117  *
118  * Description...
119  *
120  * Returns:
121  */
122 static void __ntfs_inode_release(ntfs_inode *ni)
123 {
124 	if (NInoDirty(ni))
125 		ntfs_log_error("Releasing dirty inode %lld!\n",
126 			       (long long)ni->mft_no);
127 	if (NInoAttrList(ni) && ni->attr_list)
128 		free(ni->attr_list);
129 	free(ni->mrec);
130 	free(ni);
131 	return;
132 }
133 
134 /**
135  * ntfs_inode_open - open an inode ready for access
136  * @vol:	volume to get the inode from
137  * @mref:	inode number / mft record number to open
138  *
139  * Allocate an ntfs_inode structure and initialize it for the given inode
140  * specified by @mref. @mref specifies the inode number / mft record to read,
141  * including the sequence number, which can be 0 if no sequence number checking
142  * is to be performed.
143  *
144  * Then, allocate a buffer for the mft record, read the mft record from the
145  * volume @vol, and attach it to the ntfs_inode structure (->mrec). The
146  * mft record is mst deprotected and sanity checked for validity and we abort
147  * if deprotection or checks fail.
148  *
149  * Finally, search for an attribute list attribute in the mft record and if one
150  * is found, load the attribute list attribute value and attach it to the
151  * ntfs_inode structure (->attr_list). Also set the NI_AttrList bit to indicate
152  * this.
153  *
154  * Return a pointer to the ntfs_inode structure on success or NULL on error,
155  * with errno set to the error code.
156  */
157 static ntfs_inode *ntfs_inode_real_open(ntfs_volume *vol, const MFT_REF mref)
158 {
159 	s64 l;
160 	ntfs_inode *ni = NULL;
161 	ntfs_attr_search_ctx *ctx;
162 	STANDARD_INFORMATION *std_info;
163 	le32 lthle;
164 	int olderrno;
165 
166 	ntfs_log_enter("Entering for inode %lld\n", (long long)MREF(mref));
167 	if (!vol) {
168 		errno = EINVAL;
169 		goto out;
170 	}
171 	ni = __ntfs_inode_allocate(vol);
172 	if (!ni)
173 		goto out;
174 	if (ntfs_file_record_read(vol, mref, &ni->mrec, NULL))
175 		goto err_out;
176 	if (!(ni->mrec->flags & MFT_RECORD_IN_USE)) {
177 		errno = ENOENT;
178 		goto err_out;
179 	}
180 	ni->mft_no = MREF(mref);
181 	ctx = ntfs_attr_get_search_ctx(ni, NULL);
182 	if (!ctx)
183 		goto err_out;
184 	/* Receive some basic information about inode. */
185 	if (ntfs_attr_lookup(AT_STANDARD_INFORMATION, AT_UNNAMED,
186 				0, CASE_SENSITIVE, 0, NULL, 0, ctx)) {
187 		if (!ni->mrec->base_mft_record)
188 			ntfs_log_perror("No STANDARD_INFORMATION in base record"
189 					" %lld", (long long)MREF(mref));
190 		goto put_err_out;
191 	}
192 	lthle = ctx->attr->value_length;
193 	if (le32_to_cpu(lthle) < offsetof(STANDARD_INFORMATION, owner_id)) {
194 		ntfs_log_error("Corrupt STANDARD_INFORMATION in base"
195 			" record %lld\n",
196 			(long long)MREF(mref));
197 		goto put_err_out;
198 	}
199 	std_info = (STANDARD_INFORMATION *)((u8 *)ctx->attr +
200 			le16_to_cpu(ctx->attr->value_offset));
201 	ni->flags = std_info->file_attributes;
202 	ni->creation_time = std_info->creation_time;
203 	ni->last_data_change_time = std_info->last_data_change_time;
204 	ni->last_mft_change_time = std_info->last_mft_change_time;
205 	ni->last_access_time = std_info->last_access_time;
206 		/* Insert v3 extensions if present */
207 		/* length may be seen as 48 (v1.x) or 72 (v3.x) */
208 	if (le32_to_cpu(lthle) >= offsetof(STANDARD_INFORMATION, v3_end)) {
209 		set_nino_flag(ni, v3_Extensions);
210 		ni->owner_id = std_info->owner_id;
211 		ni->security_id = std_info->security_id;
212 		ni->quota_charged = std_info->quota_charged;
213 		ni->usn = std_info->usn;
214 	} else {
215 		clear_nino_flag(ni, v3_Extensions);
216 		ni->owner_id = const_cpu_to_le32(0);
217 		ni->security_id = const_cpu_to_le32(0);
218 	}
219 	/* Set attribute list information. */
220 	olderrno = errno;
221 	if (ntfs_attr_lookup(AT_ATTRIBUTE_LIST, AT_UNNAMED, 0,
222 			CASE_SENSITIVE, 0, NULL, 0, ctx)) {
223 		if (errno != ENOENT)
224 			goto put_err_out;
225 		/* Attribute list attribute does not present. */
226 		/* restore previous errno to avoid misinterpretation */
227 		errno = olderrno;
228 		goto get_size;
229 	}
230 	NInoSetAttrList(ni);
231 	l = ntfs_get_attribute_value_length(ctx->attr);
232 	if (!l)
233 		goto put_err_out;
234 	if ((u64)l > 0x40000) {
235 		errno = EIO;
236 		ntfs_log_perror("Too large attrlist attribute (%llu), inode "
237 				"%lld", (long long)l, (long long)MREF(mref));
238 		goto put_err_out;
239 	}
240 	ni->attr_list_size = l;
241 	ni->attr_list = ntfs_malloc(ni->attr_list_size);
242 	if (!ni->attr_list)
243 		goto put_err_out;
244 	l = ntfs_get_attribute_value(vol, ctx->attr, ni->attr_list);
245 	if (!l)
246 		goto put_err_out;
247 	if (l != ni->attr_list_size) {
248 		errno = EIO;
249 		ntfs_log_perror("Unexpected attrlist size (%lld <> %u), inode "
250 				"%lld", (long long)l, ni->attr_list_size,
251 				(long long)MREF(mref));
252 		goto put_err_out;
253 	}
254 get_size:
255 	olderrno = errno;
256 	if (ntfs_attr_lookup(AT_DATA, AT_UNNAMED, 0, 0, 0, NULL, 0, ctx)) {
257 		if (errno != ENOENT)
258 			goto put_err_out;
259 		/* Directory or special file. */
260 		/* restore previous errno to avoid misinterpretation */
261 		errno = olderrno;
262 		ni->data_size = ni->allocated_size = 0;
263 	} else {
264 		if (ctx->attr->non_resident) {
265 			ni->data_size = sle64_to_cpu(ctx->attr->data_size);
266 			if (ctx->attr->flags &
267 					(ATTR_IS_COMPRESSED | ATTR_IS_SPARSE))
268 				ni->allocated_size = sle64_to_cpu(
269 						ctx->attr->compressed_size);
270 			else
271 				ni->allocated_size = sle64_to_cpu(
272 						ctx->attr->allocated_size);
273 		} else {
274 			ni->data_size = le32_to_cpu(ctx->attr->value_length);
275 			ni->allocated_size = (ni->data_size + 7) & ~7;
276 		}
277 		set_nino_flag(ni,KnownSize);
278 	}
279 	ntfs_attr_put_search_ctx(ctx);
280 out:
281 	ntfs_log_leave("\n");
282 	return ni;
283 
284 put_err_out:
285 	ntfs_attr_put_search_ctx(ctx);
286 err_out:
287 	__ntfs_inode_release(ni);
288 	ni = NULL;
289 	goto out;
290 }
291 
292 /**
293  * ntfs_inode_close - close an ntfs inode and free all associated memory
294  * @ni:		ntfs inode to close
295  *
296  * Make sure the ntfs inode @ni is clean.
297  *
298  * If the ntfs inode @ni is a base inode, close all associated extent inodes,
299  * then deallocate all memory attached to it, and finally free the ntfs inode
300  * structure itself.
301  *
302  * If it is an extent inode, we disconnect it from its base inode before we
303  * destroy it.
304  *
305  * It is OK to pass NULL to this function, it is just noop in this case.
306  *
307  * Return 0 on success or -1 on error with errno set to the error code. On
308  * error, @ni has not been freed. The user should attempt to handle the error
309  * and call ntfs_inode_close() again. The following error codes are defined:
310  *
311  *	EBUSY	@ni and/or its attribute list runlist is/are dirty and the
312  *		attempt to write it/them to disk failed.
313  *	EINVAL	@ni is invalid (probably it is an extent inode).
314  *	EIO	I/O error while trying to write inode to disk.
315  */
316 
317 int ntfs_inode_real_close(ntfs_inode *ni)
318 {
319 	int ret = -1;
320 
321 	if (!ni)
322 		return 0;
323 
324 	ntfs_log_enter("Entering for inode %lld\n", (long long)ni->mft_no);
325 
326 	/* If we have dirty metadata, write it out. */
327 	if (NInoDirty(ni) || NInoAttrListDirty(ni)) {
328 		if (ntfs_inode_sync(ni)) {
329 			if (errno != EIO)
330 				errno = EBUSY;
331 			goto err;
332 		}
333 	}
334 	/* Is this a base inode with mapped extent inodes? */
335 	if (ni->nr_extents > 0) {
336 		while (ni->nr_extents > 0) {
337 			if (ntfs_inode_real_close(ni->extent_nis[0])) {
338 				if (errno != EIO)
339 					errno = EBUSY;
340 				goto err;
341 			}
342 		}
343 	} else if (ni->nr_extents == -1) {
344 		ntfs_inode **tmp_nis;
345 		ntfs_inode *base_ni;
346 		s32 i;
347 
348 		/*
349 		 * If the inode is an extent inode, disconnect it from the
350 		 * base inode before destroying it.
351 		 */
352 		base_ni = ni->base_ni;
353 		for (i = 0; i < base_ni->nr_extents; ++i) {
354 			tmp_nis = base_ni->extent_nis;
355 			if (tmp_nis[i] != ni)
356 				continue;
357 			/* Found it. Disconnect. */
358 			memmove(tmp_nis + i, tmp_nis + i + 1,
359 					(base_ni->nr_extents - i - 1) *
360 					sizeof(ntfs_inode *));
361 			/* Buffer should be for multiple of four extents. */
362 			if ((--base_ni->nr_extents) & 3) {
363 				i = -1;
364 				break;
365 			}
366 			/*
367 			 * ElectricFence is unhappy with realloc(x,0) as free(x)
368 			 * thus we explicitly separate these two cases.
369 			 */
370 			if (base_ni->nr_extents) {
371 				/* Resize the memory buffer. */
372 				tmp_nis = realloc(tmp_nis, base_ni->nr_extents *
373 						  sizeof(ntfs_inode *));
374 				/* Ignore errors, they don't really matter. */
375 				if (tmp_nis)
376 					base_ni->extent_nis = tmp_nis;
377 			} else if (tmp_nis) {
378 				free(tmp_nis);
379 				base_ni->extent_nis = (ntfs_inode**)NULL;
380 			}
381 			/* Allow for error checking. */
382 			i = -1;
383 			break;
384 		}
385 
386 		/*
387 		 *  We could successfully sync, so only log this error
388 		 *  and try to sync other inode extents too.
389 		 */
390 		if (i != -1)
391 			ntfs_log_error("Extent inode %lld was not found\n",
392 				       (long long)ni->mft_no);
393 	}
394 
395 	__ntfs_inode_release(ni);
396 	ret = 0;
397 err:
398 	ntfs_log_leave("\n");
399 	return ret;
400 }
401 
402 #if CACHE_NIDATA_SIZE
403 
404 /*
405  *		Free an inode structure when there is not more space
406  *	in the cache
407  */
408 
409 void ntfs_inode_nidata_free(const struct CACHED_GENERIC *cached)
410 {
411         ntfs_inode_real_close(((const struct CACHED_NIDATA*)cached)->ni);
412 }
413 
414 /*
415  *		Compute a hash value for an inode entry
416  */
417 
418 int ntfs_inode_nidata_hash(const struct CACHED_GENERIC *item)
419 {
420 	return (((const struct CACHED_NIDATA*)item)->inum
421 			% (2*CACHE_NIDATA_SIZE));
422 }
423 
424 /*
425  *		inum comparing for entering/fetching from cache
426  */
427 
428 static int idata_cache_compare(const struct CACHED_GENERIC *cached,
429 			const struct CACHED_GENERIC *wanted)
430 {
431 	return (((const struct CACHED_NIDATA*)cached)->inum
432 			!= ((const struct CACHED_NIDATA*)wanted)->inum);
433 }
434 
435 /*
436  *		Invalidate an inode entry when not needed anymore.
437  *	The entry should have been synced, it may be reused later,
438  *	if it is requested before it is dropped from cache.
439  */
440 
441 void ntfs_inode_invalidate(ntfs_volume *vol, const MFT_REF mref)
442 {
443 	struct CACHED_NIDATA item;
444 
445 	item.inum = MREF(mref);
446 	item.ni = (ntfs_inode*)NULL;
447 	item.pathname = (const char*)NULL;
448 	item.varsize = 0;
449 	ntfs_invalidate_cache(vol->nidata_cache,
450 				GENERIC(&item),idata_cache_compare,CACHE_FREE);
451 }
452 
453 #endif
454 
455 /*
456  *		Open an inode
457  *
458  *	When possible, an entry recorded in the cache is reused
459  *
460  *	**NEVER REOPEN** an inode, this can lead to a duplicated
461  * 	cache entry (hard to detect), and to an obsolete one being
462  *	reused. System files are however protected from being cached.
463  */
464 
465 ntfs_inode *ntfs_inode_open(ntfs_volume *vol, const MFT_REF mref)
466 {
467 	ntfs_inode *ni;
468 #if CACHE_NIDATA_SIZE
469 	struct CACHED_NIDATA item;
470 	struct CACHED_NIDATA *cached;
471 
472 		/* fetch idata from cache */
473 	item.inum = MREF(mref);
474 	debug_double_inode(item.inum,1);
475 	item.pathname = (const char*)NULL;
476 	item.varsize = 0;
477 	cached = (struct CACHED_NIDATA*)ntfs_fetch_cache(vol->nidata_cache,
478 				GENERIC(&item),idata_cache_compare);
479 	if (cached) {
480 		ni = cached->ni;
481 		/* do not keep open entries in cache */
482 		ntfs_remove_cache(vol->nidata_cache,
483 				(struct CACHED_GENERIC*)cached,0);
484 	} else {
485 		ni = ntfs_inode_real_open(vol, mref);
486 	}
487 	if (!ni) {
488 		debug_double_inode(item.inum, 0);
489 	}
490 #else
491 	ni = ntfs_inode_real_open(vol, mref);
492 #endif
493 	return (ni);
494 }
495 
496 /*
497  *		Close an inode entry
498  *
499  *	If cacheing is in use, the entry is synced and kept available
500  *	in cache for further use.
501  *
502  *	System files (inode < 16 or having the IS_4 flag) are protected
503  *	against being cached.
504  */
505 
506 int ntfs_inode_close(ntfs_inode *ni)
507 {
508 	int res;
509 #if CACHE_NIDATA_SIZE
510 	BOOL dirty;
511 	struct CACHED_NIDATA item;
512 
513 	if (ni) {
514 		debug_double_inode(ni->mft_no,0);
515 		/* do not cache system files : could lead to double entries */
516 		if (ni->vol && ni->vol->nidata_cache
517 			&& ((ni->mft_no == FILE_root)
518 			    || ((ni->mft_no >= FILE_first_user)
519 				&& !(ni->mrec->flags & MFT_RECORD_IS_4)))) {
520 			/* If we have dirty metadata, write it out. */
521 			dirty = NInoDirty(ni) || NInoAttrListDirty(ni);
522 			if (dirty) {
523 				res = ntfs_inode_sync(ni);
524 					/* do a real close if sync failed */
525 				if (res)
526 					ntfs_inode_real_close(ni);
527 			} else
528 				res = 0;
529 
530 			if (!res) {
531 					/* feed idata into cache */
532 				item.inum = ni->mft_no;
533 				item.ni = ni;
534 				item.pathname = (const char*)NULL;
535 				item.varsize = 0;
536 				debug_cached_inode(ni);
537 #if defined(__HAIKU__)
538 				if (ntfs_fetch_cache(ni->vol->nidata_cache,
539 						GENERIC(&item), idata_cache_compare)) {
540 					panic("ntfs_inode_close: %llu already in cache!", ni->mft_no);
541 				}
542 #endif
543 				ntfs_enter_cache(ni->vol->nidata_cache,
544 					GENERIC(&item), idata_cache_compare);
545 			}
546 		} else {
547 			/* cache not ready or system file, really close */
548 			res = ntfs_inode_real_close(ni);
549 		}
550 	} else
551 		res = 0;
552 #else
553 	res = ntfs_inode_real_close(ni);
554 #endif
555 	return (res);
556 }
557 
558 /**
559  * ntfs_extent_inode_open - load an extent inode and attach it to its base
560  * @base_ni:	base ntfs inode
561  * @mref:	mft reference of the extent inode to load (in little endian)
562  *
563  * First check if the extent inode @mref is already attached to the base ntfs
564  * inode @base_ni, and if so, return a pointer to the attached extent inode.
565  *
566  * If the extent inode is not already attached to the base inode, allocate an
567  * ntfs_inode structure and initialize it for the given inode @mref. @mref
568  * specifies the inode number / mft record to read, including the sequence
569  * number, which can be 0 if no sequence number checking is to be performed.
570  *
571  * Then, allocate a buffer for the mft record, read the mft record from the
572  * volume @base_ni->vol, and attach it to the ntfs_inode structure (->mrec).
573  * The mft record is mst deprotected and sanity checked for validity and we
574  * abort if deprotection or checks fail.
575  *
576  * Finally attach the ntfs inode to its base inode @base_ni and return a
577  * pointer to the ntfs_inode structure on success or NULL on error, with errno
578  * set to the error code.
579  *
580  * Note, extent inodes are never closed directly. They are automatically
581  * disposed off by the closing of the base inode.
582  */
583 ntfs_inode *ntfs_extent_inode_open(ntfs_inode *base_ni, const leMFT_REF mref)
584 {
585 	u64 mft_no = MREF_LE(mref);
586 	VCN extent_vcn;
587 	runlist_element *rl;
588 	ntfs_volume *vol;
589 	ntfs_inode *ni = NULL;
590 	ntfs_inode **extent_nis;
591 	int i;
592 
593 	if (!base_ni) {
594 		errno = EINVAL;
595 		ntfs_log_perror("%s", __FUNCTION__);
596 		return NULL;
597 	}
598 
599 	ntfs_log_enter("Opening extent inode %lld (base mft record %lld).\n",
600 			(unsigned long long)mft_no,
601 			(unsigned long long)base_ni->mft_no);
602 
603 	if (!base_ni->mft_no) {
604 			/*
605 			 * When getting extents of MFT, we must be sure
606 			 * they are in the MFT part which has already
607 			 * been mapped, otherwise we fall into an endless
608 			 * recursion.
609 			 * Situations have been met where extents locations
610 			 * are described in themselves.
611 			 * This is a severe error which chkdsk cannot fix.
612 			 */
613 		vol = base_ni->vol;
614 		extent_vcn = mft_no << vol->mft_record_size_bits
615 				>> vol->cluster_size_bits;
616 		rl = vol->mft_na->rl;
617 		if (rl) {
618 			while (rl->length
619 			    && ((rl->vcn + rl->length) <= extent_vcn))
620 				rl++;
621 		}
622 		if (!rl || (rl->lcn < 0)) {
623 			ntfs_log_error("MFT is corrupt, cannot read"
624 				" its unmapped extent record %lld\n",
625 					(long long)mft_no);
626 			ntfs_log_error("Note : chkdsk cannot fix this,"
627 				" try ntfsfix\n");
628 			errno = EIO;
629 			ni = (ntfs_inode*)NULL;
630 			goto out;
631 		}
632 	}
633 
634 	/* Is the extent inode already open and attached to the base inode? */
635 	if (base_ni->nr_extents > 0) {
636 		extent_nis = base_ni->extent_nis;
637 		for (i = 0; i < base_ni->nr_extents; i++) {
638 			u16 seq_no;
639 
640 			ni = extent_nis[i];
641 			if (mft_no != ni->mft_no)
642 				continue;
643 			/* Verify the sequence number if given. */
644 			seq_no = MSEQNO_LE(mref);
645 			if (seq_no && seq_no != le16_to_cpu(
646 					ni->mrec->sequence_number)) {
647 				errno = EIO;
648 				ntfs_log_perror("Found stale extent mft "
649 					"reference mft=%lld",
650 					(long long)ni->mft_no);
651 				goto out;
652 			}
653 			goto out;
654 		}
655 	}
656 	/* Wasn't there, we need to load the extent inode. */
657 	ni = __ntfs_inode_allocate(base_ni->vol);
658 	if (!ni)
659 		goto out;
660 	if (ntfs_file_record_read(base_ni->vol, le64_to_cpu(mref), &ni->mrec, NULL))
661 		goto err_out;
662 	ni->mft_no = mft_no;
663 	ni->nr_extents = -1;
664 	ni->base_ni = base_ni;
665 	/* Attach extent inode to base inode, reallocating memory if needed. */
666 	if (!(base_ni->nr_extents & 3)) {
667 		i = (base_ni->nr_extents + 4) * sizeof(ntfs_inode *);
668 
669 		extent_nis = ntfs_malloc(i);
670 		if (!extent_nis)
671 			goto err_out;
672 		if (base_ni->nr_extents) {
673 			memcpy(extent_nis, base_ni->extent_nis,
674 					i - 4 * sizeof(ntfs_inode *));
675 			free(base_ni->extent_nis);
676 		}
677 		base_ni->extent_nis = extent_nis;
678 	}
679 	base_ni->extent_nis[base_ni->nr_extents++] = ni;
680 out:
681 	ntfs_log_leave("\n");
682 	return ni;
683 err_out:
684 	__ntfs_inode_release(ni);
685 	ni = NULL;
686 	goto out;
687 }
688 
689 /**
690  * ntfs_inode_attach_all_extents - attach all extents for target inode
691  * @ni:		opened ntfs inode for which perform attach
692  *
693  * Return 0 on success and -1 on error with errno set to the error code.
694  */
695 int ntfs_inode_attach_all_extents(ntfs_inode *ni)
696 {
697 	ATTR_LIST_ENTRY *ale;
698 	u64 prev_attached = 0;
699 
700 	if (!ni) {
701 		ntfs_log_trace("Invalid arguments.\n");
702 		errno = EINVAL;
703 		return -1;
704 	}
705 
706 	if (ni->nr_extents == -1)
707 		ni = ni->base_ni;
708 
709 	ntfs_log_trace("Entering for inode 0x%llx.\n", (long long) ni->mft_no);
710 
711 	/* Inode haven't got attribute list, thus nothing to attach. */
712 	if (!NInoAttrList(ni))
713 		return 0;
714 
715 	if (!ni->attr_list) {
716 		ntfs_log_trace("Corrupt in-memory struct.\n");
717 		errno = EINVAL;
718 		return -1;
719 	}
720 
721 	/* Walk through attribute list and attach all extents. */
722 	errno = 0;
723 	ale = (ATTR_LIST_ENTRY *)ni->attr_list;
724 	while ((u8*)ale < ni->attr_list + ni->attr_list_size) {
725 		if (ni->mft_no != MREF_LE(ale->mft_reference) &&
726 				prev_attached != MREF_LE(ale->mft_reference)) {
727 			if (!ntfs_extent_inode_open(ni, ale->mft_reference)) {
728 				ntfs_log_trace("Couldn't attach extent inode.\n");
729 				return -1;
730 			}
731 			prev_attached = MREF_LE(ale->mft_reference);
732 		}
733 		ale = (ATTR_LIST_ENTRY *)((u8*)ale + le16_to_cpu(ale->length));
734 	}
735 	return 0;
736 }
737 
738 /**
739  * ntfs_inode_sync_standard_information - update standard information attribute
740  * @ni:		ntfs inode to update standard information
741  *
742  * Return 0 on success or -1 on error with errno set to the error code.
743  */
744 static int ntfs_inode_sync_standard_information(ntfs_inode *ni)
745 {
746 	ntfs_attr_search_ctx *ctx;
747 	STANDARD_INFORMATION *std_info;
748 	u32 lth;
749 	le32 lthle;
750 
751 	ntfs_log_trace("Entering for inode %lld\n", (long long)ni->mft_no);
752 
753 	ctx = ntfs_attr_get_search_ctx(ni, NULL);
754 	if (!ctx)
755 		return -1;
756 	if (ntfs_attr_lookup(AT_STANDARD_INFORMATION, AT_UNNAMED,
757 			     0, CASE_SENSITIVE, 0, NULL, 0, ctx)) {
758 		ntfs_log_perror("Failed to sync standard info (inode %lld)",
759 				(long long)ni->mft_no);
760 		ntfs_attr_put_search_ctx(ctx);
761 		return -1;
762 	}
763 	std_info = (STANDARD_INFORMATION *)((u8 *)ctx->attr +
764 			le16_to_cpu(ctx->attr->value_offset));
765 	std_info->file_attributes = ni->flags;
766 	if (!test_nino_flag(ni, TimesSet)) {
767 		std_info->creation_time = ni->creation_time;
768 		std_info->last_data_change_time = ni->last_data_change_time;
769 		std_info->last_mft_change_time = ni->last_mft_change_time;
770 		std_info->last_access_time = ni->last_access_time;
771 	}
772 
773 		/* JPA update v3.x extensions, ensuring consistency */
774 
775 	lthle = ctx->attr->value_length;
776 	lth = le32_to_cpu(lthle);
777 	if (test_nino_flag(ni, v3_Extensions)
778 	    && (lth < offsetof(STANDARD_INFORMATION, v3_end)))
779 		ntfs_log_error("bad sync of standard information\n");
780 
781 	if (lth >= offsetof(STANDARD_INFORMATION, v3_end)) {
782 		std_info->owner_id = ni->owner_id;
783 		std_info->security_id = ni->security_id;
784 		std_info->quota_charged = ni->quota_charged;
785 		std_info->usn = ni->usn;
786 	}
787 	ntfs_inode_mark_dirty(ctx->ntfs_ino);
788 	ntfs_attr_put_search_ctx(ctx);
789 	return 0;
790 }
791 
792 /**
793  * ntfs_inode_sync_file_name - update FILE_NAME attributes
794  * @ni:		ntfs inode to update FILE_NAME attributes
795  *
796  * Update all FILE_NAME attributes for inode @ni in the index.
797  *
798  * Return 0 on success or -1 on error with errno set to the error code.
799  */
800 static int ntfs_inode_sync_file_name(ntfs_inode *ni, ntfs_inode *dir_ni)
801 {
802 	ntfs_attr_search_ctx *ctx = NULL;
803 	ntfs_index_context *ictx;
804 	ntfs_inode *index_ni;
805 	FILE_NAME_ATTR *fn;
806 	FILE_NAME_ATTR *fnx;
807 	REPARSE_POINT *rpp;
808 	le32 reparse_tag;
809 	int err = 0;
810 
811 	ntfs_log_trace("Entering for inode %lld\n", (long long)ni->mft_no);
812 
813 	ctx = ntfs_attr_get_search_ctx(ni, NULL);
814 	if (!ctx) {
815 		err = errno;
816 		goto err_out;
817 	}
818 	/* Collect the reparse tag, if any */
819 	reparse_tag = const_cpu_to_le32(0);
820 	if (ni->flags & FILE_ATTR_REPARSE_POINT) {
821 		if (!ntfs_attr_lookup(AT_REPARSE_POINT, NULL,
822 				0, CASE_SENSITIVE, 0, NULL, 0, ctx)) {
823 			rpp = (REPARSE_POINT*)((u8 *)ctx->attr +
824 					le16_to_cpu(ctx->attr->value_offset));
825 			reparse_tag = rpp->reparse_tag;
826 		}
827 		ntfs_attr_reinit_search_ctx(ctx);
828 	}
829 	/* Walk through all FILE_NAME attributes and update them. */
830 	while (!ntfs_attr_lookup(AT_FILE_NAME, NULL, 0, 0, 0, NULL, 0, ctx)) {
831 		fn = (FILE_NAME_ATTR *)((u8 *)ctx->attr +
832 				le16_to_cpu(ctx->attr->value_offset));
833 		if (MREF_LE(fn->parent_directory) == ni->mft_no) {
834 			/*
835 			 * WARNING: We cheat here and obtain 2 attribute
836 			 * search contexts for one inode (first we obtained
837 			 * above, second will be obtained inside
838 			 * ntfs_index_lookup), it's acceptable for library,
839 			 * but will deadlock in the kernel.
840 			 */
841 			index_ni = ni;
842 		} else
843 			if (dir_ni)
844 				index_ni = dir_ni;
845 			else
846 				index_ni = ntfs_inode_open(ni->vol,
847 					le64_to_cpu(fn->parent_directory));
848 		if (!index_ni) {
849 			if (!err)
850 				err = errno;
851 			ntfs_log_perror("Failed to open inode %lld with index",
852 				(long long)MREF_LE(fn->parent_directory));
853 			continue;
854 		}
855 		ictx = ntfs_index_ctx_get(index_ni, NTFS_INDEX_I30, 4);
856 		if (!ictx) {
857 			if (!err)
858 				err = errno;
859 			ntfs_log_perror("Failed to get index ctx, inode %lld",
860 					(long long)index_ni->mft_no);
861 			if ((ni != index_ni) && !dir_ni
862 			    && ntfs_inode_close(index_ni) && !err)
863 				err = errno;
864 			continue;
865 		}
866 		if (ntfs_index_lookup(fn, sizeof(FILE_NAME_ATTR), ictx)) {
867 			if (!err) {
868 				if (errno == ENOENT)
869 					err = EIO;
870 				else
871 					err = errno;
872 			}
873 			ntfs_log_perror("Index lookup failed, inode %lld",
874 					(long long)index_ni->mft_no);
875 			ntfs_index_ctx_put(ictx);
876 			if (ni != index_ni && ntfs_inode_close(index_ni) && !err)
877 				err = errno;
878 			continue;
879 		}
880 		/* Update flags and file size. */
881 		fnx = (FILE_NAME_ATTR *)ictx->data;
882 		fnx->file_attributes =
883 				(fnx->file_attributes & ~FILE_ATTR_VALID_FLAGS) |
884 				(ni->flags & FILE_ATTR_VALID_FLAGS);
885 		if (ni->mrec->flags & MFT_RECORD_IS_DIRECTORY)
886 			fnx->data_size = fnx->allocated_size
887 				= const_cpu_to_sle64(0);
888 		else {
889 			fnx->allocated_size = cpu_to_sle64(ni->allocated_size);
890 			fnx->data_size = cpu_to_sle64(ni->data_size);
891 			/*
892 			 * The file name record has also to be fixed if some
893 			 * attribute update implied the unnamed data to be
894 			 * made non-resident
895 			 */
896 			fn->allocated_size = fnx->allocated_size;
897 		}
898 			/* update or clear the reparse tag in the index */
899 		fnx->reparse_point_tag = reparse_tag;
900 		if (!test_nino_flag(ni, TimesSet)) {
901 			fnx->creation_time = ni->creation_time;
902 			fnx->last_data_change_time = ni->last_data_change_time;
903 			fnx->last_mft_change_time = ni->last_mft_change_time;
904 			fnx->last_access_time = ni->last_access_time;
905 		} else {
906 			fnx->creation_time = fn->creation_time;
907 			fnx->last_data_change_time = fn->last_data_change_time;
908 			fnx->last_mft_change_time = fn->last_mft_change_time;
909 			fnx->last_access_time = fn->last_access_time;
910 		}
911 		ntfs_index_entry_mark_dirty(ictx);
912 		ntfs_index_ctx_put(ictx);
913 		if ((ni != index_ni) && !dir_ni
914 		    && ntfs_inode_close(index_ni) && !err)
915 			err = errno;
916 	}
917 	/* Check for real error occurred. */
918 	if (errno != ENOENT) {
919 		err = errno;
920 		ntfs_log_perror("Attribute lookup failed, inode %lld",
921 				(long long)ni->mft_no);
922 		goto err_out;
923 	}
924 	ntfs_attr_put_search_ctx(ctx);
925 	if (err) {
926 		errno = err;
927 		return -1;
928 	}
929 	return 0;
930 err_out:
931 	if (ctx)
932 		ntfs_attr_put_search_ctx(ctx);
933 	errno = err;
934 	return -1;
935 }
936 
937 /**
938  * ntfs_inode_sync - write the inode (and its dirty extents) to disk
939  * @ni:		ntfs inode to write
940  *
941  * Write the inode @ni to disk as well as its dirty extent inodes if such
942  * exist and @ni is a base inode. If @ni is an extent inode, only @ni is
943  * written completely disregarding its base inode and any other extent inodes.
944  *
945  * For a base inode with dirty extent inodes if any writes fail for whatever
946  * reason, the failing inode is skipped and the sync process is continued. At
947  * the end the error condition that brought about the failure is returned. Thus
948  * the smallest amount of data loss possible occurs.
949  *
950  * Return 0 on success or -1 on error with errno set to the error code.
951  * The following error codes are defined:
952  *	EINVAL	- Invalid arguments were passed to the function.
953  *	EBUSY	- Inode and/or one of its extents is busy, try again later.
954  *	EIO	- I/O error while writing the inode (or one of its extents).
955  */
956 static int ntfs_inode_sync_in_dir(ntfs_inode *ni, ntfs_inode *dir_ni)
957 {
958 	int ret = 0;
959 	int err = 0;
960 	if (!ni) {
961 		errno = EINVAL;
962 		ntfs_log_error("Failed to sync NULL inode\n");
963 		return -1;
964 	}
965 
966 	ntfs_log_enter("Entering for inode %lld\n", (long long)ni->mft_no);
967 
968 	/* Update STANDARD_INFORMATION. */
969 	if ((ni->mrec->flags & MFT_RECORD_IN_USE) && ni->nr_extents != -1 &&
970 			ntfs_inode_sync_standard_information(ni)) {
971 		if (!err || errno == EIO) {
972 			err = errno;
973 			if (err != EIO)
974 				err = EBUSY;
975 		}
976 	}
977 
978 	/* Update FILE_NAME's in the index. */
979 	if ((ni->mrec->flags & MFT_RECORD_IN_USE) && ni->nr_extents != -1 &&
980 			NInoFileNameTestAndClearDirty(ni) &&
981 			ntfs_inode_sync_file_name(ni, dir_ni)) {
982 		if (!err || errno == EIO) {
983 			err = errno;
984 			if (err != EIO)
985 				err = EBUSY;
986 		}
987 		ntfs_log_perror("Failed to sync FILE_NAME (inode %lld)",
988 				(long long)ni->mft_no);
989 		NInoFileNameSetDirty(ni);
990 	}
991 
992 	/* Write out attribute list from cache to disk. */
993 	if ((ni->mrec->flags & MFT_RECORD_IN_USE) && ni->nr_extents != -1 &&
994 			NInoAttrList(ni) && NInoAttrListTestAndClearDirty(ni)) {
995 		ntfs_attr *na;
996 
997 		na = ntfs_attr_open(ni, AT_ATTRIBUTE_LIST, AT_UNNAMED, 0);
998 		if (!na) {
999 			if (!err || errno == EIO) {
1000 				err = errno;
1001 				if (err != EIO)
1002 					err = EBUSY;
1003 				ntfs_log_perror("Attribute list sync failed "
1004 						"(open, inode %lld)",
1005 						(long long)ni->mft_no);
1006 			}
1007 			NInoAttrListSetDirty(ni);
1008 			goto sync_inode;
1009 		}
1010 
1011 		if (na->data_size == ni->attr_list_size) {
1012 			if (ntfs_attr_pwrite(na, 0, ni->attr_list_size,
1013 				        ni->attr_list) != ni->attr_list_size) {
1014 				if (!err || errno == EIO) {
1015 					err = errno;
1016 					if (err != EIO)
1017 						err = EBUSY;
1018 					ntfs_log_perror("Attribute list sync "
1019 						"failed (write, inode %lld)",
1020 						(long long)ni->mft_no);
1021 				}
1022 				NInoAttrListSetDirty(ni);
1023 			}
1024 		} else {
1025 			err = EIO;
1026 			ntfs_log_error("Attribute list sync failed (bad size, "
1027 				       "inode %lld)\n", (long long)ni->mft_no);
1028 			NInoAttrListSetDirty(ni);
1029 		}
1030 		ntfs_attr_close(na);
1031 	}
1032 
1033 sync_inode:
1034 	/* Write this inode out to the $MFT (and $MFTMirr if applicable). */
1035 	if (NInoTestAndClearDirty(ni)) {
1036 		if (ntfs_mft_record_write(ni->vol, ni->mft_no, ni->mrec)) {
1037 			if (!err || errno == EIO) {
1038 				err = errno;
1039 				if (err != EIO)
1040 					err = EBUSY;
1041 			}
1042 			NInoSetDirty(ni);
1043 			ntfs_log_perror("MFT record sync failed, inode %lld",
1044 					(long long)ni->mft_no);
1045 		}
1046 	}
1047 
1048 	/* If this is a base inode with extents write all dirty extents, too. */
1049 	if (ni->nr_extents > 0) {
1050 		s32 i;
1051 
1052 		for (i = 0; i < ni->nr_extents; ++i) {
1053 			ntfs_inode *eni;
1054 
1055 			eni = ni->extent_nis[i];
1056 			if (!NInoTestAndClearDirty(eni))
1057 				continue;
1058 
1059 			if (ntfs_mft_record_write(eni->vol, eni->mft_no,
1060 						  eni->mrec)) {
1061 				if (!err || errno == EIO) {
1062 					err = errno;
1063 					if (err != EIO)
1064 						err = EBUSY;
1065 				}
1066 				NInoSetDirty(eni);
1067 				ntfs_log_perror("Extent MFT record sync failed,"
1068 						" inode %lld/%lld",
1069 						(long long)ni->mft_no,
1070 						(long long)eni->mft_no);
1071 			}
1072 		}
1073 	}
1074 
1075 	if (err) {
1076 		errno = err;
1077 		ret = -1;
1078 	}
1079 
1080 	ntfs_log_leave("\n");
1081 	return ret;
1082 }
1083 
1084 int ntfs_inode_sync(ntfs_inode *ni)
1085 {
1086 	return (ntfs_inode_sync_in_dir(ni, (ntfs_inode*)NULL));
1087 }
1088 
1089 /*
1090  *		Close an inode with an open parent inode
1091  */
1092 
1093 int ntfs_inode_close_in_dir(ntfs_inode *ni, ntfs_inode *dir_ni)
1094 {
1095 	int res;
1096 
1097 	res = ntfs_inode_sync_in_dir(ni, dir_ni);
1098 	if (res) {
1099 		if (errno != EIO)
1100 			errno = EBUSY;
1101 	} else
1102 		res = ntfs_inode_close(ni);
1103 	return (res);
1104 }
1105 
1106 /**
1107  * ntfs_inode_add_attrlist - add attribute list to inode and fill it
1108  * @ni: opened ntfs inode to which add attribute list
1109  *
1110  * Return 0 on success or -1 on error with errno set to the error code.
1111  * The following error codes are defined:
1112  *	EINVAL	- Invalid arguments were passed to the function.
1113  *	EEXIST	- Attribute list already exist.
1114  *	EIO	- Input/Ouput error occurred.
1115  *	ENOMEM	- Not enough memory to perform add.
1116  */
1117 int ntfs_inode_add_attrlist(ntfs_inode *ni)
1118 {
1119 	int err;
1120 	ntfs_attr_search_ctx *ctx;
1121 	u8 *al = NULL, *aln;
1122 	int al_len = 0;
1123 	ATTR_LIST_ENTRY *ale = NULL;
1124 	ntfs_attr *na;
1125 
1126 	if (!ni) {
1127 		errno = EINVAL;
1128 		ntfs_log_perror("%s", __FUNCTION__);
1129 		return -1;
1130 	}
1131 
1132 	ntfs_log_trace("inode %llu\n", (unsigned long long) ni->mft_no);
1133 
1134 	if (NInoAttrList(ni) || ni->nr_extents) {
1135 		errno = EEXIST;
1136 		ntfs_log_perror("Inode already has attribute list");
1137 		return -1;
1138 	}
1139 
1140 	/* Form attribute list. */
1141 	ctx = ntfs_attr_get_search_ctx(ni, NULL);
1142 	if (!ctx) {
1143 		err = errno;
1144 		goto err_out;
1145 	}
1146 	/* Walk through all attributes. */
1147 	while (!ntfs_attr_lookup(AT_UNUSED, NULL, 0, 0, 0, NULL, 0, ctx)) {
1148 
1149 		int ale_size;
1150 
1151 		if (ctx->attr->type == AT_ATTRIBUTE_LIST) {
1152 			err = EIO;
1153 			ntfs_log_perror("Attribute list already present");
1154 			goto put_err_out;
1155 		}
1156 
1157 		ale_size = (sizeof(ATTR_LIST_ENTRY) + sizeof(ntfschar) *
1158 					ctx->attr->name_length + 7) & ~7;
1159 		al_len += ale_size;
1160 
1161 		aln = realloc(al, al_len);
1162 		if (!aln) {
1163 			err = errno;
1164 			ntfs_log_perror("Failed to realloc %d bytes", al_len);
1165 			goto put_err_out;
1166 		}
1167 		ale = (ATTR_LIST_ENTRY *)(aln + ((u8 *)ale - al));
1168 		al = aln;
1169 
1170 		memset(ale, 0, ale_size);
1171 
1172 		/* Add attribute to attribute list. */
1173 		ale->type = ctx->attr->type;
1174 		ale->length = cpu_to_le16((sizeof(ATTR_LIST_ENTRY) +
1175 			sizeof(ntfschar) * ctx->attr->name_length + 7) & ~7);
1176 		ale->name_length = ctx->attr->name_length;
1177 		ale->name_offset = (u8 *)ale->name - (u8 *)ale;
1178 		if (ctx->attr->non_resident)
1179 			ale->lowest_vcn = ctx->attr->lowest_vcn;
1180 		else
1181 			ale->lowest_vcn = const_cpu_to_sle64(0);
1182 		ale->mft_reference = MK_LE_MREF(ni->mft_no,
1183 			le16_to_cpu(ni->mrec->sequence_number));
1184 		ale->instance = ctx->attr->instance;
1185 		memcpy(ale->name, (u8 *)ctx->attr +
1186 				le16_to_cpu(ctx->attr->name_offset),
1187 				ctx->attr->name_length * sizeof(ntfschar));
1188 		ale = (ATTR_LIST_ENTRY *)(al + al_len);
1189 	}
1190 	/* Check for real error occurred. */
1191 	if (errno != ENOENT) {
1192 		err = errno;
1193 		ntfs_log_perror("%s: Attribute lookup failed, inode %lld",
1194 				__FUNCTION__, (long long)ni->mft_no);
1195 		goto put_err_out;
1196 	}
1197 
1198 	/* Set in-memory attribute list. */
1199 	ni->attr_list = al;
1200 	ni->attr_list_size = al_len;
1201 	NInoSetAttrList(ni);
1202 	NInoAttrListSetDirty(ni);
1203 
1204 	/* Free space if there is not enough it for $ATTRIBUTE_LIST. */
1205 	if (le32_to_cpu(ni->mrec->bytes_allocated) -
1206 			le32_to_cpu(ni->mrec->bytes_in_use) <
1207 			offsetof(ATTR_RECORD, resident_end)) {
1208 		if (ntfs_inode_free_space(ni,
1209 				offsetof(ATTR_RECORD, resident_end))) {
1210 			/* Failed to free space. */
1211 			err = errno;
1212 			ntfs_log_perror("Failed to free space for attrlist");
1213 			goto rollback;
1214 		}
1215 	}
1216 
1217 	/* Add $ATTRIBUTE_LIST to mft record. */
1218 	if (ntfs_resident_attr_record_add(ni,
1219 				AT_ATTRIBUTE_LIST, NULL, 0, NULL, 0, const_cpu_to_le16(0)) < 0) {
1220 		err = errno;
1221 		ntfs_log_perror("Couldn't add $ATTRIBUTE_LIST to MFT");
1222 		goto rollback;
1223 	}
1224 
1225 	/* Resize it. */
1226 	na = ntfs_attr_open(ni, AT_ATTRIBUTE_LIST, AT_UNNAMED, 0);
1227 	if (!na) {
1228 		err = errno;
1229 		ntfs_log_perror("Failed to open just added $ATTRIBUTE_LIST");
1230 		goto remove_attrlist_record;
1231 	}
1232 	if (ntfs_attr_truncate(na, al_len)) {
1233 		err = errno;
1234 		ntfs_log_perror("Failed to resize just added $ATTRIBUTE_LIST");
1235 		ntfs_attr_close(na);
1236 		goto remove_attrlist_record;;
1237 	}
1238 
1239 	ntfs_attr_put_search_ctx(ctx);
1240 	ntfs_attr_close(na);
1241 	return 0;
1242 
1243 remove_attrlist_record:
1244 	/* Prevent ntfs_attr_recorm_rm from freeing attribute list. */
1245 	ni->attr_list = NULL;
1246 	NInoClearAttrList(ni);
1247 	/* Remove $ATTRIBUTE_LIST record. */
1248 	ntfs_attr_reinit_search_ctx(ctx);
1249 	if (!ntfs_attr_lookup(AT_ATTRIBUTE_LIST, NULL, 0,
1250 				CASE_SENSITIVE, 0, NULL, 0, ctx)) {
1251 		if (ntfs_attr_record_rm(ctx))
1252 			ntfs_log_perror("Rollback failed to remove attrlist");
1253 	} else
1254 		ntfs_log_perror("Rollback failed to find attrlist");
1255 	/* Setup back in-memory runlist. */
1256 	ni->attr_list = al;
1257 	ni->attr_list_size = al_len;
1258 	NInoSetAttrList(ni);
1259 rollback:
1260 	/*
1261 	 * Scan attribute list for attributes that placed not in the base MFT
1262 	 * record and move them to it.
1263 	 */
1264 	ntfs_attr_reinit_search_ctx(ctx);
1265 	ale = (ATTR_LIST_ENTRY*)al;
1266 	while ((u8*)ale < al + al_len) {
1267 		if (MREF_LE(ale->mft_reference) != ni->mft_no) {
1268 			if (!ntfs_attr_lookup(ale->type, ale->name,
1269 						ale->name_length,
1270 						CASE_SENSITIVE,
1271 						sle64_to_cpu(ale->lowest_vcn),
1272 						NULL, 0, ctx)) {
1273 				if (ntfs_attr_record_move_to(ctx, ni))
1274 					ntfs_log_perror("Rollback failed to "
1275 							"move attribute");
1276 			} else
1277 				ntfs_log_perror("Rollback failed to find attr");
1278 			ntfs_attr_reinit_search_ctx(ctx);
1279 		}
1280 		ale = (ATTR_LIST_ENTRY*)((u8*)ale + le16_to_cpu(ale->length));
1281 	}
1282 	/* Remove in-memory attribute list. */
1283 	ni->attr_list = NULL;
1284 	ni->attr_list_size = 0;
1285 	NInoClearAttrList(ni);
1286 	NInoAttrListClearDirty(ni);
1287 put_err_out:
1288 	ntfs_attr_put_search_ctx(ctx);
1289 err_out:
1290 	free(al);
1291 	errno = err;
1292 	return -1;
1293 }
1294 
1295 /**
1296  * ntfs_inode_free_space - free space in the MFT record of an inode
1297  * @ni:		ntfs inode in which MFT record needs more free space
1298  * @size:	amount of space needed to free
1299  *
1300  * Return 0 on success or -1 on error with errno set to the error code.
1301  */
1302 int ntfs_inode_free_space(ntfs_inode *ni, int size)
1303 {
1304 	ntfs_attr_search_ctx *ctx;
1305 	int freed;
1306 
1307 	if (!ni || size < 0) {
1308 		errno = EINVAL;
1309 		ntfs_log_perror("%s: ni=%p size=%d", __FUNCTION__, ni, size);
1310 		return -1;
1311 	}
1312 
1313 	ntfs_log_trace("Entering for inode %lld, size %d\n",
1314 		       (unsigned long long)ni->mft_no, size);
1315 
1316 	freed = (le32_to_cpu(ni->mrec->bytes_allocated) -
1317 				le32_to_cpu(ni->mrec->bytes_in_use));
1318 
1319 	if (size <= freed)
1320 		return 0;
1321 
1322 	ctx = ntfs_attr_get_search_ctx(ni, NULL);
1323 	if (!ctx)
1324 		return -1;
1325 	/*
1326 	 * $STANDARD_INFORMATION and $ATTRIBUTE_LIST must stay in the base MFT
1327 	 * record, so position search context on the first attribute after them.
1328 	 */
1329 	if (ntfs_attr_position(AT_FILE_NAME, ctx))
1330 		goto put_err_out;
1331 
1332 	while (1) {
1333 		int record_size;
1334 		/*
1335 		 * Check whether attribute is from different MFT record. If so,
1336 		 * find next, because we don't need such.
1337 		 */
1338 		while (ctx->ntfs_ino->mft_no != ni->mft_no) {
1339 retry:
1340 			if (ntfs_attr_position(AT_UNUSED, ctx))
1341 				goto put_err_out;
1342 		}
1343 
1344 		if (ntfs_inode_base(ctx->ntfs_ino)->mft_no == FILE_MFT &&
1345 		    ctx->attr->type == AT_DATA)
1346 			goto retry;
1347 
1348 		if (ctx->attr->type == AT_INDEX_ROOT)
1349 			goto retry;
1350 
1351 		record_size = le32_to_cpu(ctx->attr->length);
1352 
1353 		if (ntfs_attr_record_move_away(ctx, 0)) {
1354 			ntfs_log_perror("Failed to move out attribute #2");
1355 			break;
1356 		}
1357 		freed += record_size;
1358 
1359 		/* Check whether we are done. */
1360 		if (size <= freed) {
1361 			ntfs_attr_put_search_ctx(ctx);
1362 			return 0;
1363 		}
1364 		/*
1365 		 * Reposition to first attribute after $STANDARD_INFORMATION
1366 		 * and $ATTRIBUTE_LIST instead of simply skipping this attribute
1367 		 * because in the case when we have got only in-memory attribute
1368 		 * list then ntfs_attr_lookup will fail when it tries to find
1369 		 * $ATTRIBUTE_LIST.
1370 		 */
1371 		ntfs_attr_reinit_search_ctx(ctx);
1372 		if (ntfs_attr_position(AT_FILE_NAME, ctx))
1373 			break;
1374 	}
1375 put_err_out:
1376 	ntfs_attr_put_search_ctx(ctx);
1377 	if (errno == ENOSPC)
1378 		ntfs_log_trace("No attributes left that could be moved out.\n");
1379 	return -1;
1380 }
1381 
1382 /**
1383  * ntfs_inode_update_times - update selected time fields for ntfs inode
1384  * @ni:		ntfs inode for which update time fields
1385  * @mask:	select which time fields should be updated
1386  *
1387  * This function updates time fields to current time. Fields to update are
1388  * selected using @mask (see enum @ntfs_time_update_flags for posssible values).
1389  */
1390 void ntfs_inode_update_times(ntfs_inode *ni, ntfs_time_update_flags mask)
1391 {
1392 	ntfs_time now;
1393 
1394 	if (!ni) {
1395 		ntfs_log_error("%s(): Invalid arguments.\n", __FUNCTION__);
1396 		return;
1397 	}
1398 
1399 	if ((ni->mft_no < FILE_first_user && ni->mft_no != FILE_root) ||
1400 			NVolReadOnly(ni->vol) || !mask)
1401 		return;
1402 
1403 	now = ntfs_current_time();
1404 	if (mask & NTFS_UPDATE_ATIME)
1405 		ni->last_access_time = now;
1406 	if (mask & NTFS_UPDATE_MTIME)
1407 		ni->last_data_change_time = now;
1408 	if (mask & NTFS_UPDATE_CTIME)
1409 		ni->last_mft_change_time = now;
1410 
1411 	NInoFileNameSetDirty(ni);
1412 	NInoSetDirty(ni);
1413 }
1414 
1415 /**
1416  * ntfs_inode_badclus_bad - check for $Badclus:$Bad data attribute
1417  * @mft_no:		mft record number where @attr is present
1418  * @attr:		attribute record used to check for the $Bad attribute
1419  *
1420  * Check if the mft record given by @mft_no and @attr contains the bad sector
1421  * list. Please note that mft record numbers describing $Badclus extent inodes
1422  * will not match the current $Badclus:$Bad check.
1423  *
1424  * On success return 1 if the file is $Badclus:$Bad, otherwise return 0.
1425  * On error return -1 with errno set to the error code.
1426  */
1427 int ntfs_inode_badclus_bad(u64 mft_no, ATTR_RECORD *attr)
1428 {
1429 	int len, ret = 0;
1430 	ntfschar *ustr;
1431 
1432 	if (!attr) {
1433 		ntfs_log_error("Invalid argument.\n");
1434 		errno = EINVAL;
1435 		return -1;
1436 	}
1437 
1438 	if (mft_no != FILE_BadClus)
1439 	       	return 0;
1440 
1441 	if (attr->type != AT_DATA)
1442 	       	return 0;
1443 
1444 	if ((ustr = ntfs_str2ucs("$Bad", &len)) == NULL) {
1445 		ntfs_log_perror("Couldn't convert '$Bad' to Unicode");
1446 		return -1;
1447 	}
1448 
1449 	if (ustr && ntfs_names_are_equal(ustr, len,
1450 			(ntfschar *)((u8 *)attr + le16_to_cpu(attr->name_offset)),
1451 			attr->name_length, 0, NULL, 0))
1452 		ret = 1;
1453 
1454 	ntfs_ucsfree(ustr);
1455 
1456 	return ret;
1457 }
1458 
1459 /*
1460  *		Get high precision NTFS times
1461  *
1462  *	They are returned in following order : create, update, access, change
1463  *	provided they fit in requested size.
1464  *
1465  *	Returns the modified size if successfull (or 32 if buffer size is null)
1466  *		-errno if failed
1467  */
1468 
1469 int ntfs_inode_get_times(ntfs_inode *ni, char *value, size_t size)
1470 {
1471 	ntfs_attr_search_ctx *ctx;
1472 	STANDARD_INFORMATION *std_info;
1473 	u64 *times;
1474 	int ret;
1475 
1476 	ret = 0;
1477 	ctx = ntfs_attr_get_search_ctx(ni, NULL);
1478 	if (ctx) {
1479 		if (ntfs_attr_lookup(AT_STANDARD_INFORMATION, AT_UNNAMED,
1480 				     0, CASE_SENSITIVE, 0, NULL, 0, ctx)) {
1481 			ntfs_log_perror("Failed to get standard info (inode %lld)",
1482 					(long long)ni->mft_no);
1483 		} else {
1484 			std_info = (STANDARD_INFORMATION *)((u8 *)ctx->attr +
1485 					le16_to_cpu(ctx->attr->value_offset));
1486 			if (value && (size >= 8)) {
1487 				times = (u64*)value;
1488 				times[0] = sle64_to_cpu(std_info->creation_time);
1489 				ret = 8;
1490 				if (size >= 16) {
1491 					times[1] = sle64_to_cpu(std_info->last_data_change_time);
1492 					ret = 16;
1493 				}
1494 				if (size >= 24) {
1495 					times[2] = sle64_to_cpu(std_info->last_access_time);
1496 					ret = 24;
1497 				}
1498 				if (size >= 32) {
1499 					times[3] = sle64_to_cpu(std_info->last_mft_change_time);
1500 					ret = 32;
1501 				}
1502 			} else
1503 				if (!size)
1504 					ret = 32;
1505 				else
1506 					ret = -ERANGE;
1507 			}
1508 		ntfs_attr_put_search_ctx(ctx);
1509 	}
1510 	return (ret ? ret : -errno);
1511 }
1512 
1513 /*
1514  *		Set high precision NTFS times
1515  *
1516  *	They are expected in this order : create, update, access
1517  *	provided they are present in input. The change time is set to
1518  *	current time.
1519  *
1520  *	The times are inserted directly in the standard_information and
1521  *	file names attributes to avoid manipulating low precision times
1522  *
1523  *	Returns 0 if success
1524  *		-1 if there were an error (described by errno)
1525  */
1526 
1527 int ntfs_inode_set_times(ntfs_inode *ni, const char *value, size_t size,
1528 			int flags)
1529 {
1530 	ntfs_attr_search_ctx *ctx;
1531 	STANDARD_INFORMATION *std_info;
1532 	FILE_NAME_ATTR *fn;
1533 	u64 times[4];
1534 	ntfs_time now;
1535 	int cnt;
1536 	int ret;
1537 
1538 	ret = -1;
1539 	if ((size >= 8) && !(flags & XATTR_CREATE)) {
1540 		/* Copy, to avoid alignment issue encountered on ARM */
1541 		memcpy(times, value,
1542 			(size < sizeof(times) ? size : sizeof(times)));
1543 		now = ntfs_current_time();
1544 			/* update the standard information attribute */
1545 		ctx = ntfs_attr_get_search_ctx(ni, NULL);
1546 		if (ctx) {
1547 			if (ntfs_attr_lookup(AT_STANDARD_INFORMATION,
1548 					AT_UNNAMED, 0, CASE_SENSITIVE,
1549 					0, NULL, 0, ctx)) {
1550 				ntfs_log_perror("Failed to get standard info (inode %lld)",
1551 						(long long)ni->mft_no);
1552 			} else {
1553 				std_info = (STANDARD_INFORMATION *)((u8 *)ctx->attr +
1554 					le16_to_cpu(ctx->attr->value_offset));
1555 				/*
1556 				 * Mark times set to avoid overwriting
1557 				 * them when the inode is closed.
1558 				 * The inode structure must also be updated
1559 				 * (with loss of precision) because of cacheing.
1560 				 * TODO : use NTFS precision in inode, and
1561 				 * return sub-second times in getattr()
1562 				 */
1563 				set_nino_flag(ni, TimesSet);
1564 				std_info->creation_time = cpu_to_sle64(times[0]);
1565 				ni->creation_time
1566 					= std_info->creation_time;
1567 				if (size >= 16) {
1568 					std_info->last_data_change_time = cpu_to_sle64(times[1]);
1569 					ni->last_data_change_time
1570 						= std_info->last_data_change_time;
1571 				}
1572 				if (size >= 24) {
1573 					std_info->last_access_time = cpu_to_sle64(times[2]);
1574 					ni->last_access_time
1575 						= std_info->last_access_time;
1576 				}
1577 				std_info->last_mft_change_time = now;
1578 				ni->last_mft_change_time = now;
1579 				ntfs_inode_mark_dirty(ctx->ntfs_ino);
1580 				NInoFileNameSetDirty(ni);
1581 
1582 				/* update the file names attributes */
1583 				ntfs_attr_reinit_search_ctx(ctx);
1584 				cnt = 0;
1585 				while (!ntfs_attr_lookup(AT_FILE_NAME,
1586 						AT_UNNAMED, 0, CASE_SENSITIVE,
1587 						0, NULL, 0, ctx)) {
1588 					fn = (FILE_NAME_ATTR*)((u8 *)ctx->attr +
1589 						le16_to_cpu(ctx->attr->value_offset));
1590 					fn->creation_time
1591 						= cpu_to_sle64(times[0]);
1592 					if (size >= 16)
1593 						fn->last_data_change_time
1594 							= cpu_to_sle64(times[1]);
1595 					if (size >= 24)
1596 						fn->last_access_time
1597 							= cpu_to_sle64(times[2]);
1598 					fn->last_mft_change_time = now;
1599 					cnt++;
1600 				}
1601 				if (cnt)
1602 					ret = 0;
1603 				else {
1604 					ntfs_log_perror("Failed to get file names (inode %lld)",
1605 						(long long)ni->mft_no);
1606 				}
1607 			}
1608 			ntfs_attr_put_search_ctx(ctx);
1609 		}
1610 	} else
1611 		if (size < 8)
1612 			errno = ERANGE;
1613 		else
1614 			errno = EEXIST;
1615 	return (ret);
1616 }
1617