inode.c 59.3 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
/*
 * inode.c
 *
 * PURPOSE
 *  Inode handling routines for the OSTA-UDF(tm) filesystem.
 *
 * COPYRIGHT
 *  This file is distributed under the terms of the GNU General Public
 *  License (GPL). Copies of the GPL can be obtained from:
 *    ftp://prep.ai.mit.edu/pub/gnu/GPL
 *  Each contributing author retains all rights to their own work.
 *
 *  (C) 1998 Dave Boynton
 *  (C) 1998-2004 Ben Fennema
 *  (C) 1999-2000 Stelias Computing Inc
 *
 * HISTORY
 *
 *  10/04/98 dgb  Added rudimentary directory functions
 *  10/07/98      Fully working udf_block_map! It works!
 *  11/25/98      bmap altered to better support extents
M
Marcin Slusarz 已提交
22 23
 *  12/06/98 blf  partition support in udf_iget, udf_block_map
 *                and udf_read_inode
L
Linus Torvalds 已提交
24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52
 *  12/12/98      rewrote udf_block_map to handle next extents and descs across
 *                block boundaries (which is not actually allowed)
 *  12/20/98      added support for strategy 4096
 *  03/07/99      rewrote udf_block_map (again)
 *                New funcs, inode_bmap, udf_next_aext
 *  04/19/99      Support for writing device EA's for major/minor #
 */

#include "udfdecl.h"
#include <linux/mm.h>
#include <linux/smp_lock.h>
#include <linux/module.h>
#include <linux/pagemap.h>
#include <linux/buffer_head.h>
#include <linux/writeback.h>
#include <linux/slab.h>

#include "udf_i.h"
#include "udf_sb.h"

MODULE_AUTHOR("Ben Fennema");
MODULE_DESCRIPTION("Universal Disk Format Filesystem");
MODULE_LICENSE("GPL");

#define EXTENT_MERGE_SIZE 5

static mode_t udf_convert_permissions(struct fileEntry *);
static int udf_update_inode(struct inode *, int);
static void udf_fill_inode(struct inode *, struct buffer_head *);
53
static int udf_alloc_i_data(struct inode *inode, size_t size);
54
static struct buffer_head *inode_getblk(struct inode *, sector_t, int *,
55
					sector_t *, int *);
J
Jan Kara 已提交
56
static int8_t udf_insert_aext(struct inode *, struct extent_position,
57
			      kernel_lb_addr, uint32_t);
L
Linus Torvalds 已提交
58
static void udf_split_extents(struct inode *, int *, int, int,
59
			      kernel_long_ad[EXTENT_MERGE_SIZE], int *);
L
Linus Torvalds 已提交
60
static void udf_prealloc_extents(struct inode *, int, int,
61
				 kernel_long_ad[EXTENT_MERGE_SIZE], int *);
L
Linus Torvalds 已提交
62
static void udf_merge_extents(struct inode *,
63
			      kernel_long_ad[EXTENT_MERGE_SIZE], int *);
L
Linus Torvalds 已提交
64
static void udf_update_extents(struct inode *,
65 66
			       kernel_long_ad[EXTENT_MERGE_SIZE], int, int,
			       struct extent_position *);
L
Linus Torvalds 已提交
67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84
static int udf_get_block(struct inode *, sector_t, struct buffer_head *, int);

/*
 * udf_delete_inode
 *
 * PURPOSE
 *	Clean-up before the specified inode is destroyed.
 *
 * DESCRIPTION
 *	This routine is called when the kernel destroys an inode structure
 *	ie. when iput() finds i_count == 0.
 *
 * HISTORY
 *	July 1, 1997 - Andrew E. Mileski
 *	Written, tested, and released.
 *
 *  Called at the last iput() if i_nlink is zero.
 */
85
void udf_delete_inode(struct inode *inode)
L
Linus Torvalds 已提交
86
{
87 88
	truncate_inode_pages(&inode->i_data, 0);

L
Linus Torvalds 已提交
89 90 91 92 93 94 95 96 97 98 99 100
	if (is_bad_inode(inode))
		goto no_delete;

	inode->i_size = 0;
	udf_truncate(inode);
	lock_kernel();

	udf_update_inode(inode, IS_SYNC(inode));
	udf_free_inode(inode);

	unlock_kernel();
	return;
101 102

no_delete:
L
Linus Torvalds 已提交
103 104 105
	clear_inode(inode);
}

J
Jan Kara 已提交
106 107 108 109 110 111 112
/*
 * If we are going to release inode from memory, we discard preallocation and
 * truncate last inode extent to proper length. We could use drop_inode() but
 * it's called under inode_lock and thus we cannot mark inode dirty there.  We
 * use clear_inode() but we have to make sure to write inode as it's not written
 * automatically.
 */
L
Linus Torvalds 已提交
113 114
void udf_clear_inode(struct inode *inode)
{
115
	struct udf_inode_info *iinfo;
L
Linus Torvalds 已提交
116 117
	if (!(inode->i_sb->s_flags & MS_RDONLY)) {
		lock_kernel();
J
Jan Kara 已提交
118
		/* Discard preallocation for directories, symlinks, etc. */
L
Linus Torvalds 已提交
119
		udf_discard_prealloc(inode);
J
Jan Kara 已提交
120
		udf_truncate_tail_extent(inode);
L
Linus Torvalds 已提交
121
		unlock_kernel();
122
		write_inode_now(inode, 0);
L
Linus Torvalds 已提交
123
	}
124 125 126
	iinfo = UDF_I(inode);
	kfree(iinfo->i_ext.i_data);
	iinfo->i_ext.i_data = NULL;
L
Linus Torvalds 已提交
127 128 129 130 131 132 133 134 135 136 137 138
}

static int udf_writepage(struct page *page, struct writeback_control *wbc)
{
	return block_write_full_page(page, udf_get_block, wbc);
}

static int udf_readpage(struct file *file, struct page *page)
{
	return block_read_full_page(page, udf_get_block);
}

N
Nick Piggin 已提交
139 140 141
static int udf_write_begin(struct file *file, struct address_space *mapping,
			loff_t pos, unsigned len, unsigned flags,
			struct page **pagep, void **fsdata)
L
Linus Torvalds 已提交
142
{
N
Nick Piggin 已提交
143 144 145
	*pagep = NULL;
	return block_write_begin(file, mapping, pos, len, flags, pagep, fsdata,
				udf_get_block);
L
Linus Torvalds 已提交
146 147 148 149
}

static sector_t udf_bmap(struct address_space *mapping, sector_t block)
{
150
	return generic_block_bmap(mapping, block, udf_get_block);
L
Linus Torvalds 已提交
151 152
}

153
const struct address_space_operations udf_aops = {
154 155 156
	.readpage	= udf_readpage,
	.writepage	= udf_writepage,
	.sync_page	= block_sync_page,
N
Nick Piggin 已提交
157 158
	.write_begin		= udf_write_begin,
	.write_end		= generic_write_end,
159
	.bmap		= udf_bmap,
L
Linus Torvalds 已提交
160 161
};

162
void udf_expand_file_adinicb(struct inode *inode, int newsize, int *err)
L
Linus Torvalds 已提交
163 164 165
{
	struct page *page;
	char *kaddr;
166
	struct udf_inode_info *iinfo = UDF_I(inode);
L
Linus Torvalds 已提交
167 168 169 170 171 172 173 174
	struct writeback_control udf_wbc = {
		.sync_mode = WB_SYNC_NONE,
		.nr_to_write = 1,
	};

	/* from now on we have normal address_space methods */
	inode->i_data.a_ops = &udf_aops;

175
	if (!iinfo->i_lenAlloc) {
L
Linus Torvalds 已提交
176
		if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_SHORT_AD))
177
			iinfo->i_alloc_type = ICBTAG_FLAG_AD_SHORT;
L
Linus Torvalds 已提交
178
		else
179
			iinfo->i_alloc_type = ICBTAG_FLAG_AD_LONG;
L
Linus Torvalds 已提交
180 181 182 183 184
		mark_inode_dirty(inode);
		return;
	}

	page = grab_cache_page(inode->i_mapping, 0);
M
Matt Mackall 已提交
185 186
	BUG_ON(!PageLocked(page));

187
	if (!PageUptodate(page)) {
L
Linus Torvalds 已提交
188
		kaddr = kmap(page);
189 190 191 192
		memset(kaddr + iinfo->i_lenAlloc, 0x00,
		       PAGE_CACHE_SIZE - iinfo->i_lenAlloc);
		memcpy(kaddr, iinfo->i_ext.i_data + iinfo->i_lenEAttr,
			iinfo->i_lenAlloc);
L
Linus Torvalds 已提交
193 194 195 196
		flush_dcache_page(page);
		SetPageUptodate(page);
		kunmap(page);
	}
197 198 199
	memset(iinfo->i_ext.i_data + iinfo->i_lenEAttr, 0x00,
	       iinfo->i_lenAlloc);
	iinfo->i_lenAlloc = 0;
L
Linus Torvalds 已提交
200
	if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_SHORT_AD))
201
		iinfo->i_alloc_type = ICBTAG_FLAG_AD_SHORT;
L
Linus Torvalds 已提交
202
	else
203
		iinfo->i_alloc_type = ICBTAG_FLAG_AD_LONG;
L
Linus Torvalds 已提交
204 205 206 207 208 209 210

	inode->i_data.a_ops->writepage(page, &udf_wbc);
	page_cache_release(page);

	mark_inode_dirty(inode);
}

211 212
struct buffer_head *udf_expand_dir_adinicb(struct inode *inode, int *block,
					   int *err)
L
Linus Torvalds 已提交
213 214
{
	int newblock;
J
Jan Kara 已提交
215 216 217
	struct buffer_head *dbh = NULL;
	kernel_lb_addr eloc;
	uint32_t elen;
L
Linus Torvalds 已提交
218
	uint8_t alloctype;
J
Jan Kara 已提交
219
	struct extent_position epos;
L
Linus Torvalds 已提交
220 221

	struct udf_fileident_bh sfibh, dfibh;
222 223
	loff_t f_pos = udf_ext0_offset(inode);
	int size = udf_ext0_offset(inode) + inode->i_size;
L
Linus Torvalds 已提交
224
	struct fileIdentDesc cfi, *sfi, *dfi;
225
	struct udf_inode_info *iinfo = UDF_I(inode);
L
Linus Torvalds 已提交
226 227 228 229 230 231

	if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_SHORT_AD))
		alloctype = ICBTAG_FLAG_AD_SHORT;
	else
		alloctype = ICBTAG_FLAG_AD_LONG;

232
	if (!inode->i_size) {
233
		iinfo->i_alloc_type = alloctype;
L
Linus Torvalds 已提交
234 235 236 237 238 239
		mark_inode_dirty(inode);
		return NULL;
	}

	/* alloc block, and copy data to it */
	*block = udf_new_block(inode->i_sb, inode,
240 241
			       iinfo->i_location.partitionReferenceNum,
			       iinfo->i_location.logicalBlockNum, err);
L
Linus Torvalds 已提交
242 243 244
	if (!(*block))
		return NULL;
	newblock = udf_get_pblock(inode->i_sb, *block,
245
				  iinfo->i_location.partitionReferenceNum,
246
				0);
L
Linus Torvalds 已提交
247 248 249 250 251 252 253 254 255 256 257
	if (!newblock)
		return NULL;
	dbh = udf_tgetblk(inode->i_sb, newblock);
	if (!dbh)
		return NULL;
	lock_buffer(dbh);
	memset(dbh->b_data, 0x00, inode->i_sb->s_blocksize);
	set_buffer_uptodate(dbh);
	unlock_buffer(dbh);
	mark_buffer_dirty_inode(dbh, inode);

M
Marcin Slusarz 已提交
258
	sfibh.soffset = sfibh.eoffset =
259
			f_pos & (inode->i_sb->s_blocksize - 1);
J
Jan Kara 已提交
260
	sfibh.sbh = sfibh.ebh = NULL;
L
Linus Torvalds 已提交
261 262
	dfibh.soffset = dfibh.eoffset = 0;
	dfibh.sbh = dfibh.ebh = dbh;
263
	while (f_pos < size) {
264
		iinfo->i_alloc_type = ICBTAG_FLAG_AD_IN_ICB;
M
Marcin Slusarz 已提交
265 266
		sfi = udf_fileident_read(inode, &f_pos, &sfibh, &cfi, NULL,
					 NULL, NULL, NULL);
267
		if (!sfi) {
J
Jan Kara 已提交
268
			brelse(dbh);
L
Linus Torvalds 已提交
269 270
			return NULL;
		}
271
		iinfo->i_alloc_type = alloctype;
L
Linus Torvalds 已提交
272 273 274 275 276
		sfi->descTag.tagLocation = cpu_to_le32(*block);
		dfibh.soffset = dfibh.eoffset;
		dfibh.eoffset += (sfibh.eoffset - sfibh.soffset);
		dfi = (struct fileIdentDesc *)(dbh->b_data + dfibh.soffset);
		if (udf_write_fi(inode, sfi, dfi, &dfibh, sfi->impUse,
M
Marcin Slusarz 已提交
277 278
				 sfi->fileIdent +
					le16_to_cpu(sfi->lengthOfImpUse))) {
279
			iinfo->i_alloc_type = ICBTAG_FLAG_AD_IN_ICB;
J
Jan Kara 已提交
280
			brelse(dbh);
L
Linus Torvalds 已提交
281 282 283 284 285
			return NULL;
		}
	}
	mark_buffer_dirty_inode(dbh, inode);

286 287 288
	memset(iinfo->i_ext.i_data + iinfo->i_lenEAttr, 0,
		iinfo->i_lenAlloc);
	iinfo->i_lenAlloc = 0;
L
Linus Torvalds 已提交
289
	eloc.logicalBlockNum = *block;
M
Marcin Slusarz 已提交
290
	eloc.partitionReferenceNum =
291
				iinfo->i_location.partitionReferenceNum;
J
Jan Kara 已提交
292
	elen = inode->i_sb->s_blocksize;
293
	iinfo->i_lenExtents = elen;
J
Jan Kara 已提交
294
	epos.bh = NULL;
295
	epos.block = iinfo->i_location;
