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