1/*
   2 * inode.c
   3 *
   4 * PURPOSE
   5 *  Inode handling routines for the OSTA-UDF(tm) filesystem.
   6 *
   7 * COPYRIGHT
   8 *  This file is distributed under the terms of the GNU General Public
   9 *  License (GPL). Copies of the GPL can be obtained from:
  10 *    ftp://prep.ai.mit.edu/pub/gnu/GPL
  11 *  Each contributing author retains all rights to their own work.
  12 *
  13 *  (C) 1998 Dave Boynton
  14 *  (C) 1998-2004 Ben Fennema
  15 *  (C) 1999-2000 Stelias Computing Inc
  16 *
  17 * HISTORY
  18 *
  19 *  10/04/98 dgb  Added rudimentary directory functions
  20 *  10/07/98      Fully working udf_block_map! It works!
  21 *  11/25/98      bmap altered to better support extents
  22 *  12/06/98 blf  partition support in udf_iget, udf_block_map
  23 *                and udf_read_inode
  24 *  12/12/98      rewrote udf_block_map to handle next extents and descs across
  25 *                block boundaries (which is not actually allowed)
  26 *  12/20/98      added support for strategy 4096
  27 *  03/07/99      rewrote udf_block_map (again)
  28 *                New funcs, inode_bmap, udf_next_aext
  29 *  04/19/99      Support for writing device EA's for major/minor #
  30 */
  31
  32#include "udfdecl.h"
  33#include <linux/mm.h>
  34#include <linux/module.h>
  35#include <linux/pagemap.h>
  36#include <linux/writeback.h>
  37#include <linux/slab.h>
  38#include <linux/crc-itu-t.h>
  39#include <linux/mpage.h>
  40#include <linux/uio.h>
  41#include <linux/bio.h>
  42
  43#include "udf_i.h"
  44#include "udf_sb.h"
  45
 
 
 
 
  46#define EXTENT_MERGE_SIZE 5
  47
  48static umode_t udf_convert_permissions(struct fileEntry *);
  49static int udf_update_inode(struct inode *, int);
  50static int udf_sync_inode(struct inode *inode);
  51static int udf_alloc_i_data(struct inode *inode, size_t size);
  52static sector_t inode_getblk(struct inode *, sector_t, int *, int *);
  53static int8_t udf_insert_aext(struct inode *, struct extent_position,
  54			      struct kernel_lb_addr, uint32_t);
  55static void udf_split_extents(struct inode *, int *, int, udf_pblk_t,
  56			      struct kernel_long_ad *, int *);
  57static void udf_prealloc_extents(struct inode *, int, int,
  58				 struct kernel_long_ad *, int *);
  59static void udf_merge_extents(struct inode *, struct kernel_long_ad *, int *);
  60static void udf_update_extents(struct inode *, struct kernel_long_ad *, int,
  61			       int, struct extent_position *);
 
 
  62static int udf_get_block(struct inode *, sector_t, struct buffer_head *, int);
  63
  64static void __udf_clear_extent_cache(struct inode *inode)
  65{
  66	struct udf_inode_info *iinfo = UDF_I(inode);
  67
  68	if (iinfo->cached_extent.lstart != -1) {
  69		brelse(iinfo->cached_extent.epos.bh);
  70		iinfo->cached_extent.lstart = -1;
  71	}
  72}
  73
  74/* Invalidate extent cache */
  75static void udf_clear_extent_cache(struct inode *inode)
  76{
  77	struct udf_inode_info *iinfo = UDF_I(inode);
  78
  79	spin_lock(&iinfo->i_extent_cache_lock);
  80	__udf_clear_extent_cache(inode);
  81	spin_unlock(&iinfo->i_extent_cache_lock);
  82}
  83
  84/* Return contents of extent cache */
  85static int udf_read_extent_cache(struct inode *inode, loff_t bcount,
  86				 loff_t *lbcount, struct extent_position *pos)
  87{
  88	struct udf_inode_info *iinfo = UDF_I(inode);
  89	int ret = 0;
  90
  91	spin_lock(&iinfo->i_extent_cache_lock);
  92	if ((iinfo->cached_extent.lstart <= bcount) &&
  93	    (iinfo->cached_extent.lstart != -1)) {
  94		/* Cache hit */
  95		*lbcount = iinfo->cached_extent.lstart;
  96		memcpy(pos, &iinfo->cached_extent.epos,
  97		       sizeof(struct extent_position));
  98		if (pos->bh)
  99			get_bh(pos->bh);
 100		ret = 1;
 101	}
 102	spin_unlock(&iinfo->i_extent_cache_lock);
 103	return ret;
 104}
 105
 106/* Add extent to extent cache */
 107static void udf_update_extent_cache(struct inode *inode, loff_t estart,
 108				    struct extent_position *pos)
 109{
 110	struct udf_inode_info *iinfo = UDF_I(inode);
 111
 112	spin_lock(&iinfo->i_extent_cache_lock);
 113	/* Invalidate previously cached extent */
 114	__udf_clear_extent_cache(inode);
 115	if (pos->bh)
 116		get_bh(pos->bh);
 117	memcpy(&iinfo->cached_extent.epos, pos, sizeof(*pos));
 
 118	iinfo->cached_extent.lstart = estart;
 119	switch (iinfo->i_alloc_type) {
 120	case ICBTAG_FLAG_AD_SHORT:
 121		iinfo->cached_extent.epos.offset -= sizeof(struct short_ad);
 122		break;
 123	case ICBTAG_FLAG_AD_LONG:
 124		iinfo->cached_extent.epos.offset -= sizeof(struct long_ad);
 125		break;
 126	}
 
 
 127	spin_unlock(&iinfo->i_extent_cache_lock);
 128}
 129
 130void udf_evict_inode(struct inode *inode)
 131{
 132	struct udf_inode_info *iinfo = UDF_I(inode);
 133	int want_delete = 0;
 134
 135	if (!inode->i_nlink && !is_bad_inode(inode)) {
 136		want_delete = 1;
 137		udf_setsize(inode, 0);
 138		udf_update_inode(inode, IS_SYNC(inode));
 139	}
 140	truncate_inode_pages_final(&inode->i_data);
 141	invalidate_inode_buffers(inode);
 142	clear_inode(inode);
 143	if (iinfo->i_alloc_type != ICBTAG_FLAG_AD_IN_ICB &&
 144	    inode->i_size != iinfo->i_lenExtents) {
 145		udf_warn(inode->i_sb, "Inode %lu (mode %o) has inode size %llu different from extent length %llu. Filesystem need not be standards compliant.\n",
 146			 inode->i_ino, inode->i_mode,
 147			 (unsigned long long)inode->i_size,
 148			 (unsigned long long)iinfo->i_lenExtents);
 149	}
 150	kfree(iinfo->i_ext.i_data);
 151	iinfo->i_ext.i_data = NULL;
 152	udf_clear_extent_cache(inode);
 153	if (want_delete) {
 154		udf_free_inode(inode);
 155	}
 156}
 157
 158static void udf_write_failed(struct address_space *mapping, loff_t to)
 159{
 160	struct inode *inode = mapping->host;
 161	struct udf_inode_info *iinfo = UDF_I(inode);
 162	loff_t isize = inode->i_size;
 163
 164	if (to > isize) {
 165		truncate_pagecache(inode, isize);
 166		if (iinfo->i_alloc_type != ICBTAG_FLAG_AD_IN_ICB) {
 167			down_write(&iinfo->i_data_sem);
 168			udf_clear_extent_cache(inode);
 169			udf_truncate_extents(inode);
 170			up_write(&iinfo->i_data_sem);
 171		}
 172	}
 173}
 174
 175static int udf_writepage(struct page *page, struct writeback_control *wbc)
 176{
 177	return block_write_full_page(page, udf_get_block, wbc);
 178}
 179
 180static int udf_writepages(struct address_space *mapping,
 181			struct writeback_control *wbc)
 182{
 183	return mpage_writepages(mapping, wbc, udf_get_block);
 184}
 185
 186static int udf_readpage(struct file *file, struct page *page)
 187{
 188	return mpage_readpage(page, udf_get_block);
 189}
 190
 191static int udf_readpages(struct file *file, struct address_space *mapping,
 192			struct list_head *pages, unsigned nr_pages)
 193{
 194	return mpage_readpages(mapping, pages, nr_pages, udf_get_block);
 195}
 196
 197static int udf_write_begin(struct file *file, struct address_space *mapping,
 198			loff_t pos, unsigned len, unsigned flags,
 199			struct page **pagep, void **fsdata)
 200{
 201	int ret;
 202
 203	ret = block_write_begin(mapping, pos, len, flags, pagep, udf_get_block);
 204	if (unlikely(ret))
 205		udf_write_failed(mapping, pos + len);
 206	return ret;
 207}
 208
 209static ssize_t udf_direct_IO(struct kiocb *iocb, struct iov_iter *iter)
 210{
 211	struct file *file = iocb->ki_filp;
 212	struct address_space *mapping = file->f_mapping;
 213	struct inode *inode = mapping->host;
 214	size_t count = iov_iter_count(iter);
 215	ssize_t ret;
 216
 217	ret = blockdev_direct_IO(iocb, inode, iter, udf_get_block);
 218	if (unlikely(ret < 0 && iov_iter_rw(iter) == WRITE))
 219		udf_write_failed(mapping, iocb->ki_pos + count);
 220	return ret;
 221}
 222
 223static sector_t udf_bmap(struct address_space *mapping, sector_t block)
 224{
 225	return generic_block_bmap(mapping, block, udf_get_block);
 226}
 227
 228const struct address_space_operations udf_aops = {
 229	.readpage	= udf_readpage,
 230	.readpages	= udf_readpages,
 231	.writepage	= udf_writepage,
 232	.writepages	= udf_writepages,
 233	.write_begin	= udf_write_begin,
 234	.write_end	= generic_write_end,
 235	.direct_IO	= udf_direct_IO,
 236	.bmap		= udf_bmap,
 237};
 238
 239/*
 240 * Expand file stored in ICB to a normal one-block-file
 241 *
 242 * This function requires i_data_sem for writing and releases it.
 243 * This function requires i_mutex held
 244 */
 245int udf_expand_file_adinicb(struct inode *inode)
 246{
 247	struct page *page;
 248	char *kaddr;
 249	struct udf_inode_info *iinfo = UDF_I(inode);
 250	int err;
 251	struct writeback_control udf_wbc = {
 252		.sync_mode = WB_SYNC_NONE,
 253		.nr_to_write = 1,
 254	};
 255
 256	WARN_ON_ONCE(!inode_is_locked(inode));
 257	if (!iinfo->i_lenAlloc) {
 258		if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_SHORT_AD))
 259			iinfo->i_alloc_type = ICBTAG_FLAG_AD_SHORT;
 260		else
 261			iinfo->i_alloc_type = ICBTAG_FLAG_AD_LONG;
 262		/* from now on we have normal address_space methods */
 263		inode->i_data.a_ops = &udf_aops;
 264		up_write(&iinfo->i_data_sem);
 265		mark_inode_dirty(inode);
 266		return 0;
 267	}
 268	/*
 269	 * Release i_data_sem so that we can lock a page - page lock ranks
 270	 * above i_data_sem. i_mutex still protects us against file changes.
 271	 */
 272	up_write(&iinfo->i_data_sem);
 273
 274	page = find_or_create_page(inode->i_mapping, 0, GFP_NOFS);
 275	if (!page)
 276		return -ENOMEM;
 277
 278	if (!PageUptodate(page)) {
 279		kaddr = kmap_atomic(page);
 280		memset(kaddr + iinfo->i_lenAlloc, 0x00,
 281		       PAGE_SIZE - iinfo->i_lenAlloc);
 282		memcpy(kaddr, iinfo->i_ext.i_data + iinfo->i_lenEAttr,
 283			iinfo->i_lenAlloc);
 284		flush_dcache_page(page);
 285		SetPageUptodate(page);
 286		kunmap_atomic(kaddr);
 287	}
 288	down_write(&iinfo->i_data_sem);
 289	memset(iinfo->i_ext.i_data + iinfo->i_lenEAttr, 0x00,
 290	       iinfo->i_lenAlloc);
 291	iinfo->i_lenAlloc = 0;
 292	if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_SHORT_AD))
 293		iinfo->i_alloc_type = ICBTAG_FLAG_AD_SHORT;
 294	else
 295		iinfo->i_alloc_type = ICBTAG_FLAG_AD_LONG;
 296	/* from now on we have normal address_space methods */
 297	inode->i_data.a_ops = &udf_aops;
 298	up_write(&iinfo->i_data_sem);
 299	err = inode->i_data.a_ops->writepage(page, &udf_wbc);
 300	if (err) {
 301		/* Restore everything back so that we don't lose data... */
 302		lock_page(page);
 
 303		down_write(&iinfo->i_data_sem);
 304		kaddr = kmap_atomic(page);
 305		memcpy(iinfo->i_ext.i_data + iinfo->i_lenEAttr, kaddr,
 306		       inode->i_size);
 307		kunmap_atomic(kaddr);
 308		unlock_page(page);
 309		iinfo->i_alloc_type = ICBTAG_FLAG_AD_IN_ICB;
 310		inode->i_data.a_ops = &udf_adinicb_aops;
 311		up_write(&iinfo->i_data_sem);
 312	}
 313	put_page(page);
 314	mark_inode_dirty(inode);
 315
 316	return err;
 317}
 318
 319struct buffer_head *udf_expand_dir_adinicb(struct inode *inode,
 320					    udf_pblk_t *block, int *err)
 321{
 322	udf_pblk_t newblock;
 323	struct buffer_head *dbh = NULL;
 324	struct kernel_lb_addr eloc;
 325	uint8_t alloctype;
 326	struct extent_position epos;
 327
 328	struct udf_fileident_bh sfibh, dfibh;
 329	loff_t f_pos = udf_ext0_offset(inode);
 330	int size = udf_ext0_offset(inode) + inode->i_size;
 331	struct fileIdentDesc cfi, *sfi, *dfi;
 332	struct udf_inode_info *iinfo = UDF_I(inode);
 333
 334	if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_SHORT_AD))
 335		alloctype = ICBTAG_FLAG_AD_SHORT;
 336	else
 337		alloctype = ICBTAG_FLAG_AD_LONG;
 338
 339	if (!inode->i_size) {
 340		iinfo->i_alloc_type = alloctype;
 341		mark_inode_dirty(inode);
 342		return NULL;
 343	}
 344
 345	/* alloc block, and copy data to it */
 346	*block = udf_new_block(inode->i_sb, inode,
 347			       iinfo->i_location.partitionReferenceNum,
 348			       iinfo->i_location.logicalBlockNum, err);
 349	if (!(*block))
 350		return NULL;
 351	newblock = udf_get_pblock(inode->i_sb, *block,
 352				  iinfo->i_location.partitionReferenceNum,
 353				0);
 354	if (!newblock)
 355		return NULL;
 356	dbh = udf_tgetblk(inode->i_sb, newblock);
 357	if (!dbh)
 358		return NULL;
 359	lock_buffer(dbh);
 360	memset(dbh->b_data, 0x00, inode->i_sb->s_blocksize);
 361	set_buffer_uptodate(dbh);
 362	unlock_buffer(dbh);
 363	mark_buffer_dirty_inode(dbh, inode);
 364
 365	sfibh.soffset = sfibh.eoffset =
 366			f_pos & (inode->i_sb->s_blocksize - 1);
 367	sfibh.sbh = sfibh.ebh = NULL;
 368	dfibh.soffset = dfibh.eoffset = 0;
 369	dfibh.sbh = dfibh.ebh = dbh;
 370	while (f_pos < size) {
 371		iinfo->i_alloc_type = ICBTAG_FLAG_AD_IN_ICB;
 372		sfi = udf_fileident_read(inode, &f_pos, &sfibh, &cfi, NULL,
 373					 NULL, NULL, NULL);
 374		if (!sfi) {
 375			brelse(dbh);
 376			return NULL;
 377		}
 378		iinfo->i_alloc_type = alloctype;
 379		sfi->descTag.tagLocation = cpu_to_le32(*block);
 380		dfibh.soffset = dfibh.eoffset;
 381		dfibh.eoffset += (sfibh.eoffset - sfibh.soffset);
 382		dfi = (struct fileIdentDesc *)(dbh->b_data + dfibh.soffset);
 383		if (udf_write_fi(inode, sfi, dfi, &dfibh, sfi->impUse,
 384				 sfi->fileIdent +
 385					le16_to_cpu(sfi->lengthOfImpUse))) {
 386			iinfo->i_alloc_type = ICBTAG_FLAG_AD_IN_ICB;
 387			brelse(dbh);
 388			return NULL;
 389		}
 390	}
 391	mark_buffer_dirty_inode(dbh, inode);
 392
 393	memset(iinfo->i_ext.i_data + iinfo->i_lenEAttr, 0,
 394		iinfo->i_lenAlloc);
 395	iinfo->i_lenAlloc = 0;
 396	eloc.logicalBlockNum = *block;
 397	eloc.partitionReferenceNum =
 398				iinfo->i_location.partitionReferenceNum;
 399	iinfo->i_lenExtents = inode->i_size;
 400	epos.bh = NULL;
 401	epos.block = iinfo->i_location;
 402	epos.offset = udf_file_entry_alloc_offset(inode);
 403	udf_add_aext(inode, &epos, &eloc, inode->i_size, 0);
 404	/* UniqueID stuff */
 405
 406	brelse(epos.bh);
 407	mark_inode_dirty(inode);
 408	return dbh;
 409}
 410
 411static int udf_get_block(struct inode *inode, sector_t block,
 412			 struct buffer_head *bh_result, int create)
 413{
 414	int err, new;
 415	sector_t phys = 0;
 416	struct udf_inode_info *iinfo;
 417
 418	if (!create) {
 419		phys = udf_block_map(inode, block);
 420		if (phys)
 421			map_bh(bh_result, inode->i_sb, phys);
 422		return 0;
 423	}
 424
 425	err = -EIO;
 426	new = 0;
 427	iinfo = UDF_I(inode);
 428
 429	down_write(&iinfo->i_data_sem);
 430	if (block == iinfo->i_next_alloc_block + 1) {
 431		iinfo->i_next_alloc_block++;
 432		iinfo->i_next_alloc_goal++;
 433	}
 434
 435	udf_clear_extent_cache(inode);
 436	phys = inode_getblk(inode, block, &err, &new);
 437	if (!phys)
 438		goto abort;
 439
 440	if (new)
 441		set_buffer_new(bh_result);
 442	map_bh(bh_result, inode->i_sb, phys);
 443
 444abort:
 445	up_write(&iinfo->i_data_sem);
 446	return err;
 447}
 448
 449static struct buffer_head *udf_getblk(struct inode *inode, udf_pblk_t block,
 450				      int create, int *err)
 451{
 452	struct buffer_head *bh;
 453	struct buffer_head dummy;
 454
 455	dummy.b_state = 0;
 456	dummy.b_blocknr = -1000;
 457	*err = udf_get_block(inode, block, &dummy, create);
 458	if (!*err && buffer_mapped(&dummy)) {
 459		bh = sb_getblk(inode->i_sb, dummy.b_blocknr);
 460		if (buffer_new(&dummy)) {
 461			lock_buffer(bh);
 462			memset(bh->b_data, 0x00, inode->i_sb->s_blocksize);
 463			set_buffer_uptodate(bh);
 464			unlock_buffer(bh);
 465			mark_buffer_dirty_inode(bh, inode);
 466		}
 467		return bh;
 468	}
 469
 470	return NULL;
 471}
 472
 473/* Extend the file by 'blocks' blocks, return the number of extents added */
 474static int udf_do_extend_file(struct inode *inode,
 475			      struct extent_position *last_pos,
 476			      struct kernel_long_ad *last_ext,
 477			      sector_t blocks)
 478{
 479	sector_t add;
 480	int count = 0, fake = !(last_ext->extLength & UDF_EXTENT_LENGTH_MASK);
 481	struct super_block *sb = inode->i_sb;
 482	struct kernel_lb_addr prealloc_loc = {};
 483	uint32_t prealloc_len = 0;
 484	struct udf_inode_info *iinfo;
 485	int err;
 486
 487	/* The previous extent is fake and we should not extend by anything
 488	 * - there's nothing to do... */
 489	if (!blocks && fake)
 490		return 0;
 491
 492	iinfo = UDF_I(inode);
 493	/* Round the last extent up to a multiple of block size */
 494	if (last_ext->extLength & (sb->s_blocksize - 1)) {
 495		last_ext->extLength =
 496			(last_ext->extLength & UDF_EXTENT_FLAG_MASK) |
 497			(((last_ext->extLength & UDF_EXTENT_LENGTH_MASK) +
 498			  sb->s_blocksize - 1) & ~(sb->s_blocksize - 1));
 499		iinfo->i_lenExtents =
 500			(iinfo->i_lenExtents + sb->s_blocksize - 1) &
 501			~(sb->s_blocksize - 1);
 502	}
 503
 504	/* Last extent are just preallocated blocks? */
 505	if ((last_ext->extLength & UDF_EXTENT_FLAG_MASK) ==
 506						EXT_NOT_RECORDED_ALLOCATED) {
 507		/* Save the extent so that we can reattach it to the end */
 508		prealloc_loc = last_ext->extLocation;
 509		prealloc_len = last_ext->extLength;
 510		/* Mark the extent as a hole */
 511		last_ext->extLength = EXT_NOT_RECORDED_NOT_ALLOCATED |
 512			(last_ext->extLength & UDF_EXTENT_LENGTH_MASK);
 513		last_ext->extLocation.logicalBlockNum = 0;
 514		last_ext->extLocation.partitionReferenceNum = 0;
 515	}
 516
 517	/* Can we merge with the previous extent? */
 518	if ((last_ext->extLength & UDF_EXTENT_FLAG_MASK) ==
 519					EXT_NOT_RECORDED_NOT_ALLOCATED) {
 520		add = ((1 << 30) - sb->s_blocksize -
 521			(last_ext->extLength & UDF_EXTENT_LENGTH_MASK)) >>
 522			sb->s_blocksize_bits;
 523		if (add > blocks)
 524			add = blocks;
 525		blocks -= add;
 526		last_ext->extLength += add << sb->s_blocksize_bits;
 527	}
 528
 529	if (fake) {
 530		udf_add_aext(inode, last_pos, &last_ext->extLocation,
 531			     last_ext->extLength, 1);
 532		count++;
 533	} else {
 534		struct kernel_lb_addr tmploc;
 535		uint32_t tmplen;
 536
 537		udf_write_aext(inode, last_pos, &last_ext->extLocation,
 538				last_ext->extLength, 1);
 539		/*
 540		 * We've rewritten the last extent but there may be empty
 541		 * indirect extent after it - enter it.
 542		 */
 543		udf_next_aext(inode, last_pos, &tmploc, &tmplen, 0);
 544	}
 545
 546	/* Managed to do everything necessary? */
 547	if (!blocks)
 548		goto out;
 549
 550	/* All further extents will be NOT_RECORDED_NOT_ALLOCATED */
 551	last_ext->extLocation.logicalBlockNum = 0;
 552	last_ext->extLocation.partitionReferenceNum = 0;
 553	add = (1 << (30-sb->s_blocksize_bits)) - 1;
 554	last_ext->extLength = EXT_NOT_RECORDED_NOT_ALLOCATED |
 555				(add << sb->s_blocksize_bits);
 556
 557	/* Create enough extents to cover the whole hole */
 558	while (blocks > add) {
 559		blocks -= add;
 560		err = udf_add_aext(inode, last_pos, &last_ext->extLocation,
 561				   last_ext->extLength, 1);
 562		if (err)
 563			return err;
 564		count++;
 565	}
 566	if (blocks) {
 567		last_ext->extLength = EXT_NOT_RECORDED_NOT_ALLOCATED |
 568			(blocks << sb->s_blocksize_bits);
 569		err = udf_add_aext(inode, last_pos, &last_ext->extLocation,
 570				   last_ext->extLength, 1);
 571		if (err)
 572			return err;
 573		count++;
 574	}
 575
 576out:
 577	/* Do we have some preallocated blocks saved? */
 578	if (prealloc_len) {
 579		err = udf_add_aext(inode, last_pos, &prealloc_loc,
 580				   prealloc_len, 1);
 581		if (err)
 582			return err;
 583		last_ext->extLocation = prealloc_loc;
 584		last_ext->extLength = prealloc_len;
 585		count++;
 586	}
 587
 588	/* last_pos should point to the last written extent... */
 589	if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
 590		last_pos->offset -= sizeof(struct short_ad);
 591	else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
 592		last_pos->offset -= sizeof(struct long_ad);
 593	else
 594		return -EIO;
 595
 596	return count;
 597}
 598
 599static int udf_extend_file(struct inode *inode, loff_t newsize)
 600{
 601
 602	struct extent_position epos;
 603	struct kernel_lb_addr eloc;
 604	uint32_t elen;
 605	int8_t etype;
 606	struct super_block *sb = inode->i_sb;
 607	sector_t first_block = newsize >> sb->s_blocksize_bits, offset;
 608	int adsize;
 609	struct udf_inode_info *iinfo = UDF_I(inode);
 610	struct kernel_long_ad extent;
 611	int err;
 612
 613	if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
 614		adsize = sizeof(struct short_ad);
 615	else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
 616		adsize = sizeof(struct long_ad);
 617	else
 618		BUG();
 619
 620	etype = inode_bmap(inode, first_block, &epos, &eloc, &elen, &offset);
 621
 622	/* File has extent covering the new size (could happen when extending
 623	 * inside a block)? */
 624	if (etype != -1)
 625		return 0;
 626	if (newsize & (sb->s_blocksize - 1))
 627		offset++;
 628	/* Extended file just to the boundary of the last file block? */
 629	if (offset == 0)
 630		return 0;
 631
 632	/* Truncate is extending the file by 'offset' blocks */
 633	if ((!epos.bh && epos.offset == udf_file_entry_alloc_offset(inode)) ||
 634	    (epos.bh && epos.offset == sizeof(struct allocExtDesc))) {
 635		/* File has no extents at all or has empty last
 636		 * indirect extent! Create a fake extent... */
 637		extent.extLocation.logicalBlockNum = 0;
 638		extent.extLocation.partitionReferenceNum = 0;
 639		extent.extLength = EXT_NOT_RECORDED_NOT_ALLOCATED;
 640	} else {
 641		epos.offset -= adsize;
 642		etype = udf_next_aext(inode, &epos, &extent.extLocation,
 643				      &extent.extLength, 0);
 644		extent.extLength |= etype << 30;
 645	}
 646	err = udf_do_extend_file(inode, &epos, &extent, offset);
 647	if (err < 0)
 648		goto out;
 649	err = 0;
 650	iinfo->i_lenExtents = newsize;
 651out:
 652	brelse(epos.bh);
 653	return err;
 654}
 655
 656static sector_t inode_getblk(struct inode *inode, sector_t block,
 657			     int *err, int *new)
 658{
 659	struct kernel_long_ad laarr[EXTENT_MERGE_SIZE];
 660	struct extent_position prev_epos, cur_epos, next_epos;
 661	int count = 0, startnum = 0, endnum = 0;
 662	uint32_t elen = 0, tmpelen;
 663	struct kernel_lb_addr eloc, tmpeloc;
 664	int c = 1;
 665	loff_t lbcount = 0, b_off = 0;
 666	udf_pblk_t newblocknum, newblock;
 667	sector_t offset = 0;
 668	int8_t etype;
 669	struct udf_inode_info *iinfo = UDF_I(inode);
 670	udf_pblk_t goal = 0, pgoal = iinfo->i_location.logicalBlockNum;
 671	int lastblock = 0;
 672	bool isBeyondEOF;
 673
 674	*err = 0;
 675	*new = 0;
 676	prev_epos.offset = udf_file_entry_alloc_offset(inode);
 677	prev_epos.block = iinfo->i_location;
 678	prev_epos.bh = NULL;
 679	cur_epos = next_epos = prev_epos;
 680	b_off = (loff_t)block << inode->i_sb->s_blocksize_bits;
 681
 682	/* find the extent which contains the block we are looking for.
 683	   alternate between laarr[0] and laarr[1] for locations of the
 684	   current extent, and the previous extent */
 685	do {
 686		if (prev_epos.bh != cur_epos.bh) {
 687			brelse(prev_epos.bh);
 688			get_bh(cur_epos.bh);
 689			prev_epos.bh = cur_epos.bh;
 690		}
 691		if (cur_epos.bh != next_epos.bh) {
 692			brelse(cur_epos.bh);
 693			get_bh(next_epos.bh);
 694			cur_epos.bh = next_epos.bh;
 695		}
 696
 697		lbcount += elen;
 698
 699		prev_epos.block = cur_epos.block;
 700		cur_epos.block = next_epos.block;
 701
 702		prev_epos.offset = cur_epos.offset;
 703		cur_epos.offset = next_epos.offset;
 704
 705		etype = udf_next_aext(inode, &next_epos, &eloc, &elen, 1);
 706		if (etype == -1)
 707			break;
 708
 709		c = !c;
 710
 711		laarr[c].extLength = (etype << 30) | elen;
 712		laarr[c].extLocation = eloc;
 713
 714		if (etype != (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30))
 715			pgoal = eloc.logicalBlockNum +
 716				((elen + inode->i_sb->s_blocksize - 1) >>
 717				 inode->i_sb->s_blocksize_bits);
 718
 719		count++;
 720	} while (lbcount + elen <= b_off);
 721
 722	b_off -= lbcount;
 723	offset = b_off >> inode->i_sb->s_blocksize_bits;
 724	/*
 725	 * Move prev_epos and cur_epos into indirect extent if we are at
 726	 * the pointer to it
 727	 */
 728	udf_next_aext(inode, &prev_epos, &tmpeloc, &tmpelen, 0);
 729	udf_next_aext(inode, &cur_epos, &tmpeloc, &tmpelen, 0);
 730
 731	/* if the extent is allocated and recorded, return the block
 732	   if the extent is not a multiple of the blocksize, round up */
 733
 734	if (etype == (EXT_RECORDED_ALLOCATED >> 30)) {
 735		if (elen & (inode->i_sb->s_blocksize - 1)) {
 736			elen = EXT_RECORDED_ALLOCATED |
 737				((elen + inode->i_sb->s_blocksize - 1) &
 738				 ~(inode->i_sb->s_blocksize - 1));
 739			udf_write_aext(inode, &cur_epos, &eloc, elen, 1);
 740		}
 
 
 
 741		newblock = udf_get_lb_pblock(inode->i_sb, &eloc, offset);
 742		goto out_free;
 743	}
 744
 745	/* Are we beyond EOF? */
 746	if (etype == -1) {
 747		int ret;
 748		isBeyondEOF = true;
 749		if (count) {
 750			if (c)
 751				laarr[0] = laarr[1];
 752			startnum = 1;
 753		} else {
 754			/* Create a fake extent when there's not one */
 755			memset(&laarr[0].extLocation, 0x00,
 756				sizeof(struct kernel_lb_addr));
 757			laarr[0].extLength = EXT_NOT_RECORDED_NOT_ALLOCATED;
 758			/* Will udf_do_extend_file() create real extent from
 759			   a fake one? */
 760			startnum = (offset > 0);
 761		}
 762		/* Create extents for the hole between EOF and offset */
 763		ret = udf_do_extend_file(inode, &prev_epos, laarr, offset);
 764		if (ret < 0) {
 
 
 
 765			*err = ret;
 766			newblock = 0;
 767			goto out_free;
 768		}
 769		c = 0;
 770		offset = 0;
 771		count += ret;
 772		/* We are not covered by a preallocated extent? */
 773		if ((laarr[0].extLength & UDF_EXTENT_FLAG_MASK) !=
 774						EXT_NOT_RECORDED_ALLOCATED) {
 775			/* Is there any real extent? - otherwise we overwrite
 776			 * the fake one... */
 777			if (count)
 778				c = !c;
 779			laarr[c].extLength = EXT_NOT_RECORDED_NOT_ALLOCATED |
 780				inode->i_sb->s_blocksize;
 781			memset(&laarr[c].extLocation, 0x00,
 782				sizeof(struct kernel_lb_addr));
 783			count++;
 784		}
 785		endnum = c + 1;
 786		lastblock = 1;
 787	} else {
 788		isBeyondEOF = false;
 789		endnum = startnum = ((count > 2) ? 2 : count);
 790
 791		/* if the current extent is in position 0,
 792		   swap it with the previous */
 793		if (!c && count != 1) {
 794			laarr[2] = laarr[0];
 795			laarr[0] = laarr[1];
 796			laarr[1] = laarr[2];
 797			c = 1;
 798		}
 799
 800		/* if the current block is located in an extent,
 801		   read the next extent */
 802		etype = udf_next_aext(inode, &next_epos, &eloc, &elen, 0);
 803		if (etype != -1) {
 804			laarr[c + 1].extLength = (etype << 30) | elen;
 805			laarr[c + 1].extLocation = eloc;
 806			count++;
 807			startnum++;
 808			endnum++;
 809		} else
 810			lastblock = 1;
 811	}
 812
 813	/* if the current extent is not recorded but allocated, get the
 814	 * block in the extent corresponding to the requested block */
 815	if ((laarr[c].extLength >> 30) == (EXT_NOT_RECORDED_ALLOCATED >> 30))
 816		newblocknum = laarr[c].extLocation.logicalBlockNum + offset;
 817	else { /* otherwise, allocate a new block */
 818		if (iinfo->i_next_alloc_block == block)
 819			goal = iinfo->i_next_alloc_goal;
 820
 821		if (!goal) {
 822			if (!(goal = pgoal)) /* XXX: what was intended here? */
 823				goal = iinfo->i_location.logicalBlockNum + 1;
 824		}
 825
 826		newblocknum = udf_new_block(inode->i_sb, inode,
 827				iinfo->i_location.partitionReferenceNum,
 828				goal, err);
 829		if (!newblocknum) {
 
 
 
 830			*err = -ENOSPC;
 831			newblock = 0;
 832			goto out_free;
 833		}
 834		if (isBeyondEOF)
 835			iinfo->i_lenExtents += inode->i_sb->s_blocksize;
 836	}
 837
 838	/* if the extent the requsted block is located in contains multiple
 839	 * blocks, split the extent into at most three extents. blocks prior
 840	 * to requested block, requested block, and blocks after requested
 841	 * block */
 842	udf_split_extents(inode, &c, offset, newblocknum, laarr, &endnum);
 843
 
 844	/* We preallocate blocks only for regular files. It also makes sense
 845	 * for directories but there's a problem when to drop the
 846	 * preallocation. We might use some delayed work for that but I feel
 847	 * it's overengineering for a filesystem like UDF. */
 848	if (S_ISREG(inode->i_mode))
 849		udf_prealloc_extents(inode, c, lastblock, laarr, &endnum);
 
 850
 851	/* merge any continuous blocks in laarr */
 852	udf_merge_extents(inode, laarr, &endnum);
 853
 854	/* write back the new extents, inserting new extents if the new number
 855	 * of extents is greater than the old number, and deleting extents if
 856	 * the new number of extents is less than the old number */
 857	udf_update_extents(inode, laarr, startnum, endnum, &prev_epos);
 858
 
 
 
 
 859	newblock = udf_get_pblock(inode->i_sb, newblocknum,
 860				iinfo->i_location.partitionReferenceNum, 0);
 861	if (!newblock) {
 862		*err = -EIO;
 863		goto out_free;
 864	}
 865	*new = 1;
 866	iinfo->i_next_alloc_block = block;
 867	iinfo->i_next_alloc_goal = newblocknum;
 868	inode->i_ctime = current_time(inode);
 869
 870	if (IS_SYNC(inode))
 871		udf_sync_inode(inode);
 872	else
 873		mark_inode_dirty(inode);
 874out_free:
 875	brelse(prev_epos.bh);
 876	brelse(cur_epos.bh);
 877	brelse(next_epos.bh);
 878	return newblock;
 879}
 880
 881static void udf_split_extents(struct inode *inode, int *c, int offset,
 882			       udf_pblk_t newblocknum,
 883			       struct kernel_long_ad *laarr, int *endnum)
 
 884{
 885	unsigned long blocksize = inode->i_sb->s_blocksize;
 886	unsigned char blocksize_bits = inode->i_sb->s_blocksize_bits;
 887
 888	if ((laarr[*c].extLength >> 30) == (EXT_NOT_RECORDED_ALLOCATED >> 30) ||
 889	    (laarr[*c].extLength >> 30) ==
 890				(EXT_NOT_RECORDED_NOT_ALLOCATED >> 30)) {
 891		int curr = *c;
 892		int blen = ((laarr[curr].extLength & UDF_EXTENT_LENGTH_MASK) +
 893			    blocksize - 1) >> blocksize_bits;
 894		int8_t etype = (laarr[curr].extLength >> 30);
 895
 896		if (blen == 1)
 897			;
 898		else if (!offset || blen == offset + 1) {
 899			laarr[curr + 2] = laarr[curr + 1];
 900			laarr[curr + 1] = laarr[curr];
 901		} else {
 902			laarr[curr + 3] = laarr[curr + 1];
 903			laarr[curr + 2] = laarr[curr + 1] = laarr[curr];
 904		}
 905
 906		if (offset) {
 907			if (etype == (EXT_NOT_RECORDED_ALLOCATED >> 30)) {
 908				udf_free_blocks(inode->i_sb, inode,
 909						&laarr[curr].extLocation,
 910						0, offset);
 911				laarr[curr].extLength =
 912					EXT_NOT_RECORDED_NOT_ALLOCATED |
 913					(offset << blocksize_bits);
 914				laarr[curr].extLocation.logicalBlockNum = 0;
 915				laarr[curr].extLocation.
 916						partitionReferenceNum = 0;
 917			} else
 918				laarr[curr].extLength = (etype << 30) |
 919					(offset << blocksize_bits);
 920			curr++;
 921			(*c)++;
 922			(*endnum)++;
 923		}
 924
 925		laarr[curr].extLocation.logicalBlockNum = newblocknum;
 926		if (etype == (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30))
 927			laarr[curr].extLocation.partitionReferenceNum =
 928				UDF_I(inode)->i_location.partitionReferenceNum;
 929		laarr[curr].extLength = EXT_RECORDED_ALLOCATED |
 930			blocksize;
 931		curr++;
 932
 933		if (blen != offset + 1) {
 934			if (etype == (EXT_NOT_RECORDED_ALLOCATED >> 30))
 935				laarr[curr].extLocation.logicalBlockNum +=
 936								offset + 1;
 937			laarr[curr].extLength = (etype << 30) |
 938				((blen - (offset + 1)) << blocksize_bits);
 939			curr++;
 940			(*endnum)++;
 941		}
 942	}
 943}
 944
 945static void udf_prealloc_extents(struct inode *inode, int c, int lastblock,
 946				 struct kernel_long_ad *laarr,
 947				 int *endnum)
 948{
 949	int start, length = 0, currlength = 0, i;
 950
 951	if (*endnum >= (c + 1)) {
 952		if (!lastblock)
 953			return;
 954		else
 955			start = c;
 956	} else {
 957		if ((laarr[c + 1].extLength >> 30) ==
 958					(EXT_NOT_RECORDED_ALLOCATED >> 30)) {
 959			start = c + 1;
 960			length = currlength =
 961				(((laarr[c + 1].extLength &
 962					UDF_EXTENT_LENGTH_MASK) +
 963				inode->i_sb->s_blocksize - 1) >>
 964				inode->i_sb->s_blocksize_bits);
 965		} else
 966			start = c;
 967	}
 968
 969	for (i = start + 1; i <= *endnum; i++) {
 970		if (i == *endnum) {
 971			if (lastblock)
 972				length += UDF_DEFAULT_PREALLOC_BLOCKS;
 973		} else if ((laarr[i].extLength >> 30) ==
 974				(EXT_NOT_RECORDED_NOT_ALLOCATED >> 30)) {
 975			length += (((laarr[i].extLength &
 976						UDF_EXTENT_LENGTH_MASK) +
 977				    inode->i_sb->s_blocksize - 1) >>
 978				    inode->i_sb->s_blocksize_bits);
 979		} else
 980			break;
 981	}
 982
 983	if (length) {
 984		int next = laarr[start].extLocation.logicalBlockNum +
 985			(((laarr[start].extLength & UDF_EXTENT_LENGTH_MASK) +
 986			  inode->i_sb->s_blocksize - 1) >>
 987			  inode->i_sb->s_blocksize_bits);
 988		int numalloc = udf_prealloc_blocks(inode->i_sb, inode,
 989				laarr[start].extLocation.partitionReferenceNum,
 990				next, (UDF_DEFAULT_PREALLOC_BLOCKS > length ?
 991				length : UDF_DEFAULT_PREALLOC_BLOCKS) -
 992				currlength);
 993		if (numalloc) 	{
 994			if (start == (c + 1))
 995				laarr[start].extLength +=
 996					(numalloc <<
 997					 inode->i_sb->s_blocksize_bits);
 998			else {
 999				memmove(&laarr[c + 2], &laarr[c + 1],
1000					sizeof(struct long_ad) * (*endnum - (c + 1)));
1001				(*endnum)++;
1002				laarr[c + 1].extLocation.logicalBlockNum = next;
1003				laarr[c + 1].extLocation.partitionReferenceNum =
1004					laarr[c].extLocation.
1005							partitionReferenceNum;
1006				laarr[c + 1].extLength =
1007					EXT_NOT_RECORDED_ALLOCATED |
1008					(numalloc <<
1009					 inode->i_sb->s_blocksize_bits);
1010				start = c + 1;
1011			}
1012
1013			for (i = start + 1; numalloc && i < *endnum; i++) {
1014				int elen = ((laarr[i].extLength &
1015						UDF_EXTENT_LENGTH_MASK) +
1016					    inode->i_sb->s_blocksize - 1) >>
1017					    inode->i_sb->s_blocksize_bits;
1018
1019				if (elen > numalloc) {
1020					laarr[i].extLength -=
1021						(numalloc <<
1022						 inode->i_sb->s_blocksize_bits);
1023					numalloc = 0;
1024				} else {
1025					numalloc -= elen;
1026					if (*endnum > (i + 1))
1027						memmove(&laarr[i],
1028							&laarr[i + 1],
1029							sizeof(struct long_ad) *
1030							(*endnum - (i + 1)));
1031					i--;
1032					(*endnum)--;
1033				}
1034			}
1035			UDF_I(inode)->i_lenExtents +=
1036				numalloc << inode->i_sb->s_blocksize_bits;
1037		}
1038	}
1039}
1040
1041static void udf_merge_extents(struct inode *inode, struct kernel_long_ad *laarr,
 
1042			      int *endnum)
1043{
1044	int i;
1045	unsigned long blocksize = inode->i_sb->s_blocksize;
1046	unsigned char blocksize_bits = inode->i_sb->s_blocksize_bits;
1047
1048	for (i = 0; i < (*endnum - 1); i++) {
1049		struct kernel_long_ad *li /*l[i]*/ = &laarr[i];
1050		struct kernel_long_ad *lip1 /*l[i plus 1]*/ = &laarr[i + 1];
1051
1052		if (((li->extLength >> 30) == (lip1->extLength >> 30)) &&
1053			(((li->extLength >> 30) ==
1054				(EXT_NOT_RECORDED_NOT_ALLOCATED >> 30)) ||
1055			((lip1->extLocation.logicalBlockNum -
1056			  li->extLocation.logicalBlockNum) ==
1057			(((li->extLength & UDF_EXTENT_LENGTH_MASK) +
1058			blocksize - 1) >> blocksize_bits)))) {
1059
1060			if (((li->extLength & UDF_EXTENT_LENGTH_MASK) +
1061				(lip1->extLength & UDF_EXTENT_LENGTH_MASK) +
1062				blocksize - 1) & ~UDF_EXTENT_LENGTH_MASK) {
1063				lip1->extLength = (lip1->extLength -
1064						  (li->extLength &
1065						   UDF_EXTENT_LENGTH_MASK) +
1066						   UDF_EXTENT_LENGTH_MASK) &
1067							~(blocksize - 1);
1068				li->extLength = (li->extLength &
1069						 UDF_EXTENT_FLAG_MASK) +
1070						(UDF_EXTENT_LENGTH_MASK + 1) -
1071						blocksize;
1072				lip1->extLocation.logicalBlockNum =
1073					li->extLocation.logicalBlockNum +
1074					((li->extLength &
1075						UDF_EXTENT_LENGTH_MASK) >>
1076						blocksize_bits);
1077			} else {
1078				li->extLength = lip1->extLength +
1079					(((li->extLength &
1080						UDF_EXTENT_LENGTH_MASK) +
1081					 blocksize - 1) & ~(blocksize - 1));
1082				if (*endnum > (i + 2))
1083					memmove(&laarr[i + 1], &laarr[i + 2],
1084						sizeof(struct long_ad) *
1085						(*endnum - (i + 2)));
1086				i--;
1087				(*endnum)--;
1088			}
1089		} else if (((li->extLength >> 30) ==
1090				(EXT_NOT_RECORDED_ALLOCATED >> 30)) &&
1091			   ((lip1->extLength >> 30) ==
1092				(EXT_NOT_RECORDED_NOT_ALLOCATED >> 30))) {
1093			udf_free_blocks(inode->i_sb, inode, &li->extLocation, 0,
1094					((li->extLength &
1095					  UDF_EXTENT_LENGTH_MASK) +
1096					 blocksize - 1) >> blocksize_bits);
1097			li->extLocation.logicalBlockNum = 0;
1098			li->extLocation.partitionReferenceNum = 0;
1099
1100			if (((li->extLength & UDF_EXTENT_LENGTH_MASK) +
1101			     (lip1->extLength & UDF_EXTENT_LENGTH_MASK) +
1102			     blocksize - 1) & ~UDF_EXTENT_LENGTH_MASK) {
1103				lip1->extLength = (lip1->extLength -
1104						   (li->extLength &
1105						   UDF_EXTENT_LENGTH_MASK) +
1106						   UDF_EXTENT_LENGTH_MASK) &
1107						   ~(blocksize - 1);
1108				li->extLength = (li->extLength &
1109						 UDF_EXTENT_FLAG_MASK) +
1110						(UDF_EXTENT_LENGTH_MASK + 1) -
1111						blocksize;
1112			} else {
1113				li->extLength = lip1->extLength +
1114					(((li->extLength &
1115						UDF_EXTENT_LENGTH_MASK) +
1116					  blocksize - 1) & ~(blocksize - 1));
1117				if (*endnum > (i + 2))
1118					memmove(&laarr[i + 1], &laarr[i + 2],
1119						sizeof(struct long_ad) *
1120						(*endnum - (i + 2)));
1121				i--;
1122				(*endnum)--;
1123			}
1124		} else if ((li->extLength >> 30) ==
1125					(EXT_NOT_RECORDED_ALLOCATED >> 30)) {
1126			udf_free_blocks(inode->i_sb, inode,
1127					&li->extLocation, 0,
1128					((li->extLength &
1129						UDF_EXTENT_LENGTH_MASK) +
1130					 blocksize - 1) >> blocksize_bits);
1131			li->extLocation.logicalBlockNum = 0;
1132			li->extLocation.partitionReferenceNum = 0;
1133			li->extLength = (li->extLength &
1134						UDF_EXTENT_LENGTH_MASK) |
1135						EXT_NOT_RECORDED_NOT_ALLOCATED;
1136		}
1137	}
1138}
1139
1140static void udf_update_extents(struct inode *inode, struct kernel_long_ad *laarr,
 
1141			       int startnum, int endnum,
1142			       struct extent_position *epos)
1143{
1144	int start = 0, i;
1145	struct kernel_lb_addr tmploc;
1146	uint32_t tmplen;
1147
1148	if (startnum > endnum) {
1149		for (i = 0; i < (startnum - endnum); i++)
1150			udf_delete_aext(inode, *epos, laarr[i].extLocation,
1151					laarr[i].extLength);
1152	} else if (startnum < endnum) {
1153		for (i = 0; i < (endnum - startnum); i++) {
1154			udf_insert_aext(inode, *epos, laarr[i].extLocation,
1155					laarr[i].extLength);
1156			udf_next_aext(inode, epos, &laarr[i].extLocation,
1157				      &laarr[i].extLength, 1);
1158			start++;
1159		}
1160	}
1161
1162	for (i = start; i < endnum; i++) {
1163		udf_next_aext(inode, epos, &tmploc, &tmplen, 0);
1164		udf_write_aext(inode, epos, &laarr[i].extLocation,
1165			       laarr[i].extLength, 1);
1166	}
1167}
1168
1169struct buffer_head *udf_bread(struct inode *inode, udf_pblk_t block,
1170			      int create, int *err)
1171{
1172	struct buffer_head *bh = NULL;
1173
1174	bh = udf_getblk(inode, block, create, err);
1175	if (!bh)
1176		return NULL;
1177
1178	if (buffer_uptodate(bh))
1179		return bh;
1180
1181	ll_rw_block(REQ_OP_READ, 0, 1, &bh);
1182
1183	wait_on_buffer(bh);
1184	if (buffer_uptodate(bh))
1185		return bh;
1186
1187	brelse(bh);
1188	*err = -EIO;
1189	return NULL;
1190}
1191
1192int udf_setsize(struct inode *inode, loff_t newsize)
1193{
1194	int err;
1195	struct udf_inode_info *iinfo;
1196	unsigned int bsize = i_blocksize(inode);
1197
1198	if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
1199	      S_ISLNK(inode->i_mode)))
1200		return -EINVAL;
1201	if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
1202		return -EPERM;
1203
1204	iinfo = UDF_I(inode);
1205	if (newsize > inode->i_size) {
1206		down_write(&iinfo->i_data_sem);
1207		if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {
1208			if (bsize <
1209			    (udf_file_entry_alloc_offset(inode) + newsize)) {
1210				err = udf_expand_file_adinicb(inode);
1211				if (err)
1212					return err;
1213				down_write(&iinfo->i_data_sem);
1214			} else {
1215				iinfo->i_lenAlloc = newsize;
1216				goto set_size;
1217			}
1218		}
1219		err = udf_extend_file(inode, newsize);
1220		if (err) {
1221			up_write(&iinfo->i_data_sem);
1222			return err;
1223		}
1224set_size:
1225		up_write(&iinfo->i_data_sem);
1226		truncate_setsize(inode, newsize);
 
1227	} else {
1228		if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {
1229			down_write(&iinfo->i_data_sem);
1230			udf_clear_extent_cache(inode);
1231			memset(iinfo->i_ext.i_data + iinfo->i_lenEAttr + newsize,
1232			       0x00, bsize - newsize -
1233			       udf_file_entry_alloc_offset(inode));
1234			iinfo->i_lenAlloc = newsize;
1235			truncate_setsize(inode, newsize);
1236			up_write(&iinfo->i_data_sem);
1237			goto update_time;
1238		}
1239		err = block_truncate_page(inode->i_mapping, newsize,
1240					  udf_get_block);
1241		if (err)
1242			return err;
1243		truncate_setsize(inode, newsize);
1244		down_write(&iinfo->i_data_sem);
1245		udf_clear_extent_cache(inode);
 
1246		udf_truncate_extents(inode);
1247		up_write(&iinfo->i_data_sem);
1248	}
1249update_time:
1250	inode->i_mtime = inode->i_ctime = current_time(inode);
1251	if (IS_SYNC(inode))
1252		udf_sync_inode(inode);
1253	else
1254		mark_inode_dirty(inode);
1255	return 0;
1256}
1257
1258/*
1259 * Maximum length of linked list formed by ICB hierarchy. The chosen number is
1260 * arbitrary - just that we hopefully don't limit any real use of rewritten
1261 * inode on write-once media but avoid looping for too long on corrupted media.
1262 */
1263#define UDF_MAX_ICB_NESTING 1024
1264
1265static int udf_read_inode(struct inode *inode, bool hidden_inode)
1266{
1267	struct buffer_head *bh = NULL;
1268	struct fileEntry *fe;
1269	struct extendedFileEntry *efe;
1270	uint16_t ident;
1271	struct udf_inode_info *iinfo = UDF_I(inode);
1272	struct udf_sb_info *sbi = UDF_SB(inode->i_sb);
1273	struct kernel_lb_addr *iloc = &iinfo->i_location;
1274	unsigned int link_count;
1275	unsigned int indirections = 0;
1276	int bs = inode->i_sb->s_blocksize;
1277	int ret = -EIO;
1278	uint32_t uid, gid;
1279
1280reread:
1281	if (iloc->partitionReferenceNum >= sbi->s_partitions) {
1282		udf_debug("partition reference: %u > logical volume partitions: %u\n",
1283			  iloc->partitionReferenceNum, sbi->s_partitions);
1284		return -EIO;
1285	}
1286
1287	if (iloc->logicalBlockNum >=
1288	    sbi->s_partmaps[iloc->partitionReferenceNum].s_partition_len) {
1289		udf_debug("block=%u, partition=%u out of range\n",
1290			  iloc->logicalBlockNum, iloc->partitionReferenceNum);
1291		return -EIO;
1292	}
1293
1294	/*
1295	 * Set defaults, but the inode is still incomplete!
1296	 * Note: get_new_inode() sets the following on a new inode:
1297	 *      i_sb = sb
1298	 *      i_no = ino
1299	 *      i_flags = sb->s_flags
1300	 *      i_state = 0
1301	 * clean_inode(): zero fills and sets
1302	 *      i_count = 1
1303	 *      i_nlink = 1
1304	 *      i_op = NULL;
1305	 */
1306	bh = udf_read_ptagged(inode->i_sb, iloc, 0, &ident);
1307	if (!bh) {
1308		udf_err(inode->i_sb, "(ino %lu) failed !bh\n", inode->i_ino);
1309		return -EIO;
1310	}
1311
1312	if (ident != TAG_IDENT_FE && ident != TAG_IDENT_EFE &&
1313	    ident != TAG_IDENT_USE) {
1314		udf_err(inode->i_sb, "(ino %lu) failed ident=%u\n",
1315			inode->i_ino, ident);
1316		goto out;
1317	}
1318
1319	fe = (struct fileEntry *)bh->b_data;
1320	efe = (struct extendedFileEntry *)bh->b_data;
1321
1322	if (fe->icbTag.strategyType == cpu_to_le16(4096)) {
1323		struct buffer_head *ibh;
1324
1325		ibh = udf_read_ptagged(inode->i_sb, iloc, 1, &ident);
1326		if (ident == TAG_IDENT_IE && ibh) {
1327			struct kernel_lb_addr loc;
1328			struct indirectEntry *ie;
1329
1330			ie = (struct indirectEntry *)ibh->b_data;
1331			loc = lelb_to_cpu(ie->indirectICB.extLocation);
1332
1333			if (ie->indirectICB.extLength) {
1334				brelse(ibh);
1335				memcpy(&iinfo->i_location, &loc,
1336				       sizeof(struct kernel_lb_addr));
1337				if (++indirections > UDF_MAX_ICB_NESTING) {
1338					udf_err(inode->i_sb,
1339						"too many ICBs in ICB hierarchy"
1340						" (max %d supported)\n",
1341						UDF_MAX_ICB_NESTING);
1342					goto out;
1343				}
1344				brelse(bh);
1345				goto reread;
1346			}
1347		}
1348		brelse(ibh);
1349	} else if (fe->icbTag.strategyType != cpu_to_le16(4)) {
1350		udf_err(inode->i_sb, "unsupported strategy type: %u\n",
1351			le16_to_cpu(fe->icbTag.strategyType));
1352		goto out;
1353	}
1354	if (fe->icbTag.strategyType == cpu_to_le16(4))
1355		iinfo->i_strat4096 = 0;
1356	else /* if (fe->icbTag.strategyType == cpu_to_le16(4096)) */
1357		iinfo->i_strat4096 = 1;
1358
1359	iinfo->i_alloc_type = le16_to_cpu(fe->icbTag.flags) &
1360							ICBTAG_FLAG_AD_MASK;
1361	iinfo->i_unique = 0;
1362	iinfo->i_lenEAttr = 0;
1363	iinfo->i_lenExtents = 0;
1364	iinfo->i_lenAlloc = 0;
1365	iinfo->i_next_alloc_block = 0;
1366	iinfo->i_next_alloc_goal = 0;
1367	if (fe->descTag.tagIdent == cpu_to_le16(TAG_IDENT_EFE)) {
1368		iinfo->i_efe = 1;
1369		iinfo->i_use = 0;
1370		ret = udf_alloc_i_data(inode, bs -
1371					sizeof(struct extendedFileEntry));
1372		if (ret)
1373			goto out;
1374		memcpy(iinfo->i_ext.i_data,
1375		       bh->b_data + sizeof(struct extendedFileEntry),
1376		       bs - sizeof(struct extendedFileEntry));
1377	} else if (fe->descTag.tagIdent == cpu_to_le16(TAG_IDENT_FE)) {
1378		iinfo->i_efe = 0;
1379		iinfo->i_use = 0;
1380		ret = udf_alloc_i_data(inode, bs - sizeof(struct fileEntry));
1381		if (ret)
1382			goto out;
1383		memcpy(iinfo->i_ext.i_data,
1384		       bh->b_data + sizeof(struct fileEntry),
1385		       bs - sizeof(struct fileEntry));
1386	} else if (fe->descTag.tagIdent == cpu_to_le16(TAG_IDENT_USE)) {
1387		iinfo->i_efe = 0;
1388		iinfo->i_use = 1;
1389		iinfo->i_lenAlloc = le32_to_cpu(
1390				((struct unallocSpaceEntry *)bh->b_data)->
1391				 lengthAllocDescs);
1392		ret = udf_alloc_i_data(inode, bs -
1393					sizeof(struct unallocSpaceEntry));
1394		if (ret)
1395			goto out;
1396		memcpy(iinfo->i_ext.i_data,
1397		       bh->b_data + sizeof(struct unallocSpaceEntry),
1398		       bs - sizeof(struct unallocSpaceEntry));
1399		return 0;
1400	}
1401
1402	ret = -EIO;
1403	read_lock(&sbi->s_cred_lock);
1404	uid = le32_to_cpu(fe->uid);
1405	if (uid == UDF_INVALID_ID ||
 
1406	    UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_UID_SET))
1407		inode->i_uid = sbi->s_uid;
1408	else
1409		i_uid_write(inode, uid);
1410
1411	gid = le32_to_cpu(fe->gid);
1412	if (gid == UDF_INVALID_ID ||
 
1413	    UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_GID_SET))
1414		inode->i_gid = sbi->s_gid;
1415	else
1416		i_gid_write(inode, gid);
1417
1418	if (fe->icbTag.fileType != ICBTAG_FILE_TYPE_DIRECTORY &&
1419			sbi->s_fmode != UDF_INVALID_MODE)
1420		inode->i_mode = sbi->s_fmode;
1421	else if (fe->icbTag.fileType == ICBTAG_FILE_TYPE_DIRECTORY &&
1422			sbi->s_dmode != UDF_INVALID_MODE)
1423		inode->i_mode = sbi->s_dmode;
1424	else
1425		inode->i_mode = udf_convert_permissions(fe);
1426	inode->i_mode &= ~sbi->s_umask;
1427	read_unlock(&sbi->s_cred_lock);
1428
1429	link_count = le16_to_cpu(fe->fileLinkCount);
1430	if (!link_count) {
1431		if (!hidden_inode) {
1432			ret = -ESTALE;
1433			goto out;
1434		}
1435		link_count = 1;
1436	}
1437	set_nlink(inode, link_count);
1438
1439	inode->i_size = le64_to_cpu(fe->informationLength);
1440	iinfo->i_lenExtents = inode->i_size;
1441
1442	if (iinfo->i_efe == 0) {
1443		inode->i_blocks = le64_to_cpu(fe->logicalBlocksRecorded) <<
1444			(inode->i_sb->s_blocksize_bits - 9);
1445
1446		if (!udf_disk_stamp_to_time(&inode->i_atime, fe->accessTime))
1447			inode->i_atime = sbi->s_record_time;
1448
1449		if (!udf_disk_stamp_to_time(&inode->i_mtime,
1450					    fe->modificationTime))
1451			inode->i_mtime = sbi->s_record_time;
1452
1453		if (!udf_disk_stamp_to_time(&inode->i_ctime, fe->attrTime))
1454			inode->i_ctime = sbi->s_record_time;
1455
1456		iinfo->i_unique = le64_to_cpu(fe->uniqueID);
1457		iinfo->i_lenEAttr = le32_to_cpu(fe->lengthExtendedAttr);
1458		iinfo->i_lenAlloc = le32_to_cpu(fe->lengthAllocDescs);
1459		iinfo->i_checkpoint = le32_to_cpu(fe->checkpoint);
1460	} else {
1461		inode->i_blocks = le64_to_cpu(efe->logicalBlocksRecorded) <<
1462		    (inode->i_sb->s_blocksize_bits - 9);
1463
1464		if (!udf_disk_stamp_to_time(&inode->i_atime, efe->accessTime))
1465			inode->i_atime = sbi->s_record_time;
1466
1467		if (!udf_disk_stamp_to_time(&inode->i_mtime,
1468					    efe->modificationTime))
1469			inode->i_mtime = sbi->s_record_time;
1470
1471		if (!udf_disk_stamp_to_time(&iinfo->i_crtime, efe->createTime))
1472			iinfo->i_crtime = sbi->s_record_time;
1473
1474		if (!udf_disk_stamp_to_time(&inode->i_ctime, efe->attrTime))
1475			inode->i_ctime = sbi->s_record_time;
1476
1477		iinfo->i_unique = le64_to_cpu(efe->uniqueID);
1478		iinfo->i_lenEAttr = le32_to_cpu(efe->lengthExtendedAttr);
1479		iinfo->i_lenAlloc = le32_to_cpu(efe->lengthAllocDescs);
1480		iinfo->i_checkpoint = le32_to_cpu(efe->checkpoint);
1481	}
1482	inode->i_generation = iinfo->i_unique;
1483
1484	/*
1485	 * Sanity check length of allocation descriptors and extended attrs to
1486	 * avoid integer overflows
1487	 */
1488	if (iinfo->i_lenEAttr > bs || iinfo->i_lenAlloc > bs)
1489		goto out;
1490	/* Now do exact checks */
1491	if (udf_file_entry_alloc_offset(inode) + iinfo->i_lenAlloc > bs)
1492		goto out;
1493	/* Sanity checks for files in ICB so that we don't get confused later */
1494	if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {
1495		/*
1496		 * For file in ICB data is stored in allocation descriptor
1497		 * so sizes should match
1498		 */
1499		if (iinfo->i_lenAlloc != inode->i_size)
1500			goto out;
1501		/* File in ICB has to fit in there... */
1502		if (inode->i_size > bs - udf_file_entry_alloc_offset(inode))
1503			goto out;
1504	}
1505
1506	switch (fe->icbTag.fileType) {
1507	case ICBTAG_FILE_TYPE_DIRECTORY:
1508		inode->i_op = &udf_dir_inode_operations;
1509		inode->i_fop = &udf_dir_operations;
1510		inode->i_mode |= S_IFDIR;
1511		inc_nlink(inode);
1512		break;
1513	case ICBTAG_FILE_TYPE_REALTIME:
1514	case ICBTAG_FILE_TYPE_REGULAR:
1515	case ICBTAG_FILE_TYPE_UNDEF:
1516	case ICBTAG_FILE_TYPE_VAT20:
1517		if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
1518			inode->i_data.a_ops = &udf_adinicb_aops;
1519		else
1520			inode->i_data.a_ops = &udf_aops;
1521		inode->i_op = &udf_file_inode_operations;
1522		inode->i_fop = &udf_file_operations;
1523		inode->i_mode |= S_IFREG;
1524		break;
1525	case ICBTAG_FILE_TYPE_BLOCK:
1526		inode->i_mode |= S_IFBLK;
1527		break;
1528	case ICBTAG_FILE_TYPE_CHAR:
1529		inode->i_mode |= S_IFCHR;
1530		break;
1531	case ICBTAG_FILE_TYPE_FIFO:
1532		init_special_inode(inode, inode->i_mode | S_IFIFO, 0);
1533		break;
1534	case ICBTAG_FILE_TYPE_SOCKET:
1535		init_special_inode(inode, inode->i_mode | S_IFSOCK, 0);
1536		break;
1537	case ICBTAG_FILE_TYPE_SYMLINK:
1538		inode->i_data.a_ops = &udf_symlink_aops;
1539		inode->i_op = &udf_symlink_inode_operations;
1540		inode_nohighmem(inode);
1541		inode->i_mode = S_IFLNK | 0777;
1542		break;
1543	case ICBTAG_FILE_TYPE_MAIN:
1544		udf_debug("METADATA FILE-----\n");
1545		break;
1546	case ICBTAG_FILE_TYPE_MIRROR:
1547		udf_debug("METADATA MIRROR FILE-----\n");
1548		break;
1549	case ICBTAG_FILE_TYPE_BITMAP:
1550		udf_debug("METADATA BITMAP FILE-----\n");
1551		break;
1552	default:
1553		udf_err(inode->i_sb, "(ino %lu) failed unknown file type=%u\n",
1554			inode->i_ino, fe->icbTag.fileType);
1555		goto out;
1556	}
1557	if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) {
1558		struct deviceSpec *dsea =
1559			(struct deviceSpec *)udf_get_extendedattr(inode, 12, 1);
1560		if (dsea) {
1561			init_special_inode(inode, inode->i_mode,
1562				MKDEV(le32_to_cpu(dsea->majorDeviceIdent),
1563				      le32_to_cpu(dsea->minorDeviceIdent)));
1564			/* Developer ID ??? */
1565		} else
1566			goto out;
1567	}
1568	ret = 0;
1569out:
1570	brelse(bh);
1571	return ret;
1572}
1573
1574static int udf_alloc_i_data(struct inode *inode, size_t size)
1575{
1576	struct udf_inode_info *iinfo = UDF_I(inode);
1577	iinfo->i_ext.i_data = kmalloc(size, GFP_KERNEL);
1578	if (!iinfo->i_ext.i_data)
 
 
 
1579		return -ENOMEM;
 
 
1580	return 0;
1581}
1582
1583static umode_t udf_convert_permissions(struct fileEntry *fe)
1584{
1585	umode_t mode;
1586	uint32_t permissions;
1587	uint32_t flags;
1588
1589	permissions = le32_to_cpu(fe->permissions);
1590	flags = le16_to_cpu(fe->icbTag.flags);
1591
1592	mode =	((permissions) & 0007) |
1593		((permissions >> 2) & 0070) |
1594		((permissions >> 4) & 0700) |
1595		((flags & ICBTAG_FLAG_SETUID) ? S_ISUID : 0) |
1596		((flags & ICBTAG_FLAG_SETGID) ? S_ISGID : 0) |
1597		((flags & ICBTAG_FLAG_STICKY) ? S_ISVTX : 0);
1598
1599	return mode;
1600}
1601
1602int udf_write_inode(struct inode *inode, struct writeback_control *wbc)
1603{
1604	return udf_update_inode(inode, wbc->sync_mode == WB_SYNC_ALL);
1605}
1606
1607static int udf_sync_inode(struct inode *inode)
1608{
1609	return udf_update_inode(inode, 1);
1610}
1611
1612static void udf_adjust_time(struct udf_inode_info *iinfo, struct timespec time)
1613{
1614	if (iinfo->i_crtime.tv_sec > time.tv_sec ||
1615	    (iinfo->i_crtime.tv_sec == time.tv_sec &&
1616	     iinfo->i_crtime.tv_nsec > time.tv_nsec))
1617		iinfo->i_crtime = time;
1618}
1619
1620static int udf_update_inode(struct inode *inode, int do_sync)
1621{
1622	struct buffer_head *bh = NULL;
1623	struct fileEntry *fe;
1624	struct extendedFileEntry *efe;
1625	uint64_t lb_recorded;
1626	uint32_t udfperms;
1627	uint16_t icbflags;
1628	uint16_t crclen;
1629	int err = 0;
1630	struct udf_sb_info *sbi = UDF_SB(inode->i_sb);
1631	unsigned char blocksize_bits = inode->i_sb->s_blocksize_bits;
1632	struct udf_inode_info *iinfo = UDF_I(inode);
1633
1634	bh = udf_tgetblk(inode->i_sb,
1635			udf_get_lb_pblock(inode->i_sb, &iinfo->i_location, 0));
1636	if (!bh) {
1637		udf_debug("getblk failure\n");
1638		return -EIO;
1639	}
1640
1641	lock_buffer(bh);
1642	memset(bh->b_data, 0, inode->i_sb->s_blocksize);
1643	fe = (struct fileEntry *)bh->b_data;
1644	efe = (struct extendedFileEntry *)bh->b_data;
1645
1646	if (iinfo->i_use) {
1647		struct unallocSpaceEntry *use =
1648			(struct unallocSpaceEntry *)bh->b_data;
1649
1650		use->lengthAllocDescs = cpu_to_le32(iinfo->i_lenAlloc);
1651		memcpy(bh->b_data + sizeof(struct unallocSpaceEntry),
1652		       iinfo->i_ext.i_data, inode->i_sb->s_blocksize -
1653					sizeof(struct unallocSpaceEntry));
1654		use->descTag.tagIdent = cpu_to_le16(TAG_IDENT_USE);
1655		crclen = sizeof(struct unallocSpaceEntry);
1656
1657		goto finish;
1658	}
1659
1660	if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_UID_FORGET))
1661		fe->uid = cpu_to_le32(UDF_INVALID_ID);
1662	else
1663		fe->uid = cpu_to_le32(i_uid_read(inode));
1664
1665	if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_GID_FORGET))
1666		fe->gid = cpu_to_le32(UDF_INVALID_ID);
1667	else
1668		fe->gid = cpu_to_le32(i_gid_read(inode));
1669
1670	udfperms = ((inode->i_mode & 0007)) |
1671		   ((inode->i_mode & 0070) << 2) |
1672		   ((inode->i_mode & 0700) << 4);
1673
1674	udfperms |= (le32_to_cpu(fe->permissions) &
1675		    (FE_PERM_O_DELETE | FE_PERM_O_CHATTR |
1676		     FE_PERM_G_DELETE | FE_PERM_G_CHATTR |
1677		     FE_PERM_U_DELETE | FE_PERM_U_CHATTR));
1678	fe->permissions = cpu_to_le32(udfperms);
1679
1680	if (S_ISDIR(inode->i_mode) && inode->i_nlink > 0)
1681		fe->fileLinkCount = cpu_to_le16(inode->i_nlink - 1);
1682	else
1683		fe->fileLinkCount = cpu_to_le16(inode->i_nlink);
1684
1685	fe->informationLength = cpu_to_le64(inode->i_size);
1686
1687	if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) {
1688		struct regid *eid;
1689		struct deviceSpec *dsea =
1690			(struct deviceSpec *)udf_get_extendedattr(inode, 12, 1);
1691		if (!dsea) {
1692			dsea = (struct deviceSpec *)
1693				udf_add_extendedattr(inode,
1694						     sizeof(struct deviceSpec) +
1695						     sizeof(struct regid), 12, 0x3);
1696			dsea->attrType = cpu_to_le32(12);
1697			dsea->attrSubtype = 1;
1698			dsea->attrLength = cpu_to_le32(
1699						sizeof(struct deviceSpec) +
1700						sizeof(struct regid));
1701			dsea->impUseLength = cpu_to_le32(sizeof(struct regid));
1702		}
1703		eid = (struct regid *)dsea->impUse;
1704		memset(eid, 0, sizeof(*eid));
1705		strcpy(eid->ident, UDF_ID_DEVELOPER);
1706		eid->identSuffix[0] = UDF_OS_CLASS_UNIX;
1707		eid->identSuffix[1] = UDF_OS_ID_LINUX;
1708		dsea->majorDeviceIdent = cpu_to_le32(imajor(inode));
1709		dsea->minorDeviceIdent = cpu_to_le32(iminor(inode));
1710	}
1711
1712	if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
1713		lb_recorded = 0; /* No extents => no blocks! */
1714	else
1715		lb_recorded =
1716			(inode->i_blocks + (1 << (blocksize_bits - 9)) - 1) >>
1717			(blocksize_bits - 9);
1718
1719	if (iinfo->i_efe == 0) {
1720		memcpy(bh->b_data + sizeof(struct fileEntry),
1721		       iinfo->i_ext.i_data,
1722		       inode->i_sb->s_blocksize - sizeof(struct fileEntry));
1723		fe->logicalBlocksRecorded = cpu_to_le64(lb_recorded);
1724
1725		udf_time_to_disk_stamp(&fe->accessTime, inode->i_atime);
1726		udf_time_to_disk_stamp(&fe->modificationTime, inode->i_mtime);
1727		udf_time_to_disk_stamp(&fe->attrTime, inode->i_ctime);
1728		memset(&(fe->impIdent), 0, sizeof(struct regid));
1729		strcpy(fe->impIdent.ident, UDF_ID_DEVELOPER);
1730		fe->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX;
1731		fe->impIdent.identSuffix[1] = UDF_OS_ID_LINUX;
1732		fe->uniqueID = cpu_to_le64(iinfo->i_unique);
1733		fe->lengthExtendedAttr = cpu_to_le32(iinfo->i_lenEAttr);
1734		fe->lengthAllocDescs = cpu_to_le32(iinfo->i_lenAlloc);
1735		fe->checkpoint = cpu_to_le32(iinfo->i_checkpoint);
1736		fe->descTag.tagIdent = cpu_to_le16(TAG_IDENT_FE);
1737		crclen = sizeof(struct fileEntry);
1738	} else {
1739		memcpy(bh->b_data + sizeof(struct extendedFileEntry),
1740		       iinfo->i_ext.i_data,
1741		       inode->i_sb->s_blocksize -
1742					sizeof(struct extendedFileEntry));
1743		efe->objectSize = cpu_to_le64(inode->i_size);
1744		efe->logicalBlocksRecorded = cpu_to_le64(lb_recorded);
1745
1746		udf_adjust_time(iinfo, inode->i_atime);
1747		udf_adjust_time(iinfo, inode->i_mtime);
1748		udf_adjust_time(iinfo, inode->i_ctime);
 
 
 
 
 
 
 
 
 
 
 
1749
1750		udf_time_to_disk_stamp(&efe->accessTime, inode->i_atime);
1751		udf_time_to_disk_stamp(&efe->modificationTime, inode->i_mtime);
1752		udf_time_to_disk_stamp(&efe->createTime, iinfo->i_crtime);
1753		udf_time_to_disk_stamp(&efe->attrTime, inode->i_ctime);
1754
1755		memset(&(efe->impIdent), 0, sizeof(efe->impIdent));
1756		strcpy(efe->impIdent.ident, UDF_ID_DEVELOPER);
1757		efe->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX;
1758		efe->impIdent.identSuffix[1] = UDF_OS_ID_LINUX;
1759		efe->uniqueID = cpu_to_le64(iinfo->i_unique);
1760		efe->lengthExtendedAttr = cpu_to_le32(iinfo->i_lenEAttr);
1761		efe->lengthAllocDescs = cpu_to_le32(iinfo->i_lenAlloc);
1762		efe->checkpoint = cpu_to_le32(iinfo->i_checkpoint);
1763		efe->descTag.tagIdent = cpu_to_le16(TAG_IDENT_EFE);
1764		crclen = sizeof(struct extendedFileEntry);
1765	}
1766
1767finish:
1768	if (iinfo->i_strat4096) {
1769		fe->icbTag.strategyType = cpu_to_le16(4096);
1770		fe->icbTag.strategyParameter = cpu_to_le16(1);
1771		fe->icbTag.numEntries = cpu_to_le16(2);
1772	} else {
1773		fe->icbTag.strategyType = cpu_to_le16(4);
1774		fe->icbTag.numEntries = cpu_to_le16(1);
1775	}
1776
1777	if (iinfo->i_use)
1778		fe->icbTag.fileType = ICBTAG_FILE_TYPE_USE;
1779	else if (S_ISDIR(inode->i_mode))
1780		fe->icbTag.fileType = ICBTAG_FILE_TYPE_DIRECTORY;
1781	else if (S_ISREG(inode->i_mode))
1782		fe->icbTag.fileType = ICBTAG_FILE_TYPE_REGULAR;
1783	else if (S_ISLNK(inode->i_mode))
1784		fe->icbTag.fileType = ICBTAG_FILE_TYPE_SYMLINK;
1785	else if (S_ISBLK(inode->i_mode))
1786		fe->icbTag.fileType = ICBTAG_FILE_TYPE_BLOCK;
1787	else if (S_ISCHR(inode->i_mode))
1788		fe->icbTag.fileType = ICBTAG_FILE_TYPE_CHAR;
1789	else if (S_ISFIFO(inode->i_mode))
1790		fe->icbTag.fileType = ICBTAG_FILE_TYPE_FIFO;
1791	else if (S_ISSOCK(inode->i_mode))
1792		fe->icbTag.fileType = ICBTAG_FILE_TYPE_SOCKET;
1793
1794	icbflags =	iinfo->i_alloc_type |
1795			((inode->i_mode & S_ISUID) ? ICBTAG_FLAG_SETUID : 0) |
1796			((inode->i_mode & S_ISGID) ? ICBTAG_FLAG_SETGID : 0) |
1797			((inode->i_mode & S_ISVTX) ? ICBTAG_FLAG_STICKY : 0) |
1798			(le16_to_cpu(fe->icbTag.flags) &
1799				~(ICBTAG_FLAG_AD_MASK | ICBTAG_FLAG_SETUID |
1800				ICBTAG_FLAG_SETGID | ICBTAG_FLAG_STICKY));
1801
1802	fe->icbTag.flags = cpu_to_le16(icbflags);
1803	if (sbi->s_udfrev >= 0x0200)
1804		fe->descTag.descVersion = cpu_to_le16(3);
1805	else
1806		fe->descTag.descVersion = cpu_to_le16(2);
1807	fe->descTag.tagSerialNum = cpu_to_le16(sbi->s_serial_number);
1808	fe->descTag.tagLocation = cpu_to_le32(
1809					iinfo->i_location.logicalBlockNum);
1810	crclen += iinfo->i_lenEAttr + iinfo->i_lenAlloc - sizeof(struct tag);
1811	fe->descTag.descCRCLength = cpu_to_le16(crclen);
1812	fe->descTag.descCRC = cpu_to_le16(crc_itu_t(0, (char *)fe + sizeof(struct tag),
1813						  crclen));
1814	fe->descTag.tagChecksum = udf_tag_checksum(&fe->descTag);
1815
1816	set_buffer_uptodate(bh);
1817	unlock_buffer(bh);
1818
1819	/* write the data blocks */
1820	mark_buffer_dirty(bh);
1821	if (do_sync) {
1822		sync_dirty_buffer(bh);
1823		if (buffer_write_io_error(bh)) {
1824			udf_warn(inode->i_sb, "IO error syncing udf inode [%08lx]\n",
1825				 inode->i_ino);
1826			err = -EIO;
1827		}
1828	}
1829	brelse(bh);
1830
1831	return err;
1832}
1833
1834struct inode *__udf_iget(struct super_block *sb, struct kernel_lb_addr *ino,
1835			 bool hidden_inode)
1836{
1837	unsigned long block = udf_get_lb_pblock(sb, ino, 0);
1838	struct inode *inode = iget_locked(sb, block);
1839	int err;
1840
1841	if (!inode)
1842		return ERR_PTR(-ENOMEM);
1843
1844	if (!(inode->i_state & I_NEW))
1845		return inode;
1846
1847	memcpy(&UDF_I(inode)->i_location, ino, sizeof(struct kernel_lb_addr));
1848	err = udf_read_inode(inode, hidden_inode);
1849	if (err < 0) {
1850		iget_failed(inode);
1851		return ERR_PTR(err);
1852	}
1853	unlock_new_inode(inode);
1854
1855	return inode;
1856}
1857
1858int udf_setup_indirect_aext(struct inode *inode, udf_pblk_t block,
1859			    struct extent_position *epos)
1860{
1861	struct super_block *sb = inode->i_sb;
1862	struct buffer_head *bh;
1863	struct allocExtDesc *aed;
1864	struct extent_position nepos;
1865	struct kernel_lb_addr neloc;
1866	int ver, adsize;
1867
1868	if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
1869		adsize = sizeof(struct short_ad);
1870	else if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_LONG)
1871		adsize = sizeof(struct long_ad);
1872	else
1873		return -EIO;
1874
1875	neloc.logicalBlockNum = block;
1876	neloc.partitionReferenceNum = epos->block.partitionReferenceNum;
1877
1878	bh = udf_tgetblk(sb, udf_get_lb_pblock(sb, &neloc, 0));
1879	if (!bh)
1880		return -EIO;
1881	lock_buffer(bh);
1882	memset(bh->b_data, 0x00, sb->s_blocksize);
1883	set_buffer_uptodate(bh);
1884	unlock_buffer(bh);
1885	mark_buffer_dirty_inode(bh, inode);
1886
1887	aed = (struct allocExtDesc *)(bh->b_data);
1888	if (!UDF_QUERY_FLAG(sb, UDF_FLAG_STRICT)) {
1889		aed->previousAllocExtLocation =
1890				cpu_to_le32(epos->block.logicalBlockNum);
1891	}
1892	aed->lengthAllocDescs = cpu_to_le32(0);
1893	if (UDF_SB(sb)->s_udfrev >= 0x0200)
1894		ver = 3;
1895	else
1896		ver = 2;
1897	udf_new_tag(bh->b_data, TAG_IDENT_AED, ver, 1, block,
1898		    sizeof(struct tag));
1899
1900	nepos.block = neloc;
1901	nepos.offset = sizeof(struct allocExtDesc);
1902	nepos.bh = bh;
1903
1904	/*
1905	 * Do we have to copy current last extent to make space for indirect
1906	 * one?
1907	 */
1908	if (epos->offset + adsize > sb->s_blocksize) {
1909		struct kernel_lb_addr cp_loc;
1910		uint32_t cp_len;
1911		int cp_type;
1912
1913		epos->offset -= adsize;
1914		cp_type = udf_current_aext(inode, epos, &cp_loc, &cp_len, 0);
1915		cp_len |= ((uint32_t)cp_type) << 30;
1916
1917		__udf_add_aext(inode, &nepos, &cp_loc, cp_len, 1);
1918		udf_write_aext(inode, epos, &nepos.block,
1919			       sb->s_blocksize | EXT_NEXT_EXTENT_ALLOCDECS, 0);
1920	} else {
1921		__udf_add_aext(inode, epos, &nepos.block,
1922			       sb->s_blocksize | EXT_NEXT_EXTENT_ALLOCDECS, 0);
1923	}
1924
1925	brelse(epos->bh);
1926	*epos = nepos;
1927
1928	return 0;
1929}
1930
1931/*
1932 * Append extent at the given position - should be the first free one in inode
1933 * / indirect extent. This function assumes there is enough space in the inode
1934 * or indirect extent. Use udf_add_aext() if you didn't check for this before.
1935 */
1936int __udf_add_aext(struct inode *inode, struct extent_position *epos,
1937		   struct kernel_lb_addr *eloc, uint32_t elen, int inc)
1938{
1939	struct udf_inode_info *iinfo = UDF_I(inode);
1940	struct allocExtDesc *aed;
1941	int adsize;
1942
1943	if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
1944		adsize = sizeof(struct short_ad);
1945	else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
1946		adsize = sizeof(struct long_ad);
1947	else
1948		return -EIO;
1949
1950	if (!epos->bh) {
1951		WARN_ON(iinfo->i_lenAlloc !=
1952			epos->offset - udf_file_entry_alloc_offset(inode));
1953	} else {
1954		aed = (struct allocExtDesc *)epos->bh->b_data;
1955		WARN_ON(le32_to_cpu(aed->lengthAllocDescs) !=
1956			epos->offset - sizeof(struct allocExtDesc));
1957		WARN_ON(epos->offset + adsize > inode->i_sb->s_blocksize);
1958	}
1959
1960	udf_write_aext(inode, epos, eloc, elen, inc);
1961
1962	if (!epos->bh) {
1963		iinfo->i_lenAlloc += adsize;
1964		mark_inode_dirty(inode);
1965	} else {
1966		aed = (struct allocExtDesc *)epos->bh->b_data;
1967		le32_add_cpu(&aed->lengthAllocDescs, adsize);
1968		if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) ||
1969				UDF_SB(inode->i_sb)->s_udfrev >= 0x0201)
1970			udf_update_tag(epos->bh->b_data,
1971					epos->offset + (inc ? 0 : adsize));
1972		else
1973			udf_update_tag(epos->bh->b_data,
1974					sizeof(struct allocExtDesc));
1975		mark_buffer_dirty_inode(epos->bh, inode);
1976	}
1977
1978	return 0;
1979}
1980
1981/*
1982 * Append extent at given position - should be the first free one in inode
1983 * / indirect extent. Takes care of allocating and linking indirect blocks.
1984 */
1985int udf_add_aext(struct inode *inode, struct extent_position *epos,
1986		 struct kernel_lb_addr *eloc, uint32_t elen, int inc)
1987{
1988	int adsize;
1989	struct super_block *sb = inode->i_sb;
1990
1991	if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
1992		adsize = sizeof(struct short_ad);
1993	else if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_LONG)
1994		adsize = sizeof(struct long_ad);
1995	else
1996		return -EIO;
1997
1998	if (epos->offset + (2 * adsize) > sb->s_blocksize) {
1999		int err;
2000		udf_pblk_t new_block;
2001
2002		new_block = udf_new_block(sb, NULL,
2003					  epos->block.partitionReferenceNum,
2004					  epos->block.logicalBlockNum, &err);
2005		if (!new_block)
2006			return -ENOSPC;
2007
2008		err = udf_setup_indirect_aext(inode, new_block, epos);
2009		if (err)
2010			return err;
2011	}
2012
2013	return __udf_add_aext(inode, epos, eloc, elen, inc);
2014}
2015
2016void udf_write_aext(struct inode *inode, struct extent_position *epos,
2017		    struct kernel_lb_addr *eloc, uint32_t elen, int inc)
2018{
2019	int adsize;
2020	uint8_t *ptr;
2021	struct short_ad *sad;
2022	struct long_ad *lad;
2023	struct udf_inode_info *iinfo = UDF_I(inode);
2024
2025	if (!epos->bh)
2026		ptr = iinfo->i_ext.i_data + epos->offset -
2027			udf_file_entry_alloc_offset(inode) +
2028			iinfo->i_lenEAttr;
2029	else
2030		ptr = epos->bh->b_data + epos->offset;
2031
2032	switch (iinfo->i_alloc_type) {
2033	case ICBTAG_FLAG_AD_SHORT:
2034		sad = (struct short_ad *)ptr;
2035		sad->extLength = cpu_to_le32(elen);
2036		sad->extPosition = cpu_to_le32(eloc->logicalBlockNum);
2037		adsize = sizeof(struct short_ad);
2038		break;
2039	case ICBTAG_FLAG_AD_LONG:
2040		lad = (struct long_ad *)ptr;
2041		lad->extLength = cpu_to_le32(elen);
2042		lad->extLocation = cpu_to_lelb(*eloc);
2043		memset(lad->impUse, 0x00, sizeof(lad->impUse));
2044		adsize = sizeof(struct long_ad);
2045		break;
2046	default:
2047		return;
2048	}
2049
2050	if (epos->bh) {
2051		if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) ||
2052		    UDF_SB(inode->i_sb)->s_udfrev >= 0x0201) {
2053			struct allocExtDesc *aed =
2054				(struct allocExtDesc *)epos->bh->b_data;
2055			udf_update_tag(epos->bh->b_data,
2056				       le32_to_cpu(aed->lengthAllocDescs) +
2057				       sizeof(struct allocExtDesc));
2058		}
2059		mark_buffer_dirty_inode(epos->bh, inode);
2060	} else {
2061		mark_inode_dirty(inode);
2062	}
2063
2064	if (inc)
2065		epos->offset += adsize;
2066}
2067
2068/*
2069 * Only 1 indirect extent in a row really makes sense but allow upto 16 in case
2070 * someone does some weird stuff.
2071 */
2072#define UDF_MAX_INDIR_EXTS 16
2073
2074int8_t udf_next_aext(struct inode *inode, struct extent_position *epos,
2075		     struct kernel_lb_addr *eloc, uint32_t *elen, int inc)
2076{
2077	int8_t etype;
2078	unsigned int indirections = 0;
2079
2080	while ((etype = udf_current_aext(inode, epos, eloc, elen, inc)) ==
2081	       (EXT_NEXT_EXTENT_ALLOCDECS >> 30)) {
2082		udf_pblk_t block;
2083
2084		if (++indirections > UDF_MAX_INDIR_EXTS) {
2085			udf_err(inode->i_sb,
2086				"too many indirect extents in inode %lu\n",
2087				inode->i_ino);
2088			return -1;
2089		}
2090
2091		epos->block = *eloc;
2092		epos->offset = sizeof(struct allocExtDesc);
2093		brelse(epos->bh);
2094		block = udf_get_lb_pblock(inode->i_sb, &epos->block, 0);
2095		epos->bh = udf_tread(inode->i_sb, block);
2096		if (!epos->bh) {
2097			udf_debug("reading block %u failed!\n", block);
2098			return -1;
2099		}
2100	}
2101
2102	return etype;
2103}
2104
2105int8_t udf_current_aext(struct inode *inode, struct extent_position *epos,
2106			struct kernel_lb_addr *eloc, uint32_t *elen, int inc)
2107{
2108	int alen;
2109	int8_t etype;
2110	uint8_t *ptr;
2111	struct short_ad *sad;
2112	struct long_ad *lad;
2113	struct udf_inode_info *iinfo = UDF_I(inode);
2114
2115	if (!epos->bh) {
2116		if (!epos->offset)
2117			epos->offset = udf_file_entry_alloc_offset(inode);
2118		ptr = iinfo->i_ext.i_data + epos->offset -
2119			udf_file_entry_alloc_offset(inode) +
2120			iinfo->i_lenEAttr;
2121		alen = udf_file_entry_alloc_offset(inode) +
2122							iinfo->i_lenAlloc;
2123	} else {
2124		if (!epos->offset)
2125			epos->offset = sizeof(struct allocExtDesc);
2126		ptr = epos->bh->b_data + epos->offset;
2127		alen = sizeof(struct allocExtDesc) +
2128			le32_to_cpu(((struct allocExtDesc *)epos->bh->b_data)->
2129							lengthAllocDescs);
2130	}
2131
2132	switch (iinfo->i_alloc_type) {
2133	case ICBTAG_FLAG_AD_SHORT:
2134		sad = udf_get_fileshortad(ptr, alen, &epos->offset, inc);
2135		if (!sad)
2136			return -1;
2137		etype = le32_to_cpu(sad->extLength) >> 30;
2138		eloc->logicalBlockNum = le32_to_cpu(sad->extPosition);
2139		eloc->partitionReferenceNum =
2140				iinfo->i_location.partitionReferenceNum;
2141		*elen = le32_to_cpu(sad->extLength) & UDF_EXTENT_LENGTH_MASK;
2142		break;
2143	case ICBTAG_FLAG_AD_LONG:
2144		lad = udf_get_filelongad(ptr, alen, &epos->offset, inc);
2145		if (!lad)
2146			return -1;
2147		etype = le32_to_cpu(lad->extLength) >> 30;
2148		*eloc = lelb_to_cpu(lad->extLocation);
2149		*elen = le32_to_cpu(lad->extLength) & UDF_EXTENT_LENGTH_MASK;
2150		break;
2151	default:
2152		udf_debug("alloc_type = %u unsupported\n", iinfo->i_alloc_type);
2153		return -1;
2154	}
2155
2156	return etype;
2157}
2158
2159static int8_t udf_insert_aext(struct inode *inode, struct extent_position epos,
2160			      struct kernel_lb_addr neloc, uint32_t nelen)
2161{
2162	struct kernel_lb_addr oeloc;
2163	uint32_t oelen;
2164	int8_t etype;
2165
2166	if (epos.bh)
2167		get_bh(epos.bh);
2168
2169	while ((etype = udf_next_aext(inode, &epos, &oeloc, &oelen, 0)) != -1) {
2170		udf_write_aext(inode, &epos, &neloc, nelen, 1);
2171		neloc = oeloc;
2172		nelen = (etype << 30) | oelen;
2173	}
2174	udf_add_aext(inode, &epos, &neloc, nelen, 1);
2175	brelse(epos.bh);
2176
2177	return (nelen >> 30);
2178}
2179
2180int8_t udf_delete_aext(struct inode *inode, struct extent_position epos,
2181		       struct kernel_lb_addr eloc, uint32_t elen)
2182{
2183	struct extent_position oepos;
2184	int adsize;
2185	int8_t etype;
2186	struct allocExtDesc *aed;
2187	struct udf_inode_info *iinfo;
2188
2189	if (epos.bh) {
2190		get_bh(epos.bh);
2191		get_bh(epos.bh);
2192	}
2193
2194	iinfo = UDF_I(inode);
2195	if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
2196		adsize = sizeof(struct short_ad);
2197	else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
2198		adsize = sizeof(struct long_ad);
2199	else
2200		adsize = 0;
2201
2202	oepos = epos;
2203	if (udf_next_aext(inode, &epos, &eloc, &elen, 1) == -1)
2204		return -1;
2205
2206	while ((etype = udf_next_aext(inode, &epos, &eloc, &elen, 1)) != -1) {
2207		udf_write_aext(inode, &oepos, &eloc, (etype << 30) | elen, 1);
2208		if (oepos.bh != epos.bh) {
2209			oepos.block = epos.block;
2210			brelse(oepos.bh);
2211			get_bh(epos.bh);
2212			oepos.bh = epos.bh;
2213			oepos.offset = epos.offset - adsize;
2214		}
2215	}
2216	memset(&eloc, 0x00, sizeof(struct kernel_lb_addr));
2217	elen = 0;
2218
2219	if (epos.bh != oepos.bh) {
2220		udf_free_blocks(inode->i_sb, inode, &epos.block, 0, 1);
2221		udf_write_aext(inode, &oepos, &eloc, elen, 1);
2222		udf_write_aext(inode, &oepos, &eloc, elen, 1);
2223		if (!oepos.bh) {
2224			iinfo->i_lenAlloc -= (adsize * 2);
2225			mark_inode_dirty(inode);
2226		} else {
2227			aed = (struct allocExtDesc *)oepos.bh->b_data;
2228			le32_add_cpu(&aed->lengthAllocDescs, -(2 * adsize));
2229			if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) ||
2230			    UDF_SB(inode->i_sb)->s_udfrev >= 0x0201)
2231				udf_update_tag(oepos.bh->b_data,
2232						oepos.offset - (2 * adsize));
2233			else
2234				udf_update_tag(oepos.bh->b_data,
2235						sizeof(struct allocExtDesc));
2236			mark_buffer_dirty_inode(oepos.bh, inode);
2237		}
2238	} else {
2239		udf_write_aext(inode, &oepos, &eloc, elen, 1);
2240		if (!oepos.bh) {
2241			iinfo->i_lenAlloc -= adsize;
2242			mark_inode_dirty(inode);
2243		} else {
2244			aed = (struct allocExtDesc *)oepos.bh->b_data;
2245			le32_add_cpu(&aed->lengthAllocDescs, -adsize);
2246			if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) ||
2247			    UDF_SB(inode->i_sb)->s_udfrev >= 0x0201)
2248				udf_update_tag(oepos.bh->b_data,
2249						epos.offset - adsize);
2250			else
2251				udf_update_tag(oepos.bh->b_data,
2252						sizeof(struct allocExtDesc));
2253			mark_buffer_dirty_inode(oepos.bh, inode);
2254		}
2255	}
2256
2257	brelse(epos.bh);
2258	brelse(oepos.bh);
2259
2260	return (elen >> 30);
2261}
2262
2263int8_t inode_bmap(struct inode *inode, sector_t block,
2264		  struct extent_position *pos, struct kernel_lb_addr *eloc,
2265		  uint32_t *elen, sector_t *offset)
2266{
2267	unsigned char blocksize_bits = inode->i_sb->s_blocksize_bits;
2268	loff_t lbcount = 0, bcount = (loff_t) block << blocksize_bits;
 
2269	int8_t etype;
2270	struct udf_inode_info *iinfo;
2271
2272	iinfo = UDF_I(inode);
2273	if (!udf_read_extent_cache(inode, bcount, &lbcount, pos)) {
2274		pos->offset = 0;
2275		pos->block = iinfo->i_location;
2276		pos->bh = NULL;
2277	}
2278	*elen = 0;
2279	do {
2280		etype = udf_next_aext(inode, pos, eloc, elen, 1);
2281		if (etype == -1) {
2282			*offset = (bcount - lbcount) >> blocksize_bits;
2283			iinfo->i_lenExtents = lbcount;
2284			return -1;
2285		}
2286		lbcount += *elen;
2287	} while (lbcount <= bcount);
2288	/* update extent cache */
2289	udf_update_extent_cache(inode, lbcount - *elen, pos);
2290	*offset = (bcount + *elen - lbcount) >> blocksize_bits;
2291
2292	return etype;
2293}
2294
2295udf_pblk_t udf_block_map(struct inode *inode, sector_t block)
2296{
2297	struct kernel_lb_addr eloc;
2298	uint32_t elen;
2299	sector_t offset;
2300	struct extent_position epos = {};
2301	udf_pblk_t ret;
2302
2303	down_read(&UDF_I(inode)->i_data_sem);
2304
2305	if (inode_bmap(inode, block, &epos, &eloc, &elen, &offset) ==
2306						(EXT_RECORDED_ALLOCATED >> 30))
2307		ret = udf_get_lb_pblock(inode->i_sb, &eloc, offset);
2308	else
2309		ret = 0;
2310
2311	up_read(&UDF_I(inode)->i_data_sem);
2312	brelse(epos.bh);
2313
2314	if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_VARCONV))
2315		return udf_fixed_to_variable(ret);
2316	else
2317		return ret;
2318}