J
Jan Kara 已提交
296 297
	epos.offset = udf_file_entry_alloc_offset(inode);
	udf_add_aext(inode, &epos, eloc, elen, 0);
L
Linus Torvalds 已提交
298 299
	/* UniqueID stuff */

J
Jan Kara 已提交
300
	brelse(epos.bh);
L
Linus Torvalds 已提交
301 302 303 304
	mark_inode_dirty(inode);
	return dbh;
}

305 306
static int udf_get_block(struct inode *inode, sector_t block,
			 struct buffer_head *bh_result, int create)
L
Linus Torvalds 已提交
307 308 309
{
	int err, new;
	struct buffer_head *bh;
310
	sector_t phys = 0;
311
	struct udf_inode_info *iinfo;
L
Linus Torvalds 已提交
312

313
	if (!create) {
L
Linus Torvalds 已提交
314 315 316 317 318 319 320 321 322 323 324 325 326 327 328
		phys = udf_block_map(inode, block);
		if (phys)
			map_bh(bh_result, inode->i_sb, phys);
		return 0;
	}

	err = -EIO;
	new = 0;
	bh = NULL;

	lock_kernel();

	if (block < 0)
		goto abort_negative;

329 330 331 332
	iinfo = UDF_I(inode);
	if (block == iinfo->i_next_alloc_block + 1) {
		iinfo->i_next_alloc_block++;
		iinfo->i_next_alloc_goal++;
L
Linus Torvalds 已提交
333 334 335 336 337
	}

	err = 0;

	bh = inode_getblk(inode, block, &err, &phys, &new);
E
Eric Sesterhenn 已提交
338
	BUG_ON(bh);
L
Linus Torvalds 已提交
339 340
	if (err)
		goto abort;
E
Eric Sesterhenn 已提交
341
	BUG_ON(!phys);
L
Linus Torvalds 已提交
342 343 344 345

	if (new)
		set_buffer_new(bh_result);
	map_bh(bh_result, inode->i_sb, phys);
346 347

abort:
L
Linus Torvalds 已提交
348 349 350
	unlock_kernel();
	return err;

351
abort_negative:
L
Linus Torvalds 已提交
352 353 354 355
	udf_warning(inode->i_sb, "udf_get_block", "block < 0");
	goto abort;
}

356 357
static struct buffer_head *udf_getblk(struct inode *inode, long block,
				      int create, int *err)
L
Linus Torvalds 已提交
358
{
359
	struct buffer_head *bh;
L
Linus Torvalds 已提交
360 361 362 363 364
	struct buffer_head dummy;

	dummy.b_state = 0;
	dummy.b_blocknr = -1000;
	*err = udf_get_block(inode, block, &dummy, create);
365
	if (!*err && buffer_mapped(&dummy)) {
L
Linus Torvalds 已提交
366
		bh = sb_getblk(inode->i_sb, dummy.b_blocknr);
367
		if (buffer_new(&dummy)) {
L
Linus Torvalds 已提交
368 369 370 371 372 373 374 375
			lock_buffer(bh);
			memset(bh->b_data, 0x00, inode->i_sb->s_blocksize);
			set_buffer_uptodate(bh);
			unlock_buffer(bh);
			mark_buffer_dirty_inode(bh, inode);
		}
		return bh;
	}
376

L
Linus Torvalds 已提交
377 378 379
	return NULL;
}

J
Jan Kara 已提交
380 381
/* Extend the file by 'blocks' blocks, return the number of extents added */
int udf_extend_file(struct inode *inode, struct extent_position *last_pos,
M
Marcin Slusarz 已提交
382
		    kernel_long_ad *last_ext, sector_t blocks)
J
Jan Kara 已提交
383 384 385 386
{
	sector_t add;
	int count = 0, fake = !(last_ext->extLength & UDF_EXTENT_LENGTH_MASK);
	struct super_block *sb = inode->i_sb;
387
	kernel_lb_addr prealloc_loc = {};
J
Jan Kara 已提交
388
	int prealloc_len = 0;
389
	struct udf_inode_info *iinfo;
J
Jan Kara 已提交
390 391 392 393 394

	/* The previous extent is fake and we should not extend by anything
	 * - there's nothing to do... */
	if (!blocks && fake)
		return 0;
395

396
	iinfo = UDF_I(inode);
J
Jan Kara 已提交
397 398 399
	/* Round the last extent up to a multiple of block size */
	if (last_ext->extLength & (sb->s_blocksize - 1)) {
		last_ext->extLength =
400 401 402
			(last_ext->extLength & UDF_EXTENT_FLAG_MASK) |
			(((last_ext->extLength & UDF_EXTENT_LENGTH_MASK) +
			  sb->s_blocksize - 1) & ~(sb->s_blocksize - 1));
403 404
		iinfo->i_lenExtents =
			(iinfo->i_lenExtents + sb->s_blocksize - 1) &
405
			~(sb->s_blocksize - 1);
J
Jan Kara 已提交
406
	}
407

J
Jan Kara 已提交
408
	/* Last extent are just preallocated blocks? */
M
Marcin Slusarz 已提交
409 410
	if ((last_ext->extLength & UDF_EXTENT_FLAG_MASK) ==
						EXT_NOT_RECORDED_ALLOCATED) {
J
Jan Kara 已提交
411 412 413 414 415
		/* Save the extent so that we can reattach it to the end */
		prealloc_loc = last_ext->extLocation;
		prealloc_len = last_ext->extLength;
		/* Mark the extent as a hole */
		last_ext->extLength = EXT_NOT_RECORDED_NOT_ALLOCATED |
416
			(last_ext->extLength & UDF_EXTENT_LENGTH_MASK);
J
Jan Kara 已提交
417
		last_ext->extLocation.logicalBlockNum = 0;
M
Marcin Slusarz 已提交
418
		last_ext->extLocation.partitionReferenceNum = 0;
J
Jan Kara 已提交
419
	}
420

J
Jan Kara 已提交
421
	/* Can we merge with the previous extent? */
M
Marcin Slusarz 已提交
422 423 424 425 426
	if ((last_ext->extLength & UDF_EXTENT_FLAG_MASK) ==
					EXT_NOT_RECORDED_NOT_ALLOCATED) {
		add = ((1 << 30) - sb->s_blocksize -
			(last_ext->extLength & UDF_EXTENT_LENGTH_MASK)) >>
			sb->s_blocksize_bits;
J
Jan Kara 已提交
427 428 429 430 431 432 433 434
		if (add > blocks)
			add = blocks;
		blocks -= add;
		last_ext->extLength += add << sb->s_blocksize_bits;
	}

	if (fake) {
		udf_add_aext(inode, last_pos, last_ext->extLocation,
435
			     last_ext->extLength, 1);
J
Jan Kara 已提交
436
		count++;
M
Marcin Slusarz 已提交
437 438 439
	} else
		udf_write_aext(inode, last_pos, last_ext->extLocation,
				last_ext->extLength, 1);
440

J
Jan Kara 已提交
441 442 443 444 445 446
	/* Managed to do everything necessary? */
	if (!blocks)
		goto out;

	/* All further extents will be NOT_RECORDED_NOT_ALLOCATED */
	last_ext->extLocation.logicalBlockNum = 0;
M
Marcin Slusarz 已提交
447
	last_ext->extLocation.partitionReferenceNum = 0;
448
	add = (1 << (30-sb->s_blocksize_bits)) - 1;
M
Marcin Slusarz 已提交
449 450
	last_ext->extLength = EXT_NOT_RECORDED_NOT_ALLOCATED |
				(add << sb->s_blocksize_bits);
451

J
Jan Kara 已提交
452 453 454 455
	/* Create enough extents to cover the whole hole */
	while (blocks > add) {
		blocks -= add;
		if (udf_add_aext(inode, last_pos, last_ext->extLocation,
456
				 last_ext->extLength, 1) == -1)
J
Jan Kara 已提交
457 458 459 460 461
			return -1;
		count++;
	}
	if (blocks) {
		last_ext->extLength = EXT_NOT_RECORDED_NOT_ALLOCATED |
462
			(blocks << sb->s_blocksize_bits);
J
Jan Kara 已提交
463
		if (udf_add_aext(inode, last_pos, last_ext->extLocation,
464
				 last_ext->extLength, 1) == -1)
J
Jan Kara 已提交
465 466 467
			return -1;
		count++;
	}
468 469

out:
J
Jan Kara 已提交
470 471
	/* Do we have some preallocated blocks saved? */
	if (prealloc_len) {
M
Marcin Slusarz 已提交
472 473
		if (udf_add_aext(inode, last_pos, prealloc_loc,
				 prealloc_len, 1) == -1)
J
Jan Kara 已提交
474 475 476 477 478
			return -1;
		last_ext->extLocation = prealloc_loc;
		last_ext->extLength = prealloc_len;
		count++;
	}
479

J
Jan Kara 已提交
480
	/* last_pos should point to the last written extent... */
481
	if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
J
Jan Kara 已提交
482
		last_pos->offset -= sizeof(short_ad);
483
	else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
J
Jan Kara 已提交
484 485 486
		last_pos->offset -= sizeof(long_ad);
	else
		return -1;
487

J
Jan Kara 已提交
488 489 490
	return count;
}

491
static struct buffer_head *inode_getblk(struct inode *inode, sector_t block,
492
					int *err, sector_t *phys, int *new)
