goto unm_err_out; } if ((a->flags & ATTR_COMPRESSION_MASK) != ATTR_IS_COMPRESSED) { ntfs_error(vi->i_sb, "Found " "unknown compression " "method or corrupt " "file."); goto unm_err_out; } 
goto unm_err_out; 
static int ntfs_read_locked_inode(struct inode *vi){	ntfs_volume *vol = NTFS_SB(vi->i_sb);	ntfs_inode *ni;	MFT_RECORD *m;	ATTR_RECORD *a;	STANDARD_INFORMATION *si;	ntfs_attr_search_ctx *ctx;	int err = 0;	ntfs_debug("Entering for i_ino 0x%lx.", vi->i_ino);	/* Setup the generic vfs inode parts now. */	/* This is the optimal IO size (for stat), not the fs block size. */	vi->i_blksize = PAGE_CACHE_SIZE;	/*	 * This is for checking whether an inode has changed w.r.t. a file so	 * that the file can be updated if necessary (compare with f_version).	 */	vi->i_version = 1;	vi->i_uid = vol->uid;	vi->i_gid = vol->gid;	vi->i_mode = 0;	/*	 * Initialize the ntfs specific part of @vi special casing	 * FILE_MFT which we need to do at mount time.	 */	if (vi->i_ino != FILE_MFT)		ntfs_init_big_inode(vi);	ni = NTFS_I(vi);	m = map_mft_record(ni);	if (IS_ERR(m)) {		err = PTR_ERR(m);		goto err_out;	}	ctx = ntfs_attr_get_search_ctx(ni, m);	if (!ctx) {		err = -ENOMEM;		goto unm_err_out;	}	if (!(m->flags & MFT_RECORD_IN_USE)) {		ntfs_error(vi->i_sb, "Inode is not in use!");		goto unm_err_out;	}	if (m->base_mft_record) {		ntfs_error(vi->i_sb, "Inode is an extent inode!");		goto unm_err_out;	}	/* Transfer information from mft record into vfs and ntfs inodes. */	vi->i_generation = ni->seq_no = le16_to_cpu(m->sequence_number);	/*	 * FIXME: Keep in mind that link_count is two for files which have both	 * a long file name and a short file name as separate entries, so if	 * we are hiding short file names this will be too high. Either we need	 * to account for the short file names by subtracting them or we need	 * to make sure we delete files even though i_nlink is not zero which	 * might be tricky due to vfs interactions. Need to think about this	 * some more when implementing the unlink command.	 */	vi->i_nlink = le16_to_cpu(m->link_count);	/*	 * FIXME: Reparse points can have the directory bit set even though	 * they would be S_IFLNK. Need to deal with this further below when we	 * implement reparse points / symbolic links but it will do for now.	 * Also if not a directory, it could be something else, rather than	 * a regular file. But again, will do for now.	 */	/* Everyone gets all permissions. */	vi->i_mode |= S_IRWXUGO;	/* If read-only, noone gets write permissions. */	if (IS_RDONLY(vi))		vi->i_mode &= ~S_IWUGO;	if (m->flags & MFT_RECORD_IS_DIRECTORY) {		vi->i_mode |= S_IFDIR;		/*		 * Apply the directory permissions mask set in the mount		 * options.		 */		vi->i_mode &= ~vol->dmask;		/* Things break without this kludge! */		if (vi->i_nlink > 1)			vi->i_nlink = 1;	} else {		vi->i_mode |= S_IFREG;		/* Apply the file permissions mask set in the mount options. */		vi->i_mode &= ~vol->fmask;	}	/*	 * Find the standard information attribute in the mft record. At this	 * stage we haven't setup the attribute list stuff yet, so this could	 * in fact fail if the standard information is in an extent record, but	 * I don't think this actually ever happens.	 */	err = ntfs_attr_lookup(AT_STANDARD_INFORMATION, NULL, 0, 0, 0, NULL, 0,			ctx);	if (unlikely(err)) {		if (err == -ENOENT) {			/*			 * TODO: We should be performing a hot fix here (if the			 * recover mount option is set) by creating a new			 * attribute.			 */			ntfs_error(vi->i_sb, "$STANDARD_INFORMATION attribute "					"is missing.");		}		goto unm_err_out;	}	a = ctx->attr;	/* Get the standard information attribute value. */	si = (STANDARD_INFORMATION*)((u8*)a +			le16_to_cpu(a->data.resident.value_offset));	/* Transfer information from the standard information into vi. */	/*	 * Note: The i_?times do not quite map perfectly onto the NTFS times,	 * but they are close enough, and in the end it doesn't really matter	 * that much...	 */	/*	 * mtime is the last change of the data within the file. Not changed	 * when only metadata is changed, e.g. a rename doesn't affect mtime.	 */	vi->i_mtime = ntfs2utc(si->last_data_change_time);	/*	 * ctime is the last change of the metadata of the file. This obviously	 * always changes, when mtime is changed. ctime can be changed on its	 * own, mtime is then not changed, e.g. when a file is renamed.	 */	vi->i_ctime = ntfs2utc(si->last_mft_change_time);	/*	 * Last access to the data within the file. Not changed during a rename	 * for example but changed whenever the file is written to.	 */	vi->i_atime = ntfs2utc(si->last_access_time);	/* Find the attribute list attribute if present. */	ntfs_attr_reinit_search_ctx(ctx);	err = ntfs_attr_lookup(AT_ATTRIBUTE_LIST, NULL, 0, 0, 0, NULL, 0, ctx);	if (err) {		if (unlikely(err != -ENOENT)) {			ntfs_error(vi->i_sb, "Failed to lookup attribute list "					"attribute.");			goto unm_err_out;		}	} else /* if (!err) */ {		if (vi->i_ino == FILE_MFT)			goto skip_attr_list_load;		ntfs_debug("Attribute list found in inode 0x%lx.", vi->i_ino);		NInoSetAttrList(ni);		a = ctx->attr;		if (a->flags & ATTR_IS_ENCRYPTED ||				a->flags & ATTR_COMPRESSION_MASK ||				a->flags & ATTR_IS_SPARSE) {			ntfs_error(vi->i_sb, "Attribute list attribute is "					"compressed/encrypted/sparse.");			goto unm_err_out;		}		/* Now allocate memory for the attribute list. */		ni->attr_list_size = (u32)ntfs_attr_size(a);		ni->attr_list = ntfs_malloc_nofs(ni->attr_list_size);		if (!ni->attr_list) {			ntfs_error(vi->i_sb, "Not enough memory to allocate "					"buffer for attribute list.");			err = -ENOMEM;			goto unm_err_out;		}		if (a->non_resident) {			NInoSetAttrListNonResident(ni);			if (a->data.non_resident.lowest_vcn) {				ntfs_error(vi->i_sb, "Attribute list has non "						"zero lowest_vcn.");				goto unm_err_out;			}			/*			 * Setup the runlist. No need for locking as we have			 * exclusive access to the inode at this time.			 */			ni->attr_list_rl.rl = ntfs_mapping_pairs_decompress(vol,					a, NULL);			if (IS_ERR(ni->attr_list_rl.rl)) {				err = PTR_ERR(ni->attr_list_rl.rl);				ni->attr_list_rl.rl = NULL;				ntfs_error(vi->i_sb, "Mapping pairs "						"decompression failed.");				goto unm_err_out;			}			/* Now load the attribute list. */			if ((err = load_attribute_list(vol, &ni->attr_list_rl,					ni->attr_list, ni->attr_list_size,					sle64_to_cpu(a->data.non_resident.					initialized_size)))) {				ntfs_error(vi->i_sb, "Failed to load "						"attribute list attribute.");				goto unm_err_out;			}		} else /* if (!a->non_resident) */ {			if ((u8*)a + le16_to_cpu(a->data.resident.value_offset)					+ le32_to_cpu(					a->data.resident.value_length) >					(u8*)ctx->mrec + vol->mft_record_size) {				ntfs_error(vi->i_sb, "Corrupt attribute list "						"in inode.");				goto unm_err_out;			}			/* Now copy the attribute list. */			memcpy(ni->attr_list, (u8*)a + le16_to_cpu(					a->data.resident.value_offset),					le32_to_cpu(					a->data.resident.value_length));		}	}skip_attr_list_load:	/*	 * If an attribute list is present we now have the attribute list value	 * in ntfs_ino->attr_list and it is ntfs_ino->attr_list_size bytes.	 */	if (S_ISDIR(vi->i_mode)) {		loff_t bvi_size;		struct inode *bvi;		ntfs_inode *bni;		INDEX_ROOT *ir;		u8 *ir_end, *index_end;		/* It is a directory, find index root attribute. */		ntfs_attr_reinit_search_ctx(ctx);		err = ntfs_attr_lookup(AT_INDEX_ROOT, I30, 4, CASE_SENSITIVE,				0, NULL, 0, ctx);		if (unlikely(err)) {			if (err == -ENOENT) {				// FIXME: File is corrupt! Hot-fix with empty				// index root attribute if recovery option is				// set.				ntfs_error(vi->i_sb, "$INDEX_ROOT attribute "						"is missing.");			}			goto unm_err_out;		}		a = ctx->attr;		/* Set up the state. */		if (unlikely(a->non_resident)) {			ntfs_error(vol->sb, "$INDEX_ROOT attribute is not "					"resident.");			goto unm_err_out;		}		/* Ensure the attribute name is placed before the value. */		if (unlikely(a->name_length && (le16_to_cpu(a->name_offset) >=				le16_to_cpu(a->data.resident.value_offset)))) {			ntfs_error(vol->sb, "$INDEX_ROOT attribute name is "					"placed after the attribute value.");			goto unm_err_out;		}		/*		 * Compressed/encrypted index root just means that the newly		 * created files in that directory should be created compressed/		 * encrypted. However index root cannot be both compressed and		 * encrypted.		 */		if (a->flags & ATTR_COMPRESSION_MASK)			NInoSetCompressed(ni);		if (a->flags & ATTR_IS_ENCRYPTED) {			if (a->flags & ATTR_COMPRESSION_MASK) {				ntfs_error(vi->i_sb, "Found encrypted and "						"compressed attribute.");				goto unm_err_out;			}			NInoSetEncrypted(ni);		}		if (a->flags & ATTR_IS_SPARSE)			NInoSetSparse(ni);		ir = (INDEX_ROOT*)((u8*)a +				le16_to_cpu(a->data.resident.value_offset));		ir_end = (u8*)ir + le32_to_cpu(a->data.resident.value_length);		if (ir_end > (u8*)ctx->mrec + vol->mft_record_size) {			ntfs_error(vi->i_sb, "$INDEX_ROOT attribute is "					"corrupt.");			goto unm_err_out;		}		index_end = (u8*)&ir->index +				le32_to_cpu(ir->index.index_length);		if (index_end > ir_end) {			ntfs_error(vi->i_sb, "Directory index is corrupt.");			goto unm_err_out;		}		if (ir->type != AT_FILE_NAME) {			ntfs_error(vi->i_sb, "Indexed attribute is not "					"$FILE_NAME.");			goto unm_err_out;		}		if (ir->collation_rule != COLLATION_FILE_NAME) {			ntfs_error(vi->i_sb, "Index collation rule is not "					"COLLATION_FILE_NAME.");			goto unm_err_out;		}		ni->itype.index.collation_rule = ir->collation_rule;		ni->itype.index.block_size = le32_to_cpu(ir->index_block_size);		if (ni->itype.index.block_size &				(ni->itype.index.block_size - 1)) {			ntfs_error(vi->i_sb, "Index block size (%u) is not a "					"power of two.",					ni->itype.index.block_size);			goto unm_err_out;		}		if (ni->itype.index.block_size > PAGE_CACHE_SIZE) {			ntfs_error(vi->i_sb, "Index block size (%u) > "					"PAGE_CACHE_SIZE (%ld) is not "					"supported.  Sorry.",					ni->itype.index.block_size,					PAGE_CACHE_SIZE);			err = -EOPNOTSUPP;			goto unm_err_out;		}		if (ni->itype.index.block_size < NTFS_BLOCK_SIZE) {			ntfs_error(vi->i_sb, "Index block size (%u) < "					"NTFS_BLOCK_SIZE (%i) is not "					"supported.  Sorry.",					ni->itype.index.block_size,					NTFS_BLOCK_SIZE);			err = -EOPNOTSUPP;			goto unm_err_out;		}		ni->itype.index.block_size_bits =				ffs(ni->itype.index.block_size) - 1;		/* Determine the size of a vcn in the directory index. */		if (vol->cluster_size <= ni->itype.index.block_size) {			ni->itype.index.vcn_size = vol->cluster_size;			ni->itype.index.vcn_size_bits = vol->cluster_size_bits;		} else {			ni->itype.index.vcn_size = vol->sector_size;			ni->itype.index.vcn_size_bits = vol->sector_size_bits;		}		/* Setup the index allocation attribute, even if not present. */		NInoSetMstProtected(ni);		ni->type = AT_INDEX_ALLOCATION;		ni->name = I30;		ni->name_len = 4;		if (!(ir->index.flags & LARGE_INDEX)) {			/* No index allocation. */			vi->i_size = ni->initialized_size =					ni->allocated_size = 0;			/* We are done with the mft record, so we release it. */			ntfs_attr_put_search_ctx(ctx);			unmap_mft_record(ni);			m = NULL;			ctx = NULL;			goto skip_large_dir_stuff;		} /* LARGE_INDEX: Index allocation present. Setup state. */		NInoSetIndexAllocPresent(ni);		/* Find index allocation attribute. */		ntfs_attr_reinit_search_ctx(ctx);		err = ntfs_attr_lookup(AT_INDEX_ALLOCATION, I30, 4,				CASE_SENSITIVE, 0, NULL, 0, ctx);		if (unlikely(err)) {			if (err == -ENOENT)				ntfs_error(vi->i_sb, "$INDEX_ALLOCATION "						"attribute is not present but "						"$INDEX_ROOT indicated it is.");			else				ntfs_error(vi->i_sb, "Failed to lookup "						"$INDEX_ALLOCATION "						"attribute.");			goto unm_err_out;		}		a = ctx->attr;		if (!a->non_resident) {			ntfs_error(vi->i_sb, "$INDEX_ALLOCATION attribute "					"is resident.");			goto unm_err_out;		}		/*		 * Ensure the attribute name is placed before the mapping pairs		 * array.		 */		if (unlikely(a->name_length && (le16_to_cpu(a->name_offset) >=				le16_to_cpu(				a->data.non_resident.mapping_pairs_offset)))) {			ntfs_error(vol->sb, "$INDEX_ALLOCATION attribute name "					"is placed after the mapping pairs "					"array.");			goto unm_err_out;		}		if (a->flags & ATTR_IS_ENCRYPTED) {			ntfs_error(vi->i_sb, "$INDEX_ALLOCATION attribute "					"is encrypted.");			goto unm_err_out;		}		if (a->flags & ATTR_IS_SPARSE) {			ntfs_error(vi->i_sb, "$INDEX_ALLOCATION attribute "					"is sparse.");			goto unm_err_out;		}		if (a->flags & ATTR_COMPRESSION_MASK) {			ntfs_error(vi->i_sb, "$INDEX_ALLOCATION attribute "					"is compressed.");			goto unm_err_out;		}		if (a->data.non_resident.lowest_vcn) {			ntfs_error(vi->i_sb, "First extent of "					"$INDEX_ALLOCATION attribute has non "					"zero lowest_vcn.");			goto unm_err_out;		}		vi->i_size = sle64_to_cpu(a->data.non_resident.data_size);		ni->initialized_size = sle64_to_cpu(				a->data.non_resident.initialized_size);		ni->allocated_size = sle64_to_cpu(				a->data.non_resident.allocated_size);		/*		 * We are done with the mft record, so we release it. Otherwise		 * we would deadlock in ntfs_attr_iget().		 */		ntfs_attr_put_search_ctx(ctx);		unmap_mft_record(ni);		m = NULL;		ctx = NULL;		/* Get the index bitmap attribute inode. */		bvi = ntfs_attr_iget(vi, AT_BITMAP, I30, 4);		if (IS_ERR(bvi)) {			ntfs_error(vi->i_sb, "Failed to get bitmap attribute.");			err = PTR_ERR(bvi);			goto unm_err_out;		}		ni->itype.index.bmp_ino = bvi;		bni = NTFS_I(bvi);		if (NInoCompressed(bni) || NInoEncrypted(bni) ||				NInoSparse(bni)) {			ntfs_error(vi->i_sb, "$BITMAP attribute is compressed "					"and/or encrypted and/or sparse.");			goto unm_err_out;		}		/* Consistency check bitmap size vs. index allocation size. */		bvi_size = i_size_read(bvi);		if ((bvi_size << 3) < (vi->i_size >>				ni->itype.index.block_size_bits)) {			ntfs_error(vi->i_sb, "Index bitmap too small (0x%llx) "					"for index allocation (0x%llx).",					bvi_size << 3, vi->i_size);			goto unm_err_out;		}skip_large_dir_stuff:		/* Setup the operations for this inode. */		vi->i_op = &ntfs_dir_inode_ops;		vi->i_fop = &ntfs_dir_ops;	} else {		/* It is a file. */		ntfs_attr_reinit_search_ctx(ctx);		/* Setup the data attribute, even if not present. */		ni->type = AT_DATA;		ni->name = NULL;		ni->name_len = 0;		/* Find first extent of the unnamed data attribute. */		err = ntfs_attr_lookup(AT_DATA, NULL, 0, 0, 0, NULL, 0, ctx);		if (unlikely(err)) {			vi->i_size = ni->initialized_size =					ni->allocated_size = 0;			if (err != -ENOENT) {				ntfs_error(vi->i_sb, "Failed to lookup $DATA "						"attribute.");				goto unm_err_out;			}			/*			 * FILE_Secure does not have an unnamed $DATA			 * attribute, so we special case it here.			 */			if (vi->i_ino == FILE_Secure)				goto no_data_attr_special_case;			/*			 * Most if not all the system files in the $Extend			 * system directory do not have unnamed data			 * attributes so we need to check if the parent			 * directory of the file is FILE_Extend and if it is			 * ignore this error. To do this we need to get the			 * name of this inode from the mft record as the name			 * contains the back reference to the parent directory.			 */			if (ntfs_is_extended_system_file(ctx) > 0)				goto no_data_attr_special_case;			// FIXME: File is corrupt! Hot-fix with empty data			// attribute if recovery option is set.			ntfs_error(vi->i_sb, "$DATA attribute is missing.");			goto unm_err_out;		}		a = ctx->attr;		/* Setup the state. */		if (a->non_resident) {			NInoSetNonResident(ni);			if (a->flags & (ATTR_COMPRESSION_MASK |					ATTR_IS_SPARSE)) {				if (a->flags & ATTR_COMPRESSION_MASK) {					NInoSetCompressed(ni);					if (vol->cluster_size > 4096) {						ntfs_error(vi->i_sb, "Found "							"compressed data but "							"compression is "							"disabled due to "							"cluster size (%i) > "							"4kiB.",							vol->cluster_size);						goto unm_err_out;					}					if ((a->flags & ATTR_COMPRESSION_MASK)							!= ATTR_IS_COMPRESSED) {						ntfs_error(vi->i_sb, "Found "							"unknown compression "							"method or corrupt "							"file.");						goto unm_err_out;					}				}				if (a->flags & ATTR_IS_SPARSE)					NInoSetSparse(ni);				if (a->data.non_resident.compression_unit !=						4) {					ntfs_error(vi->i_sb, "Found "						"nonstandard compression unit "						"(%u instead of 4).  Cannot "						"handle this.",						a->data.non_resident.						compression_unit);					err = -EOPNOTSUPP;					goto unm_err_out;				}				ni->itype.compressed.block_clusters = 1U <<						a->data.non_resident.						compression_unit;				ni->itype.compressed.block_size = 1U << (						a->data.non_resident.						compression_unit +						vol->cluster_size_bits);				ni->itype.compressed.block_size_bits = ffs(						ni->itype.compressed.						block_size) - 1;				ni->itype.compressed.size = sle64_to_cpu(						a->data.non_resident.						compressed_size);			}			if (a->flags & ATTR_IS_ENCRYPTED) {				if (a->flags & ATTR_COMPRESSION_MASK) {					ntfs_error(vi->i_sb, "Found encrypted "							"and compressed data.");					goto unm_err_out;				}				NInoSetEncrypted(ni);			}			if (a->data.non_resident.lowest_vcn) {				ntfs_error(vi->i_sb, "First extent of $DATA "						"attribute has non zero "						"lowest_vcn.");				goto unm_err_out;			}			vi->i_size = sle64_to_cpu(					a->data.non_resident.data_size);			ni->initialized_size = sle64_to_cpu(					a->data.non_resident.initialized_size);			ni->allocated_size = sle64_to_cpu(					a->data.non_resident.allocated_size);		} else { /* Resident attribute. */			vi->i_size = ni->initialized_size = le32_to_cpu(					a->data.resident.value_length);			ni->allocated_size = le32_to_cpu(a->length) -					le16_to_cpu(					a->data.resident.value_offset);			if (vi->i_size > ni->allocated_size) {				ntfs_error(vi->i_sb, "Resident data attribute "						"is corrupt (size exceeds "						"allocation).");				goto unm_err_out;			}		}no_data_attr_special_case:		/* We are done with the mft record, so we release it. */		ntfs_attr_put_search_ctx(ctx);		unmap_mft_record(ni);		m = NULL;		ctx = NULL;		/* Setup the operations for this inode. */		vi->i_op = &ntfs_file_inode_ops;		vi->i_fop = &ntfs_file_ops;	}	if (NInoMstProtected(ni))		vi->i_mapping->a_ops = &ntfs_mst_aops;	else		vi->i_mapping->a_ops = &ntfs_aops;	/*	 * The number of 512-byte blocks used on disk (for stat). This is in so	 * far inaccurate as it doesn't account for any named streams or other	 * special non-resident attributes, but that is how Windows works, too,	 * so we are at least consistent with Windows, if not entirely	 * consistent with the Linux Way. Doing it the Linux Way would cause a	 * significant slowdown as it would involve iterating over all	 * attributes in the mft record and adding the allocated/compressed	 * sizes of all non-resident attributes present to give us the Linux	 * correct size that should go into i_blocks (after division by 512).	 */	if (S_ISREG(vi->i_mode) && (NInoCompressed(ni) || NInoSparse(ni)))		vi->i_blocks = ni->itype.compressed.size >> 9;	else		vi->i_blocks = ni->allocated_size >> 9;	ntfs_debug("Done.");	return 0;unm_err_out:	if (!err)		err = -EIO;	if (ctx)		ntfs_attr_put_search_ctx(ctx);	if (m)		unmap_mft_record(ni);err_out:	ntfs_error(vol->sb, "Failed with error code %i.  Marking corrupt "			"inode 0x%lx as bad.  Run chkdsk.", err, vi->i_ino);	make_bad_inode(vi);	if (err != -EOPNOTSUPP && err != -ENOMEM)		NVolSetErrors(vol);	return err;}
4520	/local/tlutelli/issta_data/temp/c/2005_temp/2005/4520/67bb103725e4cde322cb4ddb160a12933c5c7072/inode.c/buggy/fs/ntfs/inode.c