L
Linus Torvalds 已提交
493
{
J
Jan Kara 已提交
494
	static sector_t last_block;
J
Jan Kara 已提交
495
	struct buffer_head *result = NULL;
L
Linus Torvalds 已提交
496
	kernel_long_ad laarr[EXTENT_MERGE_SIZE];
J
Jan Kara 已提交
497
	struct extent_position prev_epos, cur_epos, next_epos;
L
Linus Torvalds 已提交
498
	int count = 0, startnum = 0, endnum = 0;
J
Jan Kara 已提交
499 500
	uint32_t elen = 0, tmpelen;
	kernel_lb_addr eloc, tmpeloc;
L
Linus Torvalds 已提交
501
	int c = 1;
502 503 504
	loff_t lbcount = 0, b_off = 0;
	uint32_t newblocknum, newblock;
	sector_t offset = 0;
L
Linus Torvalds 已提交
505
	int8_t etype;
506 507
	struct udf_inode_info *iinfo = UDF_I(inode);
	int goal = 0, pgoal = iinfo->i_location.logicalBlockNum;
J
Jan Kara 已提交
508
	int lastblock = 0;
L
Linus Torvalds 已提交
509

J
Jan Kara 已提交
510
	prev_epos.offset = udf_file_entry_alloc_offset(inode);
511
	prev_epos.block = iinfo->i_location;
J
Jan Kara 已提交
512 513
	prev_epos.bh = NULL;
	cur_epos = next_epos = prev_epos;
514
	b_off = (loff_t)block << inode->i_sb->s_blocksize_bits;
L
Linus Torvalds 已提交
515 516

	/* find the extent which contains the block we are looking for.
517 518 519 520
	   alternate between laarr[0] and laarr[1] for locations of the
	   current extent, and the previous extent */
	do {
		if (prev_epos.bh != cur_epos.bh) {
J
Jan Kara 已提交
521 522
			brelse(prev_epos.bh);
			get_bh(cur_epos.bh);
J
Jan Kara 已提交
523
			prev_epos.bh = cur_epos.bh;
L
Linus Torvalds 已提交
524
		}
525
		if (cur_epos.bh != next_epos.bh) {
J
Jan Kara 已提交
526 527
			brelse(cur_epos.bh);
			get_bh(next_epos.bh);
J
Jan Kara 已提交
528
			cur_epos.bh = next_epos.bh;
L
Linus Torvalds 已提交
529 530 531 532
		}

		lbcount += elen;

J
Jan Kara 已提交
533 534
		prev_epos.block = cur_epos.block;
		cur_epos.block = next_epos.block;
L
Linus Torvalds 已提交
535

J
Jan Kara 已提交
536 537
		prev_epos.offset = cur_epos.offset;
		cur_epos.offset = next_epos.offset;
L
Linus Torvalds 已提交
538

M
Marcin Slusarz 已提交
539 540
		etype = udf_next_aext(inode, &next_epos, &eloc, &elen, 1);
		if (etype == -1)
L
Linus Torvalds 已提交
541 542 543 544 545 546 547 548 549
			break;

		c = !c;

		laarr[c].extLength = (etype << 30) | elen;
		laarr[c].extLocation = eloc;

		if (etype != (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30))
			pgoal = eloc.logicalBlockNum +
550 551
				((elen + inode->i_sb->s_blocksize - 1) >>
				 inode->i_sb->s_blocksize_bits);
L
Linus Torvalds 已提交
552

553
		count++;
L
Linus Torvalds 已提交
554 555 556 557
	} while (lbcount + elen <= b_off);

	b_off -= lbcount;
	offset = b_off >> inode->i_sb->s_blocksize_bits;
J
Jan Kara 已提交
558 559 560 561 562 563
	/*
	 * Move prev_epos and cur_epos into indirect extent if we are at
	 * the pointer to it
	 */
	udf_next_aext(inode, &prev_epos, &tmpeloc, &tmpelen, 0);
	udf_next_aext(inode, &cur_epos, &tmpeloc, &tmpelen, 0);
L
Linus Torvalds 已提交
564 565

	/* if the extent is allocated and recorded, return the block
566
	   if the extent is not a multiple of the blocksize, round up */
L
Linus Torvalds 已提交
567

568 569
	if (etype == (EXT_RECORDED_ALLOCATED >> 30)) {
		if (elen & (inode->i_sb->s_blocksize - 1)) {
L
Linus Torvalds 已提交
570
			elen = EXT_RECORDED_ALLOCATED |
571 572
				((elen + inode->i_sb->s_blocksize - 1) &
				 ~(inode->i_sb->s_blocksize - 1));
J
Jan Kara 已提交
573
			etype = udf_write_aext(inode, &cur_epos, eloc, elen, 1);
L
Linus Torvalds 已提交
574
		}
J
Jan Kara 已提交
575 576 577
		brelse(prev_epos.bh);
		brelse(cur_epos.bh);
		brelse(next_epos.bh);
L
Linus Torvalds 已提交
578 579 580 581 582
		newblock = udf_get_lb_pblock(inode->i_sb, eloc, offset);
		*phys = newblock;
		return NULL;
	}

J
Jan Kara 已提交
583 584
	last_block = block;
	/* Are we beyond EOF? */
585
	if (etype == -1) {
J
Jan Kara 已提交
586 587 588 589 590 591
		int ret;

		if (count) {
			if (c)
				laarr[0] = laarr[1];
			startnum = 1;
592
		} else {
J
Jan Kara 已提交
593
			/* Create a fake extent when there's not one */
M
Marcin Slusarz 已提交
594 595
			memset(&laarr[0].extLocation, 0x00,
				sizeof(kernel_lb_addr));
J
Jan Kara 已提交
596
			laarr[0].extLength = EXT_NOT_RECORDED_NOT_ALLOCATED;
M
Marcin Slusarz 已提交
597 598
			/* Will udf_extend_file() create real extent from
			   a fake one? */
J
Jan Kara 已提交
599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615
			startnum = (offset > 0);
		}
		/* Create extents for the hole between EOF and offset */
		ret = udf_extend_file(inode, &prev_epos, laarr, offset);
		if (ret == -1) {
			brelse(prev_epos.bh);
			brelse(cur_epos.bh);
			brelse(next_epos.bh);
			/* We don't really know the error here so we just make
			 * something up */
			*err = -ENOSPC;
			return NULL;
		}
		c = 0;
		offset = 0;
		count += ret;
		/* We are not covered by a preallocated extent? */
M
Marcin Slusarz 已提交
616 617
		if ((laarr[0].extLength & UDF_EXTENT_FLAG_MASK) !=
						EXT_NOT_RECORDED_ALLOCATED) {
J
Jan Kara 已提交
618 619 620 621 622
			/* Is there any real extent? - otherwise we overwrite
			 * the fake one... */
			if (count)
				c = !c;
			laarr[c].extLength = EXT_NOT_RECORDED_NOT_ALLOCATED |
623
				inode->i_sb->s_blocksize;
M
Marcin Slusarz 已提交
624 625
			memset(&laarr[c].extLocation, 0x00,
				sizeof(kernel_lb_addr));
626 627
			count++;
			endnum++;
J
Jan Kara 已提交
628
		}
629
		endnum = c + 1;
L
Linus Torvalds 已提交
630
		lastblock = 1;
631
	} else {
L
Linus Torvalds 已提交
632 633
		endnum = startnum = ((count > 2) ? 2 : count);

M
Marcin Slusarz 已提交
634 635
		/* if the current extent is in position 0,
		   swap it with the previous */
636
		if (!c && count != 1) {
J
Jan Kara 已提交
637 638 639 640 641
			laarr[2] = laarr[0];
			laarr[0] = laarr[1];
			laarr[1] = laarr[2];
			c = 1;
		}
L
Linus Torvalds 已提交
642

M
Marcin Slusarz 已提交
643 644 645 646
		/* if the current block is located in an extent,
		   read the next extent */
		etype = udf_next_aext(inode, &next_epos, &eloc, &elen, 0);
		if (etype != -1) {
647 648 649 650 651
			laarr[c + 1].extLength = (etype << 30) | elen;
			laarr[c + 1].extLocation = eloc;
			count++;
			startnum++;
			endnum++;
M
Marcin Slusarz 已提交
652
		} else
L
Linus Torvalds 已提交
653 654 655 656
			lastblock = 1;
	}

	/* if the current extent is not recorded but allocated, get the
657
	 * block in the extent corresponding to the requested block */
M
Marcin Slusarz 已提交
658
	if ((laarr[c].extLength >> 30) == (EXT_NOT_RECORDED_ALLOCATED >> 30))
L
Linus Torvalds 已提交
659
		newblocknum = laarr[c].extLocation.logicalBlockNum + offset;
M
Marcin Slusarz 已提交
660
	else { /* otherwise, allocate a new block */
661 662
		if (iinfo->i_next_alloc_block == block)
			goal = iinfo->i_next_alloc_goal;
L
Linus Torvalds 已提交
663

664
		if (!goal) {
M
Marcin Slusarz 已提交
665
			if (!(goal = pgoal)) /* XXX: what was intended here? */
666
				goal = iinfo->i_location.logicalBlockNum + 1;
L
Linus Torvalds 已提交
667 668
		}

M
Marcin Slusarz 已提交
669
		newblocknum = udf_new_block(inode->i_sb, inode,
670
				iinfo->i_location.partitionReferenceNum,
M
Marcin Slusarz 已提交
671 672
				goal, err);
		if (!newblocknum) {
J
Jan Kara 已提交
673
			brelse(prev_epos.bh);
L
Linus Torvalds 已提交
674 675 676
			*err = -ENOSPC;
			return NULL;
		}
677
		iinfo->i_lenExtents += inode->i_sb->s_blocksize;
L
Linus Torvalds 已提交
678 679
	}

M
Marcin Slusarz 已提交
680 681 682 683
	/* if the extent the requsted block is located in contains multiple
	 * blocks, split the extent into at most three extents. blocks prior
	 * to requested block, requested block, and blocks after requested
	 * block */
L
Linus Torvalds 已提交
684 685 686 687 688 689 690 691 692 693 694
	udf_split_extents(inode, &c, offset, newblocknum, laarr, &endnum);

#ifdef UDF_PREALLOCATE
	/* preallocate blocks */
	udf_prealloc_extents(inode, c, lastblock, laarr, &endnum);
#endif

	/* merge any continuous blocks in laarr */
	udf_merge_extents(inode, laarr, &endnum);

	/* write back the new extents, inserting new extents if the new number
695 696
	 * of extents is greater than the old number, and deleting extents if
	 * the new number of extents is less than the old number */
J
Jan Kara 已提交
697
	udf_update_extents(inode, laarr, startnum, endnum, &prev_epos);
L
Linus Torvalds 已提交
698

J
Jan Kara 已提交
699
	brelse(prev_epos.bh);
L
Linus Torvalds 已提交
700

M
Marcin Slusarz 已提交
701
	newblock = udf_get_pblock(inode->i_sb, newblocknum,
702
				iinfo->i_location.partitionReferenceNum, 0);
M
Marcin Slusarz 已提交
703
	if (!newblock)
L
Linus Torvalds 已提交
704 705 706 707
		return NULL;
	*phys = newblock;
	*err = 0;
	*new = 1;
708 709
	iinfo->i_next_alloc_block = block;
	iinfo->i_next_alloc_goal = newblocknum;
L
Linus Torvalds 已提交
710 711 712 713 714 715
	inode->i_ctime = current_fs_time(inode->i_sb);

	if (IS_SYNC(inode))
		udf_sync_inode(inode);
	else
		mark_inode_dirty(inode);
716

L
Linus Torvalds 已提交
717 718 719
	return result;
}

720 721 722 723
static void udf_split_extents(struct inode *inode, int *c, int offset,
			      int newblocknum,
			      kernel_long_ad laarr[EXTENT_MERGE_SIZE],
			      int *endnum)
L
Linus Torvalds 已提交
724
{
M
Marcin Slusarz 已提交
725 726 727
	unsigned long blocksize = inode->i_sb->s_blocksize;
	unsigned char blocksize_bits = inode->i_sb->s_blocksize_bits;

L
Linus Torvalds 已提交
728
	if ((laarr[*c].extLength >> 30) == (EXT_NOT_RECORDED_ALLOCATED >> 30) ||
M
Marcin Slusarz 已提交
729 730
	    (laarr[*c].extLength >> 30) ==
				(EXT_NOT_RECORDED_NOT_ALLOCATED >> 30)) {
L
Linus Torvalds 已提交
731 732
		int curr = *c;
		int blen = ((laarr[curr].extLength & UDF_EXTENT_LENGTH_MASK) +
M
Marcin Slusarz 已提交
733
			    blocksize - 1) >> blocksize_bits;
L
Linus Torvalds 已提交
734 735
		int8_t etype = (laarr[curr].extLength >> 30);

M
Marcin Slusarz 已提交
736
		if (blen == 1)
737
			;
M
Marcin Slusarz 已提交
738
		else if (!offset || blen == offset + 1) {
739 740 741 742 743 744 745 746 747
			laarr[curr + 2] = laarr[curr + 1];
			laarr[curr + 1] = laarr[curr];
		} else {
			laarr[curr + 3] = laarr[curr + 1];
			laarr[curr + 2] = laarr[curr + 1] = laarr[curr];
		}

		if (offset) {
			if (etype == (EXT_NOT_RECORDED_ALLOCATED >> 30)) {
M
Marcin Slusarz 已提交
748 749 750 751 752 753
				udf_free_blocks(inode->i_sb, inode,
						laarr[curr].extLocation,
						0, offset);
				laarr[curr].extLength =
					EXT_NOT_RECORDED_NOT_ALLOCATED |
					(offset << blocksize_bits);
L
Linus Torvalds 已提交
754
				laarr[curr].extLocation.logicalBlockNum = 0;
M
Marcin Slusarz 已提交
755 756 757
				laarr[curr].extLocation.
						partitionReferenceNum = 0;
			} else
L
Linus Torvalds 已提交
758
				laarr[curr].extLength = (etype << 30) |
M
Marcin Slusarz 已提交
759
					(offset << blocksize_bits);
760 761 762
			curr++;
			(*c)++;
			(*endnum)++;
L
Linus Torvalds 已提交
763
		}
764

L
Linus Torvalds 已提交
765 766 767
		laarr[curr].extLocation.logicalBlockNum = newblocknum;
		if (etype == (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30))
			laarr[curr].extLocation.partitionReferenceNum =
768
				UDF_I(inode)->i_location.partitionReferenceNum;
L
Linus Torvalds 已提交
769
		laarr[curr].extLength = EXT_RECORDED_ALLOCATED |
M
Marcin Slusarz 已提交
770
			blocksize;
771
		curr++;
L
Linus Torvalds 已提交
772

773
		if (blen != offset + 1) {
L
Linus Torvalds 已提交
774
			if (etype == (EXT_NOT_RECORDED_ALLOCATED >> 30))
M
Marcin Slusarz 已提交
775 776
				laarr[curr].extLocation.logicalBlockNum +=
								offset + 1;
777
			laarr[curr].extLength = (etype << 30) |
M
Marcin Slusarz 已提交
778
				((blen - (offset + 1)) << blocksize_bits);
779 780
			curr++;
			(*endnum)++;
L
Linus Torvalds 已提交
781 782 783 784 785
		}
	}
}

static void udf_prealloc_extents(struct inode *inode, int c, int lastblock,
786 787
				 kernel_long_ad laarr[EXTENT_MERGE_SIZE],
				 int *endnum)
L
Linus Torvalds 已提交
788 789 790
{
	int start, length = 0, currlength = 0, i;

791
	if (*endnum >= (c + 1)) {
L
Linus Torvalds 已提交
792 793 794 795
		if (!lastblock)
			return;
		else
			start = c;
796
	} else {
M
Marcin Slusarz 已提交
797 798
		if ((laarr[c + 1].extLength >> 30) ==
					(EXT_NOT_RECORDED_ALLOCATED >> 30)) {
799
			start = c + 1;
M
Marcin Slusarz 已提交
800 801 802 803 804 805
			length = currlength =
				(((laarr[c + 1].extLength &
					UDF_EXTENT_LENGTH_MASK) +
				inode->i_sb->s_blocksize - 1) >>
				inode->i_sb->s_blocksize_bits);
		} else
L
Linus Torvalds 已提交
806 807 808
			start = c;
	}

809 810
	for (i = start + 1; i <= *endnum; i++) {
		if (i == *endnum) {
L
Linus Torvalds 已提交
811 812
			if (lastblock)
				length += UDF_DEFAULT_PREALLOC_BLOCKS;
M
Marcin Slusarz 已提交
813 814 815 816 817 818 819
		} else if ((laarr[i].extLength >> 30) ==
				(EXT_NOT_RECORDED_NOT_ALLOCATED >> 30)) {
			length += (((laarr[i].extLength &
						UDF_EXTENT_LENGTH_MASK) +
				    inode->i_sb->s_blocksize - 1) >>
				    inode->i_sb->s_blocksize_bits);
		} else
L
Linus Torvalds 已提交
820 821 822
			break;
	}

823
	if (length) {
L
Linus Torvalds 已提交
824
		int next = laarr[start].extLocation.logicalBlockNum +
825
			(((laarr[start].extLength & UDF_EXTENT_LENGTH_MASK) +
M
Marcin Slusarz 已提交
826 827
			  inode->i_sb->s_blocksize - 1) >>
			  inode->i_sb->s_blocksize_bits);
L
Linus Torvalds 已提交
828
		int numalloc = udf_prealloc_blocks(inode->i_sb, inode,
M
Marcin Slusarz 已提交
829 830 831 832
				laarr[start].extLocation.partitionReferenceNum,
				next, (UDF_DEFAULT_PREALLOC_BLOCKS > length ?
				length : UDF_DEFAULT_PREALLOC_BLOCKS) -
				currlength);
833
		if (numalloc) 	{
M
Marcin Slusarz 已提交
834
			if (start == (c + 1))
L
Linus Torvalds 已提交
835
				laarr[start].extLength +=
M
Marcin Slusarz 已提交
836 837 838
					(numalloc <<
					 inode->i_sb->s_blocksize_bits);
			else {
839 840 841 842 843
				memmove(&laarr[c + 2], &laarr[c + 1],
					sizeof(long_ad) * (*endnum - (c + 1)));
				(*endnum)++;
				laarr[c + 1].extLocation.logicalBlockNum = next;
				laarr[c + 1].extLocation.partitionReferenceNum =
M
Marcin Slusarz 已提交
844 845 846 847 848 849
					laarr[c].extLocation.
							partitionReferenceNum;
				laarr[c + 1].extLength =
					EXT_NOT_RECORDED_ALLOCATED |
					(numalloc <<
					 inode->i_sb->s_blocksize_bits);
850
				start = c + 1;
L
Linus Torvalds 已提交
851 852
			}

853
			for (i = start + 1; numalloc && i < *endnum; i++) {
M
Marcin Slusarz 已提交
854 855 856 857
				int elen = ((laarr[i].extLength &
						UDF_EXTENT_LENGTH_MASK) +
					    inode->i_sb->s_blocksize - 1) >>
					    inode->i_sb->s_blocksize_bits;
L
Linus Torvalds 已提交
858

859
				if (elen > numalloc) {
L
Linus Torvalds 已提交
860
					laarr[i].extLength -=
M
Marcin Slusarz 已提交
861 862
						(numalloc <<
						 inode->i_sb->s_blocksize_bits);
L
Linus Torvalds 已提交
863
					numalloc = 0;
864
				} else {
L
Linus Torvalds 已提交
865
					numalloc -= elen;
866
					if (*endnum > (i + 1))
M
Marcin Slusarz 已提交
867 868 869 870
						memmove(&laarr[i],
							&laarr[i + 1],
							sizeof(long_ad) *
							(*endnum - (i + 1)));
871 872
					i--;
					(*endnum)--;
L
Linus Torvalds 已提交
873 874
				}
			}
875
			UDF_I(inode)->i_lenExtents +=
M
Marcin Slusarz 已提交
876
				numalloc << inode->i_sb->s_blocksize_bits;
L
Linus Torvalds 已提交
877 878 879 880 881
		}
	}
}

static void udf_merge_extents(struct inode *inode,
882 883
			      kernel_long_ad laarr[EXTENT_MERGE_SIZE],
			      int *endnum)
L
Linus Torvalds 已提交
884 885
{
	int i;
M
Marcin Slusarz 已提交
886 887
	unsigned long blocksize = inode->i_sb->s_blocksize;
	unsigned char blocksize_bits = inode->i_sb->s_blocksize_bits;
L
Linus Torvalds 已提交
888

889
	for (i = 0; i < (*endnum - 1); i++) {
M
Marcin Slusarz 已提交
890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928
		kernel_long_ad *li /*l[i]*/ = &laarr[i];
		kernel_long_ad *lip1 /*l[i plus 1]*/ = &laarr[i + 1];

		if (((li->extLength >> 30) == (lip1->extLength >> 30)) &&
			(((li->extLength >> 30) ==
				(EXT_NOT_RECORDED_NOT_ALLOCATED >> 30)) ||
			((lip1->extLocation.logicalBlockNum -
			  li->extLocation.logicalBlockNum) ==
			(((li->extLength & UDF_EXTENT_LENGTH_MASK) +
			blocksize - 1) >> blocksize_bits)))) {

			if (((li->extLength & UDF_EXTENT_LENGTH_MASK) +
				(lip1->extLength & UDF_EXTENT_LENGTH_MASK) +
				blocksize - 1) & ~UDF_EXTENT_LENGTH_MASK) {
				lip1->extLength = (lip1->extLength -
						  (li->extLength &
						   UDF_EXTENT_LENGTH_MASK) +
						   UDF_EXTENT_LENGTH_MASK) &
							~(blocksize - 1);
				li->extLength = (li->extLength &
						 UDF_EXTENT_FLAG_MASK) +
						(UDF_EXTENT_LENGTH_MASK + 1) -
						blocksize;
				lip1->extLocation.logicalBlockNum =
					li->extLocation.logicalBlockNum +
					((li->extLength &
						UDF_EXTENT_LENGTH_MASK) >>
						blocksize_bits);
			} else {
				li->extLength = lip1->extLength +
					(((li->extLength &
						UDF_EXTENT_LENGTH_MASK) +
					 blocksize - 1) & ~(blocksize - 1));
				if (*endnum > (i + 2))
					memmove(&laarr[i + 1], &laarr[i + 2],
						sizeof(long_ad) *
						(*endnum - (i + 2)));
				i--;
				(*endnum)--;
L
Linus Torvalds 已提交
929
			}
M
Marcin Slusarz 已提交
930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952
		} else if (((li->extLength >> 30) ==
				(EXT_NOT_RECORDED_ALLOCATED >> 30)) &&
			   ((lip1->extLength >> 30) ==
				(EXT_NOT_RECORDED_NOT_ALLOCATED >> 30))) {
			udf_free_blocks(inode->i_sb, inode, li->extLocation, 0,
					((li->extLength &
					  UDF_EXTENT_LENGTH_MASK) +
					 blocksize - 1) >> blocksize_bits);
			li->extLocation.logicalBlockNum = 0;
			li->extLocation.partitionReferenceNum = 0;

			if (((li->extLength & UDF_EXTENT_LENGTH_MASK) +
			     (lip1->extLength & UDF_EXTENT_LENGTH_MASK) +
			     blocksize - 1) & ~UDF_EXTENT_LENGTH_MASK) {
				lip1->extLength = (lip1->extLength -
						   (li->extLength &
						   UDF_EXTENT_LENGTH_MASK) +
						   UDF_EXTENT_LENGTH_MASK) &
						   ~(blocksize - 1);
				li->extLength = (li->extLength &
						 UDF_EXTENT_FLAG_MASK) +
						(UDF_EXTENT_LENGTH_MASK + 1) -
						blocksize;
953
			} else {
M
Marcin Slusarz 已提交
954 955 956 957
				li->extLength = lip1->extLength +
					(((li->extLength &
						UDF_EXTENT_LENGTH_MASK) +
					  blocksize - 1) & ~(blocksize - 1));
958 959
				if (*endnum > (i + 2))
					memmove(&laarr[i + 1], &laarr[i + 2],
M
Marcin Slusarz 已提交
960 961
						sizeof(long_ad) *
						(*endnum - (i + 2)));
962 963
				i--;
				(*endnum)--;
L
Linus Torvalds 已提交
964
			}
M
Marcin Slusarz 已提交
965 966 967 968 969 970 971 972 973 974 975 976
		} else if ((li->extLength >> 30) ==
					(EXT_NOT_RECORDED_ALLOCATED >> 30)) {
			udf_free_blocks(inode->i_sb, inode,
					li->extLocation, 0,
					((li->extLength &
						UDF_EXTENT_LENGTH_MASK) +
					 blocksize - 1) >> blocksize_bits);
			li->extLocation.logicalBlockNum = 0;
			li->extLocation.partitionReferenceNum = 0;
			li->extLength = (li->extLength &
						UDF_EXTENT_LENGTH_MASK) |
						EXT_NOT_RECORDED_NOT_ALLOCATED;
L
Linus Torvalds 已提交
977 978 979 980 981
		}
	}
}

static void udf_update_extents(struct inode *inode,
982 983 984
			       kernel_long_ad laarr[EXTENT_MERGE_SIZE],
			       int startnum, int endnum,
			       struct extent_position *epos)
L
Linus Torvalds 已提交
985 986 987 988 989
{
	int start = 0, i;
	kernel_lb_addr tmploc;
	uint32_t tmplen;

990 991
	if (startnum > endnum) {
		for (i = 0; i < (startnum - endnum); i++)
J
Jan Kara 已提交
992
			udf_delete_aext(inode, *epos, laarr[i].extLocation,
993 994 995
					laarr[i].extLength);
	} else if (startnum < endnum) {
		for (i = 0; i < (endnum - startnum); i++) {
J
Jan Kara 已提交
996
			udf_insert_aext(inode, *epos, laarr[i].extLocation,
997
					laarr[i].extLength);
J
Jan Kara 已提交
998
			udf_next_aext(inode, epos, &laarr[i].extLocation,
999 1000
				      &laarr[i].extLength, 1);
			start++;
L
Linus Torvalds 已提交
1001 1002 1003
		}
	}

1004
	for (i = start; i < endnum; i++) {
J
Jan Kara 已提交
1005 1006
		udf_next_aext(inode, epos, &tmploc, &tmplen, 0);
		udf_write_aext(inode, epos, laarr[i].extLocation,
1007
			       laarr[i].extLength, 1);
L
Linus Torvalds 已提交
1008 1009 1010
	}
}

1011 1012
struct buffer_head *udf_bread(struct inode *inode, int block,
			      int create, int *err)
L
Linus Torvalds 已提交
1013
{
1014
	struct buffer_head *bh = NULL;
L
Linus Torvalds 已提交
1015 1016 1017 1018 1019 1020 1021

	bh = udf_getblk(inode, block, create, err);
	if (!bh)
		return NULL;

	if (buffer_uptodate(bh))
		return bh;
1022

L
Linus Torvalds 已提交
1023
	ll_rw_block(READ, 1, &bh);
1024

L
Linus Torvalds 已提交
1025 1026 1027
	wait_on_buffer(bh);
	if (buffer_uptodate(bh))
		return bh;
1028

L
Linus Torvalds 已提交
1029 1030 1031 1032 1033
	brelse(bh);
	*err = -EIO;
	return NULL;
}

1034
void udf_truncate(struct inode *inode)
L
Linus Torvalds 已提交
1035 1036 1037
{
	int offset;
	int err;
1038
	struct udf_inode_info *iinfo;
L
Linus Torvalds 已提交
1039 1040

	if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
1041
	      S_ISLNK(inode->i_mode)))
L
Linus Torvalds 已提交
1042 1043 1044 1045 1046
		return;
	if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
		return;

	lock_kernel();
1047 1048
	iinfo = UDF_I(inode);
	if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {
M
Marcin Slusarz 已提交
1049 1050 1051
		if (inode->i_sb->s_blocksize <
				(udf_file_entry_alloc_offset(inode) +
				 inode->i_size)) {
L
Linus Torvalds 已提交
1052
			udf_expand_file_adinicb(inode, inode->i_size, &err);
1053 1054
			if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {
				inode->i_size = iinfo->i_lenAlloc;
L
Linus Torvalds 已提交
1055 1056
				unlock_kernel();
				return;
M
Marcin Slusarz 已提交
1057
			} else
L
Linus Torvalds 已提交
1058
				udf_truncate_extents(inode);
1059
		} else {
L
Linus Torvalds 已提交
1060
			offset = inode->i_size & (inode->i_sb->s_blocksize - 1);
1061
			memset(iinfo->i_ext.i_data + iinfo->i_lenEAttr + offset,
1062
				0x00, inode->i_sb->s_blocksize -
M
Marcin Slusarz 已提交
1063
				offset - udf_file_entry_alloc_offset(inode));
1064
			iinfo->i_lenAlloc = inode->i_size;
L
Linus Torvalds 已提交
1065
		}
1066
	} else {
M
Marcin Slusarz 已提交
1067 1068
		block_truncate_page(inode->i_mapping, inode->i_size,
				    udf_get_block);
L
Linus Torvalds 已提交
1069
		udf_truncate_extents(inode);
1070
	}
L
Linus Torvalds 已提交
1071 1072 1073

	inode->i_mtime = inode->i_ctime = current_fs_time(inode->i_sb);
	if (IS_SYNC(inode))
1074
		udf_sync_inode(inode);
L
Linus Torvalds 已提交
1075 1076 1077 1078 1079
	else
		mark_inode_dirty(inode);
	unlock_kernel();
}

1080
static void __udf_read_inode(struct inode *inode)
L
Linus Torvalds 已提交
1081 1082 1083 1084
{
	struct buffer_head *bh = NULL;
	struct fileEntry *fe;
	uint16_t ident;
1085
	struct udf_inode_info *iinfo = UDF_I(inode);
L
Linus Torvalds 已提交
1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098

	/*
	 * Set defaults, but the inode is still incomplete!
	 * Note: get_new_inode() sets the following on a new inode:
	 *      i_sb = sb
	 *      i_no = ino
	 *      i_flags = sb->s_flags
	 *      i_state = 0
	 * clean_inode(): zero fills and sets
	 *      i_count = 1
	 *      i_nlink = 1
	 *      i_op = NULL;
	 */
1099
	bh = udf_read_ptagged(inode->i_sb, iinfo->i_location, 0, &ident);
1100
	if (!bh) {
L
Linus Torvalds 已提交
1101
		printk(KERN_ERR "udf: udf_read_inode(ino %ld) failed !bh\n",
1102
		       inode->i_ino);
L
Linus Torvalds 已提交
1103 1104 1105 1106 1107
		make_bad_inode(inode);
		return;
	}

	if (ident != TAG_IDENT_FE && ident != TAG_IDENT_EFE &&
1108
	    ident != TAG_IDENT_USE) {
M
Marcin Slusarz 已提交
1109 1110
		printk(KERN_ERR "udf: udf_read_inode(ino %ld) "
				"failed ident=%d\n", inode->i_ino, ident);
J
Jan Kara 已提交
1111
		brelse(bh);
L
Linus Torvalds 已提交
1112 1113 1114 1115 1116 1117
		make_bad_inode(inode);
		return;
	}

	fe = (struct fileEntry *)bh->b_data;

1118
	if (fe->icbTag.strategyType == cpu_to_le16(4096)) {
L
Linus Torvalds 已提交
1119 1120 1121
		struct buffer_head *ibh = NULL, *nbh = NULL;
		struct indirectEntry *ie;

1122
		ibh = udf_read_ptagged(inode->i_sb, iinfo->i_location, 1,
M
Marcin Slusarz 已提交
1123
					&ident);
1124 1125
		if (ident == TAG_IDENT_IE) {
			if (ibh) {
L
Linus Torvalds 已提交
1126 1127
				kernel_lb_addr loc;
				ie = (struct indirectEntry *)ibh->b_data;
1128

L
Linus Torvalds 已提交
1129
				loc = lelb_to_cpu(ie->indirectICB.extLocation);
1130 1131

				if (ie->indirectICB.extLength &&
M
Marcin Slusarz 已提交
1132 1133
				    (nbh = udf_read_ptagged(inode->i_sb, loc, 0,
							    &ident))) {
1134 1135
					if (ident == TAG_IDENT_FE ||
					    ident == TAG_IDENT_EFE) {
1136
						memcpy(&iinfo->i_location,
M
Marcin Slusarz 已提交
1137
						       &loc,
1138
						       sizeof(kernel_lb_addr));
J
Jan Kara 已提交
1139 1140 1141
						brelse(bh);
						brelse(ibh);
						brelse(nbh);
L
Linus Torvalds 已提交
1142 1143
						__udf_read_inode(inode);
						return;
1144
					} else {
J
Jan Kara 已提交
1145 1146
						brelse(nbh);
						brelse(ibh);
L
Linus Torvalds 已提交
1147
					}
1148
				} else {
J
Jan Kara 已提交
1149
					brelse(ibh);
1150
				}
L
Linus Torvalds 已提交
1151
			}
1152
		} else {
J
Jan Kara 已提交
1153
			brelse(ibh);
1154
		}
1155
	} else if (fe->icbTag.strategyType != cpu_to_le16(4)) {
L
Linus Torvalds 已提交
1156
		printk(KERN_ERR "udf: unsupported strategy type: %d\n",
1157
		       le16_to_cpu(fe->icbTag.strategyType));
J
Jan Kara 已提交
1158
		brelse(bh);
L
Linus Torvalds 已提交
1159 1160 1161 1162
		make_bad_inode(inode);
		return;
	}
	udf_fill_inode(inode, bh);
J
Jan Kara 已提交
1163

J
Jan Kara 已提交
1164
	brelse(bh);
L
Linus Torvalds 已提交
1165 1166 1167 1168 1169 1170 1171 1172 1173
}

static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
{
	struct fileEntry *fe;
	struct extendedFileEntry *efe;
	time_t convtime;
	long convtime_usec;
	int offset;
M
Marcin Slusarz 已提交
1174
	struct udf_sb_info *sbi = UDF_SB(inode->i_sb);
1175
	struct udf_inode_info *iinfo = UDF_I(inode);
L
Linus Torvalds 已提交
1176 1177 1178 1179

	fe = (struct fileEntry *)bh->b_data;
	efe = (struct extendedFileEntry *)bh->b_data;

1180
	if (fe->icbTag.strategyType == cpu_to_le16(4))
1181
		iinfo->i_strat4096 = 0;
1182
	else /* if (fe->icbTag.strategyType == cpu_to_le16(4096)) */
1183
		iinfo->i_strat4096 = 1;
L
Linus Torvalds 已提交
1184

1185
	iinfo->i_alloc_type = le16_to_cpu(fe->icbTag.flags) &
M
Marcin Slusarz 已提交
1186
							ICBTAG_FLAG_AD_MASK;
1187 1188 1189 1190 1191 1192
	iinfo->i_unique = 0;
	iinfo->i_lenEAttr = 0;
	iinfo->i_lenExtents = 0;
	iinfo->i_lenAlloc = 0;
	iinfo->i_next_alloc_block = 0;
	iinfo->i_next_alloc_goal = 0;
1193
	if (fe->descTag.tagIdent == cpu_to_le16(TAG_IDENT_EFE)) {
1194 1195
		iinfo->i_efe = 1;
		iinfo->i_use = 0;
M
Marcin Slusarz 已提交
1196 1197
		if (udf_alloc_i_data(inode, inode->i_sb->s_blocksize -
					sizeof(struct extendedFileEntry))) {
1198 1199 1200
			make_bad_inode(inode);
			return;
		}
1201
		memcpy(iinfo->i_ext.i_data,
M
Marcin Slusarz 已提交
1202 1203 1204
		       bh->b_data + sizeof(struct extendedFileEntry),
		       inode->i_sb->s_blocksize -
					sizeof(struct extendedFileEntry));
1205
	} else if (fe->descTag.tagIdent == cpu_to_le16(TAG_IDENT_FE)) {
1206 1207
		iinfo->i_efe = 0;
		iinfo->i_use = 0;
M
Marcin Slusarz 已提交
1208 1209
		if (udf_alloc_i_data(inode, inode->i_sb->s_blocksize -
						sizeof(struct fileEntry))) {
1210 1211 1212
			make_bad_inode(inode);
			return;
		}
1213
		memcpy(iinfo->i_ext.i_data,
1214
		       bh->b_data + sizeof(struct fileEntry),
1215
		       inode->i_sb->s_blocksize - sizeof(struct fileEntry));
1216
	} else if (fe->descTag.tagIdent == cpu_to_le16(TAG_IDENT_USE)) {
1217 1218 1219
		iinfo->i_efe = 0;
		iinfo->i_use = 1;
		iinfo->i_lenAlloc = le32_to_cpu(
M
Marcin Slusarz 已提交
1220 1221 1222 1223
				((struct unallocSpaceEntry *)bh->b_data)->
				 lengthAllocDescs);
		if (udf_alloc_i_data(inode, inode->i_sb->s_blocksize -
					sizeof(struct unallocSpaceEntry))) {
1224 1225 1226
			make_bad_inode(inode);
			return;
		}
1227
		memcpy(iinfo->i_ext.i_data,
M
Marcin Slusarz 已提交
1228 1229 1230
		       bh->b_data + sizeof(struct unallocSpaceEntry),
		       inode->i_sb->s_blocksize -
					sizeof(struct unallocSpaceEntry));
L
Linus Torvalds 已提交
1231 1232 1233 1234
		return;
	}

	inode->i_uid = le32_to_cpu(fe->uid);
1235 1236 1237
	if (inode->i_uid == -1 ||
	    UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_UID_IGNORE) ||
	    UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_UID_SET))
1238
		inode->i_uid = UDF_SB(inode->i_sb)->s_uid;
L
Linus Torvalds 已提交
1239 1240

	inode->i_gid = le32_to_cpu(fe->gid);
1241 1242 1243
	if (inode->i_gid == -1 ||
	    UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_GID_IGNORE) ||
	    UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_GID_SET))
1244
		inode->i_gid = UDF_SB(inode->i_sb)->s_gid;
L
Linus Torvalds 已提交
1245 1246 1247 1248

	inode->i_nlink = le16_to_cpu(fe->fileLinkCount);
	if (!inode->i_nlink)
		inode->i_nlink = 1;
1249

L
Linus Torvalds 已提交
1250
	inode->i_size = le64_to_cpu(fe->informationLength);
1251
	iinfo->i_lenExtents = inode->i_size;
L
Linus Torvalds 已提交
1252 1253 1254 1255

	inode->i_mode = udf_convert_permissions(fe);
	inode->i_mode &= ~UDF_SB(inode->i_sb)->s_umask;

1256
	if (iinfo->i_efe == 0) {
L
Linus Torvalds 已提交
1257
		inode->i_blocks = le64_to_cpu(fe->logicalBlocksRecorded) <<
1258
			(inode->i_sb->s_blocksize_bits - 9);
L
Linus Torvalds 已提交
1259

1260 1261
		if (udf_stamp_to_time(&convtime, &convtime_usec,
				      lets_to_cpu(fe->accessTime))) {
L
Linus Torvalds 已提交
1262 1263
			inode->i_atime.tv_sec = convtime;
			inode->i_atime.tv_nsec = convtime_usec * 1000;
1264
		} else {
M
Marcin Slusarz 已提交
1265
			inode->i_atime = sbi->s_record_time;
L
Linus Torvalds 已提交
1266 1267
		}

1268 1269
		if (udf_stamp_to_time(&convtime, &convtime_usec,
				      lets_to_cpu(fe->modificationTime))) {
L
Linus Torvalds 已提交
1270 1271
			inode->i_mtime.tv_sec = convtime;
			inode->i_mtime.tv_nsec = convtime_usec * 1000;
1272
		} else {
M
Marcin Slusarz 已提交
1273
			inode->i_mtime = sbi->s_record_time;
L
Linus Torvalds 已提交
1274 1275
		}

1276 1277
		if (udf_stamp_to_time(&convtime, &convtime_usec,
				      lets_to_cpu(fe->attrTime))) {
L
Linus Torvalds 已提交
1278 1279
			inode->i_ctime.tv_sec = convtime;
			inode->i_ctime.tv_nsec = convtime_usec * 1000;
1280
		} else {
M
Marcin Slusarz 已提交
1281
			inode->i_ctime = sbi->s_record_time;
L
Linus Torvalds 已提交
1282 1283
		}

1284 1285 1286 1287
		iinfo->i_unique = le64_to_cpu(fe->uniqueID);
		iinfo->i_lenEAttr = le32_to_cpu(fe->lengthExtendedAttr);
		iinfo->i_lenAlloc = le32_to_cpu(fe->lengthAllocDescs);
		offset = sizeof(struct fileEntry) + iinfo->i_lenEAttr;
1288
	} else {
1289
		inode->i_blocks = le64_to_cpu(efe->logicalBlocksRecorded) <<
1290
		    (inode->i_sb->s_blocksize_bits - 9);
L
Linus Torvalds 已提交
1291

1292 1293
		if (udf_stamp_to_time(&convtime, &convtime_usec,
				      lets_to_cpu(efe->accessTime))) {
L
Linus Torvalds 已提交
1294 1295
			inode->i_atime.tv_sec = convtime;
			inode->i_atime.tv_nsec = convtime_usec * 1000;
1296
		} else {
M
Marcin Slusarz 已提交
1297
			inode->i_atime = sbi->s_record_time;
L
Linus Torvalds 已提交
1298 1299
		}

1300 1301
		if (udf_stamp_to_time(&convtime, &convtime_usec,
				      lets_to_cpu(efe->modificationTime))) {
L
Linus Torvalds 已提交
1302 1303
			inode->i_mtime.tv_sec = convtime;
			inode->i_mtime.tv_nsec = convtime_usec * 1000;
1304
		} else {
M
Marcin Slusarz 已提交
1305
			inode->i_mtime = sbi->s_record_time;
L
Linus Torvalds 已提交
1306 1307
		}

1308 1309
		if (udf_stamp_to_time(&convtime, &convtime_usec,
				      lets_to_cpu(efe->createTime))) {
1310 1311
			iinfo->i_crtime.tv_sec = convtime;
			iinfo->i_crtime.tv_nsec = convtime_usec * 1000;
1312
		} else {
1313
			iinfo->i_crtime = sbi->s_record_time;
L
Linus Torvalds 已提交
1314 1315
		}

1316 1317
		if (udf_stamp_to_time(&convtime, &convtime_usec,
				      lets_to_cpu(efe->attrTime))) {
L
Linus Torvalds 已提交
1318 1319
			inode->i_ctime.tv_sec = convtime;
			inode->i_ctime.tv_nsec = convtime_usec * 1000;
1320
		} else {
M
Marcin Slusarz 已提交
1321
			inode->i_ctime = sbi->s_record_time;
L
Linus Torvalds 已提交
1322 1323
		}

1324 1325 1326
		iinfo->i_unique = le64_to_cpu(efe->uniqueID);
		iinfo->i_lenEAttr = le32_to_cpu(efe->lengthExtendedAttr);
		iinfo->i_lenAlloc = le32_to_cpu(efe->lengthAllocDescs);
M
Marcin Slusarz 已提交
1327
		offset = sizeof(struct extendedFileEntry) +
1328
							iinfo->i_lenEAttr;
L
Linus Torvalds 已提交
1329 1330
	}

1331 1332
	switch (fe->icbTag.fileType) {
	case ICBTAG_FILE_TYPE_DIRECTORY:
1333 1334 1335 1336 1337
		inode->i_op = &udf_dir_inode_operations;
		inode->i_fop = &udf_dir_operations;
		inode->i_mode |= S_IFDIR;
		inc_nlink(inode);
		break;
1338 1339 1340
	case ICBTAG_FILE_TYPE_REALTIME:
	case ICBTAG_FILE_TYPE_REGULAR:
	case ICBTAG_FILE_TYPE_UNDEF:
1341
		if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
1342 1343 1344 1345 1346 1347 1348
			inode->i_data.a_ops = &udf_adinicb_aops;
		else
			inode->i_data.a_ops = &udf_aops;
		inode->i_op = &udf_file_inode_operations;
		inode->i_fop = &udf_file_operations;
		inode->i_mode |= S_IFREG;
		break;
1349
	case ICBTAG_FILE_TYPE_BLOCK:
1350 1351
		inode->i_mode |= S_IFBLK;
		break;
1352
	case ICBTAG_FILE_TYPE_CHAR:
1353 1354
		inode->i_mode |= S_IFCHR;
		break;
1355
	case ICBTAG_FILE_TYPE_FIFO:
1356 1357
		init_special_inode(inode, inode->i_mode | S_IFIFO, 0);
		break;
1358
	case ICBTAG_FILE_TYPE_SOCKET:
1359 1360
		init_special_inode(inode, inode->i_mode | S_IFSOCK, 0);
		break;
1361
	case ICBTAG_FILE_TYPE_SYMLINK:
1362 1363 1364 1365
		inode->i_data.a_ops = &udf_symlink_aops;
		inode->i_op = &page_symlink_inode_operations;
		inode->i_mode = S_IFLNK | S_IRWXUGO;
		break;
1366
	default:
M
Marcin Slusarz 已提交
1367 1368 1369
		printk(KERN_ERR "udf: udf_fill_inode(ino %ld) failed unknown "
				"file type=%d\n", inode->i_ino,
				fe->icbTag.fileType);
1370 1371
		make_bad_inode(inode);
		return;
L
Linus Torvalds 已提交
1372
	}
1373
	if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) {
M
Marcin Slusarz 已提交
1374 1375
		struct deviceSpec *dsea =
			(struct deviceSpec *)udf_get_extendedattr(inode, 12, 1);
1376 1377
		if (dsea) {
			init_special_inode(inode, inode->i_mode,
M
Marcin Slusarz 已提交
1378 1379
				MKDEV(le32_to_cpu(dsea->majorDeviceIdent),
				      le32_to_cpu(dsea->minorDeviceIdent)));
L
Linus Torvalds 已提交
1380
			/* Developer ID ??? */
M
Marcin Slusarz 已提交
1381
		} else
L
Linus Torvalds 已提交
1382 1383 1384 1385
			make_bad_inode(inode);
	}
}

1386 1387
static int udf_alloc_i_data(struct inode *inode, size_t size)
{
1388 1389
	struct udf_inode_info *iinfo = UDF_I(inode);
	iinfo->i_ext.i_data = kmalloc(size, GFP_KERNEL);
1390

1391
	if (!iinfo->i_ext.i_data) {
M
Marcin Slusarz 已提交
1392 1393
		printk(KERN_ERR "udf:udf_alloc_i_data (ino %ld) "
				"no free memory\n", inode->i_ino);
1394 1395 1396 1397 1398 1399
		return -ENOMEM;
	}

	return 0;
}

1400
static mode_t udf_convert_permissions(struct fileEntry *fe)
L
Linus Torvalds 已提交
1401 1402 1403 1404 1405 1406 1407 1408
{
	mode_t mode;
	uint32_t permissions;
	uint32_t flags;

	permissions = le32_to_cpu(fe->permissions);
	flags = le16_to_cpu(fe->icbTag.flags);

M
Marcin Slusarz 已提交
1409 1410 1411 1412 1413 1414
	mode =	((permissions) & S_IRWXO) |
		((permissions >> 2) & S_IRWXG) |
		((permissions >> 4) & S_IRWXU) |
		((flags & ICBTAG_FLAG_SETUID) ? S_ISUID : 0) |
		((flags & ICBTAG_FLAG_SETGID) ? S_ISGID : 0) |
		((flags & ICBTAG_FLAG_STICKY) ? S_ISVTX : 0);
L
Linus Torvalds 已提交
1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433

	return mode;
}

/*
 * udf_write_inode
 *
 * PURPOSE
 *	Write out the specified inode.
 *
 * DESCRIPTION
 *	This routine is called whenever an inode is synced.
 *	Currently this routine is just a placeholder.
 *
 * HISTORY
 *	July 1, 1997 - Andrew E. Mileski
 *	Written, tested, and released.
 */

1434
int udf_write_inode(struct inode *inode, int sync)
L
Linus Torvalds 已提交
1435 1436
{
	int ret;
1437

L
Linus Torvalds 已提交
1438 1439 1440
	lock_kernel();
	ret = udf_update_inode(inode, sync);
	unlock_kernel();
1441

L
Linus Torvalds 已提交
1442 1443 1444
	return ret;
}

1445
int udf_sync_inode(struct inode *inode)
L
Linus Torvalds 已提交
1446 1447 1448 1449
{
	return udf_update_inode(inode, 1);
}

1450
static int udf_update_inode(struct inode *inode, int do_sync)
L
Linus Torvalds 已提交
1451 1452 1453 1454 1455 1456 1457 1458 1459
{
	struct buffer_head *bh = NULL;
	struct fileEntry *fe;
	struct extendedFileEntry *efe;
	uint32_t udfperms;
	uint16_t icbflags;
	uint16_t crclen;
	kernel_timestamp cpu_time;
	int err = 0;
M
Marcin Slusarz 已提交
1460
	struct udf_sb_info *sbi = UDF_SB(inode->i_sb);
M
Marcin Slusarz 已提交
1461
	unsigned char blocksize_bits = inode->i_sb->s_blocksize_bits;
1462
	struct udf_inode_info *iinfo = UDF_I(inode);
L
Linus Torvalds 已提交
1463

M
Marcin Slusarz 已提交
1464 1465
	bh = udf_tread(inode->i_sb,
			udf_get_lb_pblock(inode->i_sb,
1466
					  iinfo->i_location, 0));
1467
	if (!bh) {
L
Linus Torvalds 已提交
1468 1469 1470 1471 1472 1473 1474 1475 1476
		udf_debug("bread failure\n");
		return -EIO;
	}

	memset(bh->b_data, 0x00, inode->i_sb->s_blocksize);

	fe = (struct fileEntry *)bh->b_data;
	efe = (struct extendedFileEntry *)bh->b_data;

1477
	if (fe->descTag.tagIdent == cpu_to_le16(TAG_IDENT_USE)) {
L
Linus Torvalds 已提交
1478
		struct unallocSpaceEntry *use =
1479
			(struct unallocSpaceEntry *)bh->b_data;
L
Linus Torvalds 已提交
1480

1481
		use->lengthAllocDescs = cpu_to_le32(iinfo->i_lenAlloc);
M
Marcin Slusarz 已提交
1482
		memcpy(bh->b_data + sizeof(struct unallocSpaceEntry),
1483
		       iinfo->i_ext.i_data, inode->i_sb->s_blocksize -
M
Marcin Slusarz 已提交
1484 1485
					sizeof(struct unallocSpaceEntry));
		crclen = sizeof(struct unallocSpaceEntry) +
1486
				iinfo->i_lenAlloc - sizeof(tag);
M
Marcin Slusarz 已提交
1487
		use->descTag.tagLocation = cpu_to_le32(
1488
						iinfo->i_location.
M
Marcin Slusarz 已提交
1489
							logicalBlockNum);
L
Linus Torvalds 已提交
1490
		use->descTag.descCRCLength = cpu_to_le16(crclen);
M
Marcin Slusarz 已提交
1491 1492 1493
		use->descTag.descCRC = cpu_to_le16(udf_crc((char *)use +
							   sizeof(tag), crclen,
							   0));
1494
		use->descTag.tagChecksum = udf_tag_checksum(&use->descTag);
L
Linus Torvalds 已提交
1495 1496

		mark_buffer_dirty(bh);
J
Jan Kara 已提交
1497
		brelse(bh);
L
Linus Torvalds 已提交
1498 1499 1500
		return err;
	}

1501 1502
	if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_UID_FORGET))
		fe->uid = cpu_to_le32(-1);
1503 1504
	else
		fe->uid = cpu_to_le32(inode->i_uid);
L
Linus Torvalds 已提交
1505

1506 1507
	if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_GID_FORGET))
		fe->gid = cpu_to_le32(-1);
1508 1509
	else
		fe->gid = cpu_to_le32(inode->i_gid);
L
Linus Torvalds 已提交
1510

M
Marcin Slusarz 已提交
1511 1512 1513
	udfperms = ((inode->i_mode & S_IRWXO)) |
		   ((inode->i_mode & S_IRWXG) << 2) |
		   ((inode->i_mode & S_IRWXU) << 4);
L
Linus Torvalds 已提交
1514

M
Marcin Slusarz 已提交
1515 1516 1517 1518
	udfperms |= (le32_to_cpu(fe->permissions) &
		    (FE_PERM_O_DELETE | FE_PERM_O_CHATTR |
		     FE_PERM_G_DELETE | FE_PERM_G_CHATTR |
		     FE_PERM_U_DELETE | FE_PERM_U_CHATTR));
L
Linus Torvalds 已提交
1519 1520 1521 1522 1523 1524 1525 1526 1527
	fe->permissions = cpu_to_le32(udfperms);

	if (S_ISDIR(inode->i_mode))
		fe->fileLinkCount = cpu_to_le16(inode->i_nlink - 1);
	else
		fe->fileLinkCount = cpu_to_le16(inode->i_nlink);

	fe->informationLength = cpu_to_le64(inode->i_size);

1528
	if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) {
L
Linus Torvalds 已提交
1529
		regid *eid;
1530 1531
		struct deviceSpec *dsea =
			(struct deviceSpec *)udf_get_extendedattr(inode, 12, 1);
1532
		if (!dsea) {
L
Linus Torvalds 已提交
1533
			dsea = (struct deviceSpec *)
1534 1535 1536
				udf_add_extendedattr(inode,
						     sizeof(struct deviceSpec) +
						     sizeof(regid), 12, 0x3);
L
Linus Torvalds 已提交
1537 1538
			dsea->attrType = cpu_to_le32(12);
			dsea->attrSubtype = 1;
M
Marcin Slusarz 已提交
1539 1540 1541
			dsea->attrLength = cpu_to_le32(
						sizeof(struct deviceSpec) +
						sizeof(regid));
L
Linus Torvalds 已提交
1542 1543
			dsea->impUseLength = cpu_to_le32(sizeof(regid));
		}
1544
		eid = (regid *)dsea->impUse;
L
Linus Torvalds 已提交
1545 1546 1547 1548 1549 1550 1551 1552
		memset(eid, 0, sizeof(regid));
		strcpy(eid->ident, UDF_ID_DEVELOPER);
		eid->identSuffix[0] = UDF_OS_CLASS_UNIX;
		eid->identSuffix[1] = UDF_OS_ID_LINUX;
		dsea->majorDeviceIdent = cpu_to_le32(imajor(inode));
		dsea->minorDeviceIdent = cpu_to_le32(iminor(inode));
	}

1553
	if (iinfo->i_efe == 0) {
1554
		memcpy(bh->b_data + sizeof(struct fileEntry),
1555
		       iinfo->i_ext.i_data,
1556
		       inode->i_sb->s_blocksize - sizeof(struct fileEntry));
1557
		fe->logicalBlocksRecorded = cpu_to_le64(
M
Marcin Slusarz 已提交
1558 1559
			(inode->i_blocks + (1 << (blocksize_bits - 9)) - 1) >>
			(blocksize_bits - 9));
L
Linus Torvalds 已提交
1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570

		if (udf_time_to_stamp(&cpu_time, inode->i_atime))
			fe->accessTime = cpu_to_lets(cpu_time);
		if (udf_time_to_stamp(&cpu_time, inode->i_mtime))
			fe->modificationTime = cpu_to_lets(cpu_time);
		if (udf_time_to_stamp(&cpu_time, inode->i_ctime))
			fe->attrTime = cpu_to_lets(cpu_time);
		memset(&(fe->impIdent), 0, sizeof(regid));
		strcpy(fe->impIdent.ident, UDF_ID_DEVELOPER);
		fe->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX;
		fe->impIdent.identSuffix[1] = UDF_OS_ID_LINUX;
1571 1572 1573
		fe->uniqueID = cpu_to_le64(iinfo->i_unique);
		fe->lengthExtendedAttr = cpu_to_le32(iinfo->i_lenEAttr);
		fe->lengthAllocDescs = cpu_to_le32(iinfo->i_lenAlloc);
L
Linus Torvalds 已提交
1574 1575
		fe->descTag.tagIdent = cpu_to_le16(TAG_IDENT_FE);
		crclen = sizeof(struct fileEntry);
1576
	} else {
M
Marcin Slusarz 已提交
1577
		memcpy(bh->b_data + sizeof(struct extendedFileEntry),
1578
		       iinfo->i_ext.i_data,
M
Marcin Slusarz 已提交
1579 1580
		       inode->i_sb->s_blocksize -
					sizeof(struct extendedFileEntry));
L
Linus Torvalds 已提交
1581
		efe->objectSize = cpu_to_le64(inode->i_size);
1582
		efe->logicalBlocksRecorded = cpu_to_le64(
M
Marcin Slusarz 已提交
1583 1584
			(inode->i_blocks + (1 << (blocksize_bits - 9)) - 1) >>
			(blocksize_bits - 9));
L
Linus Torvalds 已提交
1585

1586 1587 1588 1589
		if (iinfo->i_crtime.tv_sec > inode->i_atime.tv_sec ||
		    (iinfo->i_crtime.tv_sec == inode->i_atime.tv_sec &&
		     iinfo->i_crtime.tv_nsec > inode->i_atime.tv_nsec))
			iinfo->i_crtime = inode->i_atime;
M
Marcin Slusarz 已提交
1590

1591 1592 1593 1594
		if (iinfo->i_crtime.tv_sec > inode->i_mtime.tv_sec ||
		    (iinfo->i_crtime.tv_sec == inode->i_mtime.tv_sec &&
		     iinfo->i_crtime.tv_nsec > inode->i_mtime.tv_nsec))
			iinfo->i_crtime = inode->i_mtime;
M
Marcin Slusarz 已提交
1595

1596 1597 1598 1599
		if (iinfo->i_crtime.tv_sec > inode->i_ctime.tv_sec ||
		    (iinfo->i_crtime.tv_sec == inode->i_ctime.tv_sec &&
		     iinfo->i_crtime.tv_nsec > inode->i_ctime.tv_nsec))
			iinfo->i_crtime = inode->i_ctime;
L
Linus Torvalds 已提交
1600 1601 1602 1603 1604

		if (udf_time_to_stamp(&cpu_time, inode->i_atime))
			efe->accessTime = cpu_to_lets(cpu_time);
		if (udf_time_to_stamp(&cpu_time, inode->i_mtime))
			efe->modificationTime = cpu_to_lets(cpu_time);
1605
		if (udf_time_to_stamp(&cpu_time, iinfo->i_crtime))
L
Linus Torvalds 已提交
1606 1607 1608 1609 1610 1611 1612 1613
			efe->createTime = cpu_to_lets(cpu_time);
		if (udf_time_to_stamp(&cpu_time, inode->i_ctime))
			efe->attrTime = cpu_to_lets(cpu_time);

		memset(&(efe->impIdent), 0, sizeof(regid));
		strcpy(efe->impIdent.ident, UDF_ID_DEVELOPER);
		efe->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX;
		efe->impIdent.identSuffix[1] = UDF_OS_ID_LINUX;
1614 1615 1616
		efe->uniqueID = cpu_to_le64(iinfo->i_unique);
		efe->lengthExtendedAttr = cpu_to_le32(iinfo->i_lenEAttr);
		efe->lengthAllocDescs = cpu_to_le32(iinfo->i_lenAlloc);
L
Linus Torvalds 已提交
1617 1618 1619
		efe->descTag.tagIdent = cpu_to_le16(TAG_IDENT_EFE);
		crclen = sizeof(struct extendedFileEntry);
	}
1620
	if (iinfo->i_strat4096) {
L
Linus Torvalds 已提交
1621 1622 1623
		fe->icbTag.strategyType = cpu_to_le16(4096);
		fe->icbTag.strategyParameter = cpu_to_le16(1);
		fe->icbTag.numEntries = cpu_to_le16(2);
1624
	} else {
L
Linus Torvalds 已提交
1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643
		fe->icbTag.strategyType = cpu_to_le16(4);
		fe->icbTag.numEntries = cpu_to_le16(1);
	}

	if (S_ISDIR(inode->i_mode))
		fe->icbTag.fileType = ICBTAG_FILE_TYPE_DIRECTORY;
	else if (S_ISREG(inode->i_mode))
		fe->icbTag.fileType = ICBTAG_FILE_TYPE_REGULAR;
	else if (S_ISLNK(inode->i_mode))
		fe->icbTag.fileType = ICBTAG_FILE_TYPE_SYMLINK;
	else if (S_ISBLK(inode->i_mode))
		fe->icbTag.fileType = ICBTAG_FILE_TYPE_BLOCK;
	else if (S_ISCHR(inode->i_mode))
		fe->icbTag.fileType = ICBTAG_FILE_TYPE_CHAR;
	else if (S_ISFIFO(inode->i_mode))
		fe->icbTag.fileType = ICBTAG_FILE_TYPE_FIFO;
	else if (S_ISSOCK(inode->i_mode))
		fe->icbTag.fileType = ICBTAG_FILE_TYPE_SOCKET;

1644
	icbflags =	iinfo->i_alloc_type |
1645 1646 1647 1648 1649 1650
			((inode->i_mode & S_ISUID) ? ICBTAG_FLAG_SETUID : 0) |
			((inode->i_mode & S_ISGID) ? ICBTAG_FLAG_SETGID : 0) |
			((inode->i_mode & S_ISVTX) ? ICBTAG_FLAG_STICKY : 0) |
			(le16_to_cpu(fe->icbTag.flags) &
				~(ICBTAG_FLAG_AD_MASK | ICBTAG_FLAG_SETUID |
				ICBTAG_FLAG_SETGID | ICBTAG_FLAG_STICKY));
L
Linus Torvalds 已提交
1651 1652

	fe->icbTag.flags = cpu_to_le16(icbflags);
M
Marcin Slusarz 已提交
1653
	if (sbi->s_udfrev >= 0x0200)
L
Linus Torvalds 已提交
1654 1655 1656
		fe->descTag.descVersion = cpu_to_le16(3);
	else
		fe->descTag.descVersion = cpu_to_le16(2);
M
Marcin Slusarz 已提交
1657
	fe->descTag.tagSerialNum = cpu_to_le16(sbi->s_serial_number);
M
Marcin Slusarz 已提交
1658
	fe->descTag.tagLocation = cpu_to_le32(
1659 1660
					iinfo->i_location.logicalBlockNum);
	crclen += iinfo->i_lenEAttr + iinfo->i_lenAlloc -
1661
								sizeof(tag);
L
Linus Torvalds 已提交
1662
	fe->descTag.descCRCLength = cpu_to_le16(crclen);
M
Marcin Slusarz 已提交
1663 1664
	fe->descTag.descCRC = cpu_to_le16(udf_crc((char *)fe + sizeof(tag),
						  crclen, 0));
1665
	fe->descTag.tagChecksum = udf_tag_checksum(&fe->descTag);
L
Linus Torvalds 已提交
1666 1667 1668

	/* write the data blocks */
	mark_buffer_dirty(bh);
1669
	if (do_sync) {
L
Linus Torvalds 已提交
1670
		sync_dirty_buffer(bh);
1671
		if (buffer_req(bh) && !buffer_uptodate(bh)) {
M
Marcin Slusarz 已提交
1672 1673 1674
			printk(KERN_WARNING "IO error syncing udf inode "
				"[%s:%08lx]\n", inode->i_sb->s_id,
				inode->i_ino);
L
Linus Torvalds 已提交
1675 1676 1677
			err = -EIO;
		}
	}
J
Jan Kara 已提交
1678
	brelse(bh);
1679

L
Linus Torvalds 已提交
1680 1681 1682
	return err;
}

1683
struct inode *udf_iget(struct super_block *sb, kernel_lb_addr ino)
L
Linus Torvalds 已提交
1684 1685 1686 1687 1688 1689 1690 1691
{
	unsigned long block = udf_get_lb_pblock(sb, ino, 0);
	struct inode *inode = iget_locked(sb, block);

	if (!inode)
		return NULL;

	if (inode->i_state & I_NEW) {
1692
		memcpy(&UDF_I(inode)->i_location, &ino, sizeof(kernel_lb_addr));
L
Linus Torvalds 已提交
1693 1694 1695 1696 1697 1698 1699
		__udf_read_inode(inode);
		unlock_new_inode(inode);
	}

	if (is_bad_inode(inode))
		goto out_iput;

M
Marcin Slusarz 已提交
1700 1701
	if (ino.logicalBlockNum >= UDF_SB(sb)->
			s_partmaps[ino.partitionReferenceNum].s_partition_len) {
L
Linus Torvalds 已提交
1702
		udf_debug("block=%d, partition=%d out of range\n",
1703
			  ino.logicalBlockNum, ino.partitionReferenceNum);
L
Linus Torvalds 已提交
1704 1705 1706 1707 1708 1709
		make_bad_inode(inode);
		goto out_iput;
	}

	return inode;

1710
 out_iput:
L
Linus Torvalds 已提交
1711 1712 1713 1714
	iput(inode);
	return NULL;
}

M
Marcin Slusarz 已提交
1715
int8_t udf_add_aext(struct inode *inode, struct extent_position *epos,
1716
		    kernel_lb_addr eloc, uint32_t elen, int inc)
L
Linus Torvalds 已提交
1717 1718 1719 1720 1721 1722 1723
{
	int adsize;
	short_ad *sad = NULL;
	long_ad *lad = NULL;
	struct allocExtDesc *aed;
	int8_t etype;
	uint8_t *ptr;
1724
	struct udf_inode_info *iinfo = UDF_I(inode);
L
Linus Torvalds 已提交
1725

J
Jan Kara 已提交
1726
	if (!epos->bh)
1727
		ptr = iinfo->i_ext.i_data + epos->offset -
M
Marcin Slusarz 已提交
1728
			udf_file_entry_alloc_offset(inode) +
1729
			iinfo->i_lenEAttr;
L
Linus Torvalds 已提交
1730
	else
J
Jan Kara 已提交
1731
		ptr = epos->bh->b_data + epos->offset;
L
Linus Torvalds 已提交
1732

1733
	if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
L
Linus Torvalds 已提交
1734
		adsize = sizeof(short_ad);
1735
	else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
L
Linus Torvalds 已提交
1736 1737 1738 1739
		adsize = sizeof(long_ad);
	else
		return -1;

1740
	if (epos->offset + (2 * adsize) > inode->i_sb->s_blocksize) {
L
Linus Torvalds 已提交
1741 1742 1743
		char *sptr, *dptr;
		struct buffer_head *nbh;
		int err, loffset;
J
Jan Kara 已提交
1744
		kernel_lb_addr obloc = epos->block;
L
Linus Torvalds 已提交
1745

M
Marcin Slusarz 已提交
1746 1747 1748 1749
		epos->block.logicalBlockNum = udf_new_block(inode->i_sb, NULL,
						obloc.partitionReferenceNum,
						obloc.logicalBlockNum, &err);
		if (!epos->block.logicalBlockNum)
L
Linus Torvalds 已提交
1750
			return -1;
M
Marcin Slusarz 已提交
1751 1752 1753 1754
		nbh = udf_tgetblk(inode->i_sb, udf_get_lb_pblock(inode->i_sb,
								 epos->block,
								 0));
		if (!nbh)
L
Linus Torvalds 已提交
1755 1756 1757 1758 1759 1760 1761 1762 1763
			return -1;
		lock_buffer(nbh);
		memset(nbh->b_data, 0x00, inode->i_sb->s_blocksize);
		set_buffer_uptodate(nbh);
		unlock_buffer(nbh);
		mark_buffer_dirty_inode(nbh, inode);

		aed = (struct allocExtDesc *)(nbh->b_data);
		if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT))
M
Marcin Slusarz 已提交
1764 1765
			aed->previousAllocExtLocation =
					cpu_to_le32(obloc.logicalBlockNum);
1766
		if (epos->offset + adsize > inode->i_sb->s_blocksize) {
J
Jan Kara 已提交
1767
			loffset = epos->offset;
L
Linus Torvalds 已提交
1768 1769 1770 1771
			aed->lengthAllocDescs = cpu_to_le32(adsize);
			sptr = ptr - adsize;
			dptr = nbh->b_data + sizeof(struct allocExtDesc);
			memcpy(dptr, sptr, adsize);
J
Jan Kara 已提交
1772
			epos->offset = sizeof(struct allocExtDesc) + adsize;
1773
		} else {
J
Jan Kara 已提交
1774
			loffset = epos->offset + adsize;
L
Linus Torvalds 已提交
1775 1776
			aed->lengthAllocDescs = cpu_to_le32(0);
			sptr = ptr;
J
Jan Kara 已提交
1777
			epos->offset = sizeof(struct allocExtDesc);
L
Linus Torvalds 已提交
1778

1779
			if (epos->bh) {
J
Jan Kara 已提交
1780
				aed = (struct allocExtDesc *)epos->bh->b_data;
L
Linus Torvalds 已提交
1781
				aed->lengthAllocDescs =
M
Marcin Slusarz 已提交
1782 1783
					cpu_to_le32(le32_to_cpu(
					aed->lengthAllocDescs) + adsize);
1784
			} else {
1785
				iinfo->i_lenAlloc += adsize;
L
Linus Torvalds 已提交
1786 1787 1788
				mark_inode_dirty(inode);
			}
		}
M
Marcin Slusarz 已提交
1789
		if (UDF_SB(inode->i_sb)->s_udfrev >= 0x0200)
L
Linus Torvalds 已提交
1790
			udf_new_tag(nbh->b_data, TAG_IDENT_AED, 3, 1,
1791
				    epos->block.logicalBlockNum, sizeof(tag));
L
Linus Torvalds 已提交
1792 1793
		else
			udf_new_tag(nbh->b_data, TAG_IDENT_AED, 2, 1,
1794
				    epos->block.logicalBlockNum, sizeof(tag));
1795
		switch (iinfo->i_alloc_type) {
1796
		case ICBTAG_FLAG_AD_SHORT:
1797 1798 1799
			sad = (short_ad *)sptr;
			sad->extLength = cpu_to_le32(EXT_NEXT_EXTENT_ALLOCDECS |
						     inode->i_sb->s_blocksize);
M
Marcin Slusarz 已提交
1800 1801
			sad->extPosition =
				cpu_to_le32(epos->block.logicalBlockNum);
1802
			break;
1803
		case ICBTAG_FLAG_AD_LONG:
1804 1805 1806 1807 1808 1809
			lad = (long_ad *)sptr;
			lad->extLength = cpu_to_le32(EXT_NEXT_EXTENT_ALLOCDECS |
						     inode->i_sb->s_blocksize);
			lad->extLocation = cpu_to_lelb(epos->block);
			memset(lad->impUse, 0x00, sizeof(lad->impUse));
			break;
L
Linus Torvalds 已提交
1810
		}
1811
		if (epos->bh) {
1812
			if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) ||
M
Marcin Slusarz 已提交
1813
			    UDF_SB(inode->i_sb)->s_udfrev >= 0x0201)
J
Jan Kara 已提交
1814
				udf_update_tag(epos->bh->b_data, loffset);
L
Linus Torvalds 已提交
1815
			else
M
Marcin Slusarz 已提交
1816 1817
				udf_update_tag(epos->bh->b_data,
						sizeof(struct allocExtDesc));
J
Jan Kara 已提交
1818
			mark_buffer_dirty_inode(epos->bh, inode);
J
Jan Kara 已提交
1819
			brelse(epos->bh);
1820
		} else {
L
Linus Torvalds 已提交
1821
			mark_inode_dirty(inode);
1822
		}
J
Jan Kara 已提交
1823
		epos->bh = nbh;
L
Linus Torvalds 已提交
1824 1825
	}

J
Jan Kara 已提交
1826
	etype = udf_write_aext(inode, epos, eloc, elen, inc);
L
Linus Torvalds 已提交
1827

1828
	if (!epos->bh) {
1829
		iinfo->i_lenAlloc += adsize;
L
Linus Torvalds 已提交
1830
		mark_inode_dirty(inode);
1831
	} else {
J
Jan Kara 已提交
1832
		aed = (struct allocExtDesc *)epos->bh->b_data;
L
Linus Torvalds 已提交
1833
		aed->lengthAllocDescs =
M
Marcin Slusarz 已提交
1834 1835 1836 1837 1838 1839
			cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) +
				    adsize);
		if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) ||
				UDF_SB(inode->i_sb)->s_udfrev >= 0x0201)
			udf_update_tag(epos->bh->b_data,
					epos->offset + (inc ? 0 : adsize));
L
Linus Torvalds 已提交
1840
		else
M
Marcin Slusarz 已提交
1841 1842
			udf_update_tag(epos->bh->b_data,
					sizeof(struct allocExtDesc));
J
Jan Kara 已提交
1843
		mark_buffer_dirty_inode(epos->bh, inode);
L
Linus Torvalds 已提交
1844 1845 1846 1847 1848
	}

	return etype;
}

M
Marcin Slusarz 已提交
1849
int8_t udf_write_aext(struct inode *inode, struct extent_position *epos,
1850
		      kernel_lb_addr eloc, uint32_t elen, int inc)
L
Linus Torvalds 已提交
1851 1852 1853
{
	int adsize;
	uint8_t *ptr;
1854 1855
	short_ad *sad;
	long_ad *lad;
1856
	struct udf_inode_info *iinfo = UDF_I(inode);
L
Linus Torvalds 已提交
1857

J
Jan Kara 已提交
1858
	if (!epos->bh)
1859
		ptr = iinfo->i_ext.i_data + epos->offset -
M
Marcin Slusarz 已提交
1860
			udf_file_entry_alloc_offset(inode) +
1861
			iinfo->i_lenEAttr;
L
Linus Torvalds 已提交
1862
	else
J
Jan Kara 已提交
1863
		ptr = epos->bh->b_data + epos->offset;
L
Linus Torvalds 已提交
1864

1865
	switch (iinfo->i_alloc_type) {
1866
	case ICBTAG_FLAG_AD_SHORT:
1867 1868 1869 1870 1871
		sad = (short_ad *)ptr;
		sad->extLength = cpu_to_le32(elen);
		sad->extPosition = cpu_to_le32(eloc.logicalBlockNum);
		adsize = sizeof(short_ad);
		break;
1872
	case ICBTAG_FLAG_AD_LONG:
1873 1874 1875 1876 1877 1878
		lad = (long_ad *)ptr;
		lad->extLength = cpu_to_le32(elen);
		lad->extLocation = cpu_to_lelb(eloc);
		memset(lad->impUse, 0x00, sizeof(lad->impUse));
		adsize = sizeof(long_ad);
		break;
1879 1880
	default:
		return -1;
L
Linus Torvalds 已提交
1881 1882
	}

1883
	if (epos->bh) {
1884
		if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) ||
M
Marcin Slusarz 已提交
1885
		    UDF_SB(inode->i_sb)->s_udfrev >= 0x0201) {
M
Marcin Slusarz 已提交
1886 1887
			struct allocExtDesc *aed =
				(struct allocExtDesc *)epos->bh->b_data;
J
Jan Kara 已提交
1888
			udf_update_tag(epos->bh->b_data,
M
Marcin Slusarz 已提交
1889 1890
				       le32_to_cpu(aed->lengthAllocDescs) +
				       sizeof(struct allocExtDesc));
L
Linus Torvalds 已提交
1891
		}
J
Jan Kara 已提交
1892
		mark_buffer_dirty_inode(epos->bh, inode);
1893
	} else {
L
Linus Torvalds 已提交
1894
		mark_inode_dirty(inode);
1895
	}
L
Linus Torvalds 已提交
1896 1897

	if (inc)
J
Jan Kara 已提交
1898
		epos->offset += adsize;
1899

L
Linus Torvalds 已提交
1900 1901 1902
	return (elen >> 30);
}

M
Marcin Slusarz 已提交
1903 1904
int8_t udf_next_aext(struct inode *inode, struct extent_position *epos,
		     kernel_lb_addr *eloc, uint32_t *elen, int inc)
L
Linus Torvalds 已提交
1905 1906 1907
{
	int8_t etype;

J
Jan Kara 已提交
1908
	while ((etype = udf_current_aext(inode, epos, eloc, elen, inc)) ==
1909
	       (EXT_NEXT_EXTENT_ALLOCDECS >> 30)) {
M
Marcin Slusarz 已提交
1910
		int block;
J
Jan Kara 已提交
1911 1912
		epos->block = *eloc;
		epos->offset = sizeof(struct allocExtDesc);
J
Jan Kara 已提交
1913
		brelse(epos->bh);
M
Marcin Slusarz 已提交
1914 1915 1916 1917
		block = udf_get_lb_pblock(inode->i_sb, epos->block, 0);
		epos->bh = udf_tread(inode->i_sb, block);
		if (!epos->bh) {
			udf_debug("reading block %d failed!\n", block);
L
Linus Torvalds 已提交
1918 1919 1920 1921 1922 1923 1924
			return -1;
		}
	}

	return etype;
}

M
Marcin Slusarz 已提交
1925 1926
int8_t udf_current_aext(struct inode *inode, struct extent_position *epos,
			kernel_lb_addr *eloc, uint32_t *elen, int inc)
L
Linus Torvalds 已提交
1927 1928 1929 1930
{
	int alen;
	int8_t etype;
	uint8_t *ptr;
1931 1932
	short_ad *sad;
	long_ad *lad;
1933
	struct udf_inode_info *iinfo = UDF_I(inode);
1934

1935
	if (!epos->bh) {
J
Jan Kara 已提交
1936 1937
		if (!epos->offset)
			epos->offset = udf_file_entry_alloc_offset(inode);
1938
		ptr = iinfo->i_ext.i_data + epos->offset -
M
Marcin Slusarz 已提交
1939
			udf_file_entry_alloc_offset(inode) +
1940
			iinfo->i_lenEAttr;
M
Marcin Slusarz 已提交
1941
		alen = udf_file_entry_alloc_offset(inode) +
1942
							iinfo->i_lenAlloc;
1943
	} else {
J
Jan Kara 已提交
1944 1945 1946
		if (!epos->offset)
			epos->offset = sizeof(struct allocExtDesc);
		ptr = epos->bh->b_data + epos->offset;
1947
		alen = sizeof(struct allocExtDesc) +
M
Marcin Slusarz 已提交
1948 1949
			le32_to_cpu(((struct allocExtDesc *)epos->bh->b_data)->
							lengthAllocDescs);
L
Linus Torvalds 已提交
1950 1951
	}

1952
	switch (iinfo->i_alloc_type) {
1953
	case ICBTAG_FLAG_AD_SHORT:
M
Marcin Slusarz 已提交
1954 1955
		sad = udf_get_fileshortad(ptr, alen, &epos->offset, inc);
		if (!sad)
1956 1957 1958
			return -1;
		etype = le32_to_cpu(sad->extLength) >> 30;
		eloc->logicalBlockNum = le32_to_cpu(sad->extPosition);
M
Marcin Slusarz 已提交
1959
		eloc->partitionReferenceNum =
1960
				iinfo->i_location.partitionReferenceNum;
1961 1962
		*elen = le32_to_cpu(sad->extLength) & UDF_EXTENT_LENGTH_MASK;
		break;
1963
	case ICBTAG_FLAG_AD_LONG:
M
Marcin Slusarz 已提交
1964 1965
		lad = udf_get_filelongad(ptr, alen, &epos->offset, inc);
		if (!lad)
L
Linus Torvalds 已提交
1966
			return -1;
1967 1968 1969 1970 1971
		etype = le32_to_cpu(lad->extLength) >> 30;
		*eloc = lelb_to_cpu(lad->extLocation);
		*elen = le32_to_cpu(lad->extLength) & UDF_EXTENT_LENGTH_MASK;
		break;
	default:
M
Marcin Slusarz 已提交
1972
		udf_debug("alloc_type = %d unsupported\n",
1973
				iinfo->i_alloc_type);
1974
		return -1;
L
Linus Torvalds 已提交
1975 1976 1977 1978 1979
	}

	return etype;
}

1980 1981
static int8_t udf_insert_aext(struct inode *inode, struct extent_position epos,
			      kernel_lb_addr neloc, uint32_t nelen)
L
Linus Torvalds 已提交
1982 1983 1984 1985 1986
{
	kernel_lb_addr oeloc;
	uint32_t oelen;
	int8_t etype;

J
Jan Kara 已提交
1987
	if (epos.bh)
J
Jan Kara 已提交
1988
		get_bh(epos.bh);
L
Linus Torvalds 已提交
1989

1990
	while ((etype = udf_next_aext(inode, &epos, &oeloc, &oelen, 0)) != -1) {
J
Jan Kara 已提交
1991
		udf_write_aext(inode, &epos, neloc, nelen, 1);
L
Linus Torvalds 已提交
1992 1993 1994
		neloc = oeloc;
		nelen = (etype << 30) | oelen;
	}
J
Jan Kara 已提交
1995
	udf_add_aext(inode, &epos, neloc, nelen, 1);
J
Jan Kara 已提交
1996
	brelse(epos.bh);
1997

L
Linus Torvalds 已提交
1998 1999 2000
	return (nelen >> 30);
}

M
Marcin Slusarz 已提交
2001
int8_t udf_delete_aext(struct inode *inode, struct extent_position epos,
2002
		       kernel_lb_addr eloc, uint32_t elen)
L
Linus Torvalds 已提交
2003
{
J
Jan Kara 已提交
2004 2005
	struct extent_position oepos;
	int adsize;
L
Linus Torvalds 已提交
2006 2007
	int8_t etype;
	struct allocExtDesc *aed;
2008
	struct udf_inode_info *iinfo;
L
Linus Torvalds 已提交
2009

2010
	if (epos.bh) {
J
Jan Kara 已提交
2011 2012
		get_bh(epos.bh);
		get_bh(epos.bh);
L
Linus Torvalds 已提交
2013 2014
	}

2015 2016
	iinfo = UDF_I(inode);
	if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
L
Linus Torvalds 已提交
2017
		adsize = sizeof(short_ad);
2018
	else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
L
Linus Torvalds 已提交
2019 2020 2021 2022
		adsize = sizeof(long_ad);
	else
		adsize = 0;

J
Jan Kara 已提交
2023 2024
	oepos = epos;
	if (udf_next_aext(inode, &epos, &eloc, &elen, 1) == -1)
L
Linus Torvalds 已提交
2025 2026
		return -1;

2027
	while ((etype = udf_next_aext(inode, &epos, &eloc, &elen, 1)) != -1) {
J
Jan Kara 已提交
2028
		udf_write_aext(inode, &oepos, eloc, (etype << 30) | elen, 1);
2029
		if (oepos.bh != epos.bh) {
J
Jan Kara 已提交
2030
			oepos.block = epos.block;
J
Jan Kara 已提交
2031 2032
			brelse(oepos.bh);
			get_bh(epos.bh);
J
Jan Kara 已提交
2033 2034
			oepos.bh = epos.bh;
			oepos.offset = epos.offset - adsize;
L
Linus Torvalds 已提交
2035 2036 2037 2038 2039
		}
	}
	memset(&eloc, 0x00, sizeof(kernel_lb_addr));
	elen = 0;

2040
	if (epos.bh != oepos.bh) {
J
Jan Kara 已提交
2041 2042 2043
		udf_free_blocks(inode->i_sb, inode, epos.block, 0, 1);
		udf_write_aext(inode, &oepos, eloc, elen, 1);
		udf_write_aext(inode, &oepos, eloc, elen, 1);
2044
		if (!oepos.bh) {
2045
			iinfo->i_lenAlloc -= (adsize * 2);
L
Linus Torvalds 已提交
2046
			mark_inode_dirty(inode);
2047
		} else {
J
Jan Kara 已提交
2048
			aed = (struct allocExtDesc *)oepos.bh->b_data;
L
Linus Torvalds 已提交
2049
			aed->lengthAllocDescs =
M
Marcin Slusarz 已提交
2050 2051
				cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) -
					    (2 * adsize));
2052
			if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) ||
M
Marcin Slusarz 已提交
2053
			    UDF_SB(inode->i_sb)->s_udfrev >= 0x0201)
M
Marcin Slusarz 已提交
2054 2055
				udf_update_tag(oepos.bh->b_data,
						oepos.offset - (2 * adsize));
L
Linus Torvalds 已提交
2056
			else
M
Marcin Slusarz 已提交
2057 2058
				udf_update_tag(oepos.bh->b_data,
						sizeof(struct allocExtDesc));
J
Jan Kara 已提交
2059
			mark_buffer_dirty_inode(oepos.bh, inode);
L
Linus Torvalds 已提交
2060
		}
2061
	} else {
J
Jan Kara 已提交
2062
		udf_write_aext(inode, &oepos, eloc, elen, 1);
2063
		if (!oepos.bh) {
2064
			iinfo->i_lenAlloc -= adsize;
L
Linus Torvalds 已提交
2065
			mark_inode_dirty(inode);
2066
		} else {
J
Jan Kara 已提交
2067
			aed = (struct allocExtDesc *)oepos.bh->b_data;
L
Linus Torvalds 已提交
2068
			aed->lengthAllocDescs =
M
Marcin Slusarz 已提交
2069 2070
				cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) -
					    adsize);
2071
			if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) ||
M
Marcin Slusarz 已提交
2072
			    UDF_SB(inode->i_sb)->s_udfrev >= 0x0201)
M
Marcin Slusarz 已提交
2073 2074
				udf_update_tag(oepos.bh->b_data,
						epos.offset - adsize);
L
Linus Torvalds 已提交
2075
			else
M
Marcin Slusarz 已提交
2076 2077
				udf_update_tag(oepos.bh->b_data,
						sizeof(struct allocExtDesc));
J
Jan Kara 已提交
2078
			mark_buffer_dirty_inode(oepos.bh, inode);
L
Linus Torvalds 已提交
2079 2080
		}
	}
2081

J
Jan Kara 已提交
2082 2083
	brelse(epos.bh);
	brelse(oepos.bh);
2084

L
Linus Torvalds 已提交
2085 2086 2087
	return (elen >> 30);
}

M
Marcin Slusarz 已提交
2088 2089 2090
int8_t inode_bmap(struct inode *inode, sector_t block,
		  struct extent_position *pos, kernel_lb_addr *eloc,
		  uint32_t *elen, sector_t *offset)
L
Linus Torvalds 已提交
2091
{
M
Marcin Slusarz 已提交
2092
	unsigned char blocksize_bits = inode->i_sb->s_blocksize_bits;
2093
	loff_t lbcount = 0, bcount =
M
Marcin Slusarz 已提交
2094
	    (loff_t) block << blocksize_bits;
L
Linus Torvalds 已提交
2095
	int8_t etype;
2096
	struct udf_inode_info *iinfo;
L
Linus Torvalds 已提交
2097

2098
	if (block < 0) {
L
Linus Torvalds 已提交
2099 2100 2101 2102
		printk(KERN_ERR "udf: inode_bmap: block < 0\n");
		return -1;
	}

2103
	iinfo = UDF_I(inode);
J
Jan Kara 已提交
2104
	pos->offset = 0;
2105
	pos->block = iinfo->i_location;
J
Jan Kara 已提交
2106
	pos->bh = NULL;
L
Linus Torvalds 已提交
2107 2108
	*elen = 0;

2109
	do {
M
Marcin Slusarz 已提交
2110 2111 2112
		etype = udf_next_aext(inode, pos, eloc, elen, 1);
		if (etype == -1) {
			*offset = (bcount - lbcount) >> blocksize_bits;
2113
			iinfo->i_lenExtents = lbcount;
L
Linus Torvalds 已提交
2114 2115 2116 2117 2118
			return -1;
		}
		lbcount += *elen;
	} while (lbcount <= bcount);

M
Marcin Slusarz 已提交
2119
	*offset = (bcount + *elen - lbcount) >> blocksize_bits;
L
Linus Torvalds 已提交
2120 2121 2122 2123

	return etype;
}

2124
long udf_block_map(struct inode *inode, sector_t block)
L
Linus Torvalds 已提交
2125
{
J
Jan Kara 已提交
2126 2127
	kernel_lb_addr eloc;
	uint32_t elen;
2128
	sector_t offset;
2129
	struct extent_position epos = {};
L
Linus Torvalds 已提交
2130 2131 2132 2133
	int ret;

	lock_kernel();

M
Marcin Slusarz 已提交
2134 2135
	if (inode_bmap(inode, block, &epos, &eloc, &elen, &offset) ==
						(EXT_RECORDED_ALLOCATED >> 30))
2136
		ret = udf_get_lb_pblock(inode->i_sb, eloc, offset);
L
Linus Torvalds 已提交
2137 2138 2139 2140
	else
		ret = 0;

	unlock_kernel();
J
Jan Kara 已提交
2141
	brelse(epos.bh);
L
Linus Torvalds 已提交
2142 2143 2144 2145 2146 2147

	if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_VARCONV))
		return udf_fixed_to_variable(ret);
	else
		return ret;
}