inode.c 61.0 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
 *  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/module.h>
#include <linux/pagemap.h>
#include <linux/buffer_head.h>
#include <linux/writeback.h>
#include <linux/slab.h>
39
#include <linux/crc-itu-t.h>
N
Namjae Jeon 已提交
40
#include <linux/mpage.h>
L
Linus Torvalds 已提交
41 42 43 44 45 46 47 48 49 50 51 52 53

#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 *);
J
Jan Kara 已提交
54
static int udf_sync_inode(struct inode *inode);
55
static int udf_alloc_i_data(struct inode *inode, size_t size);
56
static struct buffer_head *inode_getblk(struct inode *, sector_t, int *,
57
					sector_t *, int *);
J
Jan Kara 已提交
58
static int8_t udf_insert_aext(struct inode *, struct extent_position,
59
			      struct kernel_lb_addr, uint32_t);
L
Linus Torvalds 已提交
60
static void udf_split_extents(struct inode *, int *, int, int,
61
			      struct kernel_long_ad[EXTENT_MERGE_SIZE], int *);
L
Linus Torvalds 已提交
62
static void udf_prealloc_extents(struct inode *, int, int,
63
				 struct kernel_long_ad[EXTENT_MERGE_SIZE], int *);
L
Linus Torvalds 已提交
64
static void udf_merge_extents(struct inode *,
65
			      struct kernel_long_ad[EXTENT_MERGE_SIZE], int *);
L
Linus Torvalds 已提交
66
static void udf_update_extents(struct inode *,
67
			       struct kernel_long_ad[EXTENT_MERGE_SIZE], int, int,
68
			       struct extent_position *);
L
Linus Torvalds 已提交
69 70
static int udf_get_block(struct inode *, sector_t, struct buffer_head *, int);

71

A
Al Viro 已提交
72
void udf_evict_inode(struct inode *inode)
L
Linus Torvalds 已提交
73
{
J
Jan Kara 已提交
74
	struct udf_inode_info *iinfo = UDF_I(inode);
A
Al Viro 已提交
75 76 77 78
	int want_delete = 0;

	if (!inode->i_nlink && !is_bad_inode(inode)) {
		want_delete = 1;
79
		udf_setsize(inode, 0);
A
Al Viro 已提交
80
		udf_update_inode(inode, IS_SYNC(inode));
81 82
	} else
		truncate_inode_pages(&inode->i_data, 0);
A
Al Viro 已提交
83 84
	invalidate_inode_buffers(inode);
	end_writeback(inode);
J
Jan Kara 已提交
85 86
	if (iinfo->i_alloc_type != ICBTAG_FLAG_AD_IN_ICB &&
	    inode->i_size != iinfo->i_lenExtents) {
J
Joe Perches 已提交
87 88 89 90
		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",
			 inode->i_ino, inode->i_mode,
			 (unsigned long long)inode->i_size,
			 (unsigned long long)iinfo->i_lenExtents);
L
Linus Torvalds 已提交
91
	}
92 93
	kfree(iinfo->i_ext.i_data);
	iinfo->i_ext.i_data = NULL;
A
Al Viro 已提交
94 95 96
	if (want_delete) {
		udf_free_inode(inode);
	}
L
Linus Torvalds 已提交
97 98 99 100 101 102 103 104 105
}

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)
{
N
Namjae Jeon 已提交
106 107 108 109 110 111 112
	return mpage_readpage(page, udf_get_block);
}

static int udf_readpages(struct file *file, struct address_space *mapping,
			struct list_head *pages, unsigned nr_pages)
{
	return mpage_readpages(mapping, pages, nr_pages, udf_get_block);
L
Linus Torvalds 已提交
113 114
}

N
Nick Piggin 已提交
115 116 117
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 已提交
118
{
119 120 121 122
	int ret;

	ret = block_write_begin(mapping, pos, len, flags, pagep, udf_get_block);
	if (unlikely(ret)) {
123 124 125 126 127 128 129 130 131 132 133 134
		struct inode *inode = mapping->host;
		struct udf_inode_info *iinfo = UDF_I(inode);
		loff_t isize = inode->i_size;

		if (pos + len > isize) {
			truncate_pagecache(inode, pos + len, isize);
			if (iinfo->i_alloc_type != ICBTAG_FLAG_AD_IN_ICB) {
				down_write(&iinfo->i_data_sem);
				udf_truncate_extents(inode);
				up_write(&iinfo->i_data_sem);
			}
		}
135 136 137
	}

	return ret;
L
Linus Torvalds 已提交
138 139 140 141
}

static sector_t udf_bmap(struct address_space *mapping, sector_t block)
{
142
	return generic_block_bmap(mapping, block, udf_get_block);
L
Linus Torvalds 已提交
143 144
}

145
const struct address_space_operations udf_aops = {
146
	.readpage	= udf_readpage,
N
Namjae Jeon 已提交
147
	.readpages	= udf_readpages,
148
	.writepage	= udf_writepage,
N
Nick Piggin 已提交
149 150
	.write_begin		= udf_write_begin,
	.write_end		= generic_write_end,
151
	.bmap		= udf_bmap,
L
Linus Torvalds 已提交
152 153
};

154
int udf_expand_file_adinicb(struct inode *inode)
L
Linus Torvalds 已提交
155 156 157
{
	struct page *page;
	char *kaddr;
158
	struct udf_inode_info *iinfo = UDF_I(inode);
159
	int err;
L
Linus Torvalds 已提交
160 161 162 163 164
	struct writeback_control udf_wbc = {
		.sync_mode = WB_SYNC_NONE,
		.nr_to_write = 1,
	};

165
	if (!iinfo->i_lenAlloc) {
L
Linus Torvalds 已提交
166
		if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_SHORT_AD))
167
			iinfo->i_alloc_type = ICBTAG_FLAG_AD_SHORT;
L
Linus Torvalds 已提交
168
		else
169
			iinfo->i_alloc_type = ICBTAG_FLAG_AD_LONG;
170 171
		/* from now on we have normal address_space methods */
		inode->i_data.a_ops = &udf_aops;
L
Linus Torvalds 已提交
172
		mark_inode_dirty(inode);
173
		return 0;
L
Linus Torvalds 已提交
174 175
	}

176 177 178
	page = find_or_create_page(inode->i_mapping, 0, GFP_NOFS);
	if (!page)
		return -ENOMEM;
M
Matt Mackall 已提交
179

180
	if (!PageUptodate(page)) {
L
Linus Torvalds 已提交
181
		kaddr = kmap(page);
182 183 184 185
		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 已提交
186 187 188 189
		flush_dcache_page(page);
		SetPageUptodate(page);
		kunmap(page);
	}
190 191 192
	memset(iinfo->i_ext.i_data + iinfo->i_lenEAttr, 0x00,
	       iinfo->i_lenAlloc);
	iinfo->i_lenAlloc = 0;
L
Linus Torvalds 已提交
193
	if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_SHORT_AD))
194
		iinfo->i_alloc_type = ICBTAG_FLAG_AD_SHORT;
L
Linus Torvalds 已提交
195
	else
196
		iinfo->i_alloc_type = ICBTAG_FLAG_AD_LONG;
197 198 199 200 201 202 203 204 205 206 207 208 209 210
	/* from now on we have normal address_space methods */
	inode->i_data.a_ops = &udf_aops;
	err = inode->i_data.a_ops->writepage(page, &udf_wbc);
	if (err) {
		/* Restore everything back so that we don't lose data... */
		lock_page(page);
		kaddr = kmap(page);
		memcpy(iinfo->i_ext.i_data + iinfo->i_lenEAttr, kaddr,
		       inode->i_size);
		kunmap(page);
		unlock_page(page);
		iinfo->i_alloc_type = ICBTAG_FLAG_AD_IN_ICB;
		inode->i_data.a_ops = &udf_adinicb_aops;
	}
L
Linus Torvalds 已提交
211 212
	page_cache_release(page);
	mark_inode_dirty(inode);
213 214

	return err;
L
Linus Torvalds 已提交
215 216
}

217 218
struct buffer_head *udf_expand_dir_adinicb(struct inode *inode, int *block,
					   int *err)
L
Linus Torvalds 已提交
219 220
{
	int newblock;
J
Jan Kara 已提交
221
	struct buffer_head *dbh = NULL;
222
	struct kernel_lb_addr eloc;
L
Linus Torvalds 已提交
223
	uint8_t alloctype;
J
Jan Kara 已提交
224
	struct extent_position epos;
L
Linus Torvalds 已提交
225 226

	struct udf_fileident_bh sfibh, dfibh;
227 228
	loff_t f_pos = udf_ext0_offset(inode);
	int size = udf_ext0_offset(inode) + inode->i_size;
L
Linus Torvalds 已提交
229
	struct fileIdentDesc cfi, *sfi, *dfi;
230
	struct udf_inode_info *iinfo = UDF_I(inode);
L
Linus Torvalds 已提交
231 232 233 234 235 236

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

237
	if (!inode->i_size) {
238
		iinfo->i_alloc_type = alloctype;
L
Linus Torvalds 已提交
239 240 241 242 243 244
		mark_inode_dirty(inode);
		return NULL;
	}

	/* alloc block, and copy data to it */
	*block = udf_new_block(inode->i_sb, inode,
245 246
			       iinfo->i_location.partitionReferenceNum,
			       iinfo->i_location.logicalBlockNum, err);
L
Linus Torvalds 已提交
247 248 249
	if (!(*block))
		return NULL;
	newblock = udf_get_pblock(inode->i_sb, *block,
250
				  iinfo->i_location.partitionReferenceNum,
251
				0);
L
Linus Torvalds 已提交
252 253 254 255 256 257 258 259 260 261 262
	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 已提交
263
	sfibh.soffset = sfibh.eoffset =
264
			f_pos & (inode->i_sb->s_blocksize - 1);
J
Jan Kara 已提交
265
	sfibh.sbh = sfibh.ebh = NULL;
L
Linus Torvalds 已提交
266 267
	dfibh.soffset = dfibh.eoffset = 0;
	dfibh.sbh = dfibh.ebh = dbh;
268
	while (f_pos < size) {
269
		iinfo->i_alloc_type = ICBTAG_FLAG_AD_IN_ICB;
M
Marcin Slusarz 已提交
270 271
		sfi = udf_fileident_read(inode, &f_pos, &sfibh, &cfi, NULL,
					 NULL, NULL, NULL);
272
		if (!sfi) {
J
Jan Kara 已提交
273
			brelse(dbh);
L
Linus Torvalds 已提交
274 275
			return NULL;
		}
276
		iinfo->i_alloc_type = alloctype;
L
Linus Torvalds 已提交
277 278 279 280 281
		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 已提交
282 283
				 sfi->fileIdent +
					le16_to_cpu(sfi->lengthOfImpUse))) {
284
			iinfo->i_alloc_type = ICBTAG_FLAG_AD_IN_ICB;
J
Jan Kara 已提交
285
			brelse(dbh);
L
Linus Torvalds 已提交
286 287 288 289 290
			return NULL;
		}
	}
	mark_buffer_dirty_inode(dbh, inode);

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

J
Jan Kara 已提交
304
	brelse(epos.bh);
L
Linus Torvalds 已提交
305 306 307 308
	mark_inode_dirty(inode);
	return dbh;
}

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

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

	err = -EIO;
	new = 0;
	bh = NULL;
327
	iinfo = UDF_I(inode);
328 329

	down_write(&iinfo->i_data_sem);
330 331 332
	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:
348
	up_write(&iinfo->i_data_sem);
L
Linus Torvalds 已提交
349 350 351
	return err;
}

352 353
static struct buffer_head *udf_getblk(struct inode *inode, long block,
				      int create, int *err)
L
Linus Torvalds 已提交
354
{
355
	struct buffer_head *bh;
L
Linus Torvalds 已提交
356 357 358 359 360
	struct buffer_head dummy;

	dummy.b_state = 0;
	dummy.b_blocknr = -1000;
	*err = udf_get_block(inode, block, &dummy, create);
361
	if (!*err && buffer_mapped(&dummy)) {
L
Linus Torvalds 已提交
362
		bh = sb_getblk(inode->i_sb, dummy.b_blocknr);
363
		if (buffer_new(&dummy)) {
L
Linus Torvalds 已提交
364 365 366 367 368 369 370 371
			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;
	}
372

L
Linus Torvalds 已提交
373 374 375
	return NULL;
}

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

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

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

J
Jan Kara 已提交
407
	/* Last extent are just preallocated blocks? */
M
Marcin Slusarz 已提交
408 409
	if ((last_ext->extLength & UDF_EXTENT_FLAG_MASK) ==
						EXT_NOT_RECORDED_ALLOCATED) {
J
Jan Kara 已提交
410 411 412 413 414
		/* 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 |
415
			(last_ext->extLength & UDF_EXTENT_LENGTH_MASK);
J
Jan Kara 已提交
416
		last_ext->extLocation.logicalBlockNum = 0;
M
Marcin Slusarz 已提交
417
		last_ext->extLocation.partitionReferenceNum = 0;
J
Jan Kara 已提交
418
	}
419

J
Jan Kara 已提交
420
	/* Can we merge with the previous extent? */
M
Marcin Slusarz 已提交
421 422 423 424 425
	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 已提交
426 427 428 429 430 431 432
		if (add > blocks)
			add = blocks;
		blocks -= add;
		last_ext->extLength += add << sb->s_blocksize_bits;
	}

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

J
Jan Kara 已提交
440 441 442 443 444 445
	/* 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 已提交
446
	last_ext->extLocation.partitionReferenceNum = 0;
447
	add = (1 << (30-sb->s_blocksize_bits)) - 1;
M
Marcin Slusarz 已提交
448 449
	last_ext->extLength = EXT_NOT_RECORDED_NOT_ALLOCATED |
				(add << sb->s_blocksize_bits);
450

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

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

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

J
Jan Kara 已提交
490 491 492
	return count;
}

493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549
static int udf_extend_file(struct inode *inode, loff_t newsize)
{

	struct extent_position epos;
	struct kernel_lb_addr eloc;
	uint32_t elen;
	int8_t etype;
	struct super_block *sb = inode->i_sb;
	sector_t first_block = newsize >> sb->s_blocksize_bits, offset;
	int adsize;
	struct udf_inode_info *iinfo = UDF_I(inode);
	struct kernel_long_ad extent;
	int err;

	if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
		adsize = sizeof(struct short_ad);
	else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
		adsize = sizeof(struct long_ad);
	else
		BUG();

	etype = inode_bmap(inode, first_block, &epos, &eloc, &elen, &offset);

	/* File has extent covering the new size (could happen when extending
	 * inside a block)? */
	if (etype != -1)
		return 0;
	if (newsize & (sb->s_blocksize - 1))
		offset++;
	/* Extended file just to the boundary of the last file block? */
	if (offset == 0)
		return 0;

	/* Truncate is extending the file by 'offset' blocks */
	if ((!epos.bh && epos.offset == udf_file_entry_alloc_offset(inode)) ||
	    (epos.bh && epos.offset == sizeof(struct allocExtDesc))) {
		/* File has no extents at all or has empty last
		 * indirect extent! Create a fake extent... */
		extent.extLocation.logicalBlockNum = 0;
		extent.extLocation.partitionReferenceNum = 0;
		extent.extLength = EXT_NOT_RECORDED_NOT_ALLOCATED;
	} else {
		epos.offset -= adsize;
		etype = udf_next_aext(inode, &epos, &extent.extLocation,
				      &extent.extLength, 0);
		extent.extLength |= etype << 30;
	}
	err = udf_do_extend_file(inode, &epos, &extent, offset);
	if (err < 0)
		goto out;
	err = 0;
	iinfo->i_lenExtents = newsize;
out:
	brelse(epos.bh);
	return err;
}

550
static struct buffer_head *inode_getblk(struct inode *inode, sector_t block,
551
					int *err, sector_t *phys, int *new)
L
Linus Torvalds 已提交
552
{
J
Jan Kara 已提交
553
	static sector_t last_block;
J
Jan Kara 已提交
554
	struct buffer_head *result = NULL;
555
	struct kernel_long_ad laarr[EXTENT_MERGE_SIZE];
J
Jan Kara 已提交
556
	struct extent_position prev_epos, cur_epos, next_epos;
L
Linus Torvalds 已提交
557
	int count = 0, startnum = 0, endnum = 0;
J
Jan Kara 已提交
558
	uint32_t elen = 0, tmpelen;
559
	struct kernel_lb_addr eloc, tmpeloc;
L
Linus Torvalds 已提交
560
	int c = 1;
561 562 563
	loff_t lbcount = 0, b_off = 0;
	uint32_t newblocknum, newblock;
	sector_t offset = 0;
L
Linus Torvalds 已提交
564
	int8_t etype;
565 566
	struct udf_inode_info *iinfo = UDF_I(inode);
	int goal = 0, pgoal = iinfo->i_location.logicalBlockNum;
J
Jan Kara 已提交
567
	int lastblock = 0;
L
Linus Torvalds 已提交
568

J
Jan Kara 已提交
569
	prev_epos.offset = udf_file_entry_alloc_offset(inode);
570
	prev_epos.block = iinfo->i_location;
J
Jan Kara 已提交
571 572
	prev_epos.bh = NULL;
	cur_epos = next_epos = prev_epos;
573
	b_off = (loff_t)block << inode->i_sb->s_blocksize_bits;
L
Linus Torvalds 已提交
574 575

	/* find the extent which contains the block we are looking for.
576 577 578 579
	   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 已提交
580 581
			brelse(prev_epos.bh);
			get_bh(cur_epos.bh);
J
Jan Kara 已提交
582
			prev_epos.bh = cur_epos.bh;
L
Linus Torvalds 已提交
583
		}
584
		if (cur_epos.bh != next_epos.bh) {
J
Jan Kara 已提交
585 586
			brelse(cur_epos.bh);
			get_bh(next_epos.bh);
J
Jan Kara 已提交
587
			cur_epos.bh = next_epos.bh;
L
Linus Torvalds 已提交
588 589 590 591
		}

		lbcount += elen;

J
Jan Kara 已提交
592 593
		prev_epos.block = cur_epos.block;
		cur_epos.block = next_epos.block;
L
Linus Torvalds 已提交
594

J
Jan Kara 已提交
595 596
		prev_epos.offset = cur_epos.offset;
		cur_epos.offset = next_epos.offset;
L
Linus Torvalds 已提交
597

M
Marcin Slusarz 已提交
598 599
		etype = udf_next_aext(inode, &next_epos, &eloc, &elen, 1);
		if (etype == -1)
L
Linus Torvalds 已提交
600 601 602 603 604 605 606 607 608
			break;

		c = !c;

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

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

612
		count++;
L
Linus Torvalds 已提交
613 614 615 616
	} while (lbcount + elen <= b_off);

	b_off -= lbcount;
	offset = b_off >> inode->i_sb->s_blocksize_bits;
J
Jan Kara 已提交
617 618 619 620 621 622
	/*
	 * 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 已提交
623 624

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

627 628
	if (etype == (EXT_RECORDED_ALLOCATED >> 30)) {
		if (elen & (inode->i_sb->s_blocksize - 1)) {
L
Linus Torvalds 已提交
629
			elen = EXT_RECORDED_ALLOCATED |
630 631
				((elen + inode->i_sb->s_blocksize - 1) &
				 ~(inode->i_sb->s_blocksize - 1));
632
			udf_write_aext(inode, &cur_epos, &eloc, elen, 1);
L
Linus Torvalds 已提交
633
		}
J
Jan Kara 已提交
634 635 636
		brelse(prev_epos.bh);
		brelse(cur_epos.bh);
		brelse(next_epos.bh);
637
		newblock = udf_get_lb_pblock(inode->i_sb, &eloc, offset);
L
Linus Torvalds 已提交
638 639 640 641
		*phys = newblock;
		return NULL;
	}

J
Jan Kara 已提交
642 643
	last_block = block;
	/* Are we beyond EOF? */
644
	if (etype == -1) {
J
Jan Kara 已提交
645 646 647 648 649 650
		int ret;

		if (count) {
			if (c)
				laarr[0] = laarr[1];
			startnum = 1;
651
		} else {
J
Jan Kara 已提交
652
			/* Create a fake extent when there's not one */
M
Marcin Slusarz 已提交
653
			memset(&laarr[0].extLocation, 0x00,
654
				sizeof(struct kernel_lb_addr));
J
Jan Kara 已提交
655
			laarr[0].extLength = EXT_NOT_RECORDED_NOT_ALLOCATED;
656
			/* Will udf_do_extend_file() create real extent from
M
Marcin Slusarz 已提交
657
			   a fake one? */
J
Jan Kara 已提交
658 659 660
			startnum = (offset > 0);
		}
		/* Create extents for the hole between EOF and offset */
661 662
		ret = udf_do_extend_file(inode, &prev_epos, laarr, offset);
		if (ret < 0) {
J
Jan Kara 已提交
663 664 665
			brelse(prev_epos.bh);
			brelse(cur_epos.bh);
			brelse(next_epos.bh);
666
			*err = ret;
J
Jan Kara 已提交
667 668 669 670 671 672
			return NULL;
		}
		c = 0;
		offset = 0;
		count += ret;
		/* We are not covered by a preallocated extent? */
M
Marcin Slusarz 已提交
673 674
		if ((laarr[0].extLength & UDF_EXTENT_FLAG_MASK) !=
						EXT_NOT_RECORDED_ALLOCATED) {
J
Jan Kara 已提交
675 676 677 678 679
			/* Is there any real extent? - otherwise we overwrite
			 * the fake one... */
			if (count)
				c = !c;
			laarr[c].extLength = EXT_NOT_RECORDED_NOT_ALLOCATED |
680
				inode->i_sb->s_blocksize;
M
Marcin Slusarz 已提交
681
			memset(&laarr[c].extLocation, 0x00,
682
				sizeof(struct kernel_lb_addr));
683 684
			count++;
			endnum++;
J
Jan Kara 已提交
685
		}
686
		endnum = c + 1;
L
Linus Torvalds 已提交
687
		lastblock = 1;
688
	} else {
L
Linus Torvalds 已提交
689 690
		endnum = startnum = ((count > 2) ? 2 : count);

M
Marcin Slusarz 已提交
691 692
		/* if the current extent is in position 0,
		   swap it with the previous */
693
		if (!c && count != 1) {
J
Jan Kara 已提交
694 695 696 697 698
			laarr[2] = laarr[0];
			laarr[0] = laarr[1];
			laarr[1] = laarr[2];
			c = 1;
		}
L
Linus Torvalds 已提交
699

M
Marcin Slusarz 已提交
700 701 702 703
		/* 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) {
704 705 706 707 708
			laarr[c + 1].extLength = (etype << 30) | elen;
			laarr[c + 1].extLocation = eloc;
			count++;
			startnum++;
			endnum++;
M
Marcin Slusarz 已提交
709
		} else
L
Linus Torvalds 已提交
710 711 712 713
			lastblock = 1;
	}

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

721
		if (!goal) {
M
Marcin Slusarz 已提交
722
			if (!(goal = pgoal)) /* XXX: what was intended here? */
723
				goal = iinfo->i_location.logicalBlockNum + 1;
L
Linus Torvalds 已提交
724 725
		}

M
Marcin Slusarz 已提交
726
		newblocknum = udf_new_block(inode->i_sb, inode,
727
				iinfo->i_location.partitionReferenceNum,
M
Marcin Slusarz 已提交
728 729
				goal, err);
		if (!newblocknum) {
J
Jan Kara 已提交
730
			brelse(prev_epos.bh);
L
Linus Torvalds 已提交
731 732 733
			*err = -ENOSPC;
			return NULL;
		}
734
		iinfo->i_lenExtents += inode->i_sb->s_blocksize;
L
Linus Torvalds 已提交
735 736
	}

M
Marcin Slusarz 已提交
737 738 739 740
	/* 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 已提交
741 742 743
	udf_split_extents(inode, &c, offset, newblocknum, laarr, &endnum);

#ifdef UDF_PREALLOCATE
744 745 746 747 748 749
	/* We preallocate blocks only for regular files. It also makes sense
	 * for directories but there's a problem when to drop the
	 * preallocation. We might use some delayed work for that but I feel
	 * it's overengineering for a filesystem like UDF. */
	if (S_ISREG(inode->i_mode))
		udf_prealloc_extents(inode, c, lastblock, laarr, &endnum);
L
Linus Torvalds 已提交
750 751 752 753 754 755
#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
756 757
	 * 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 已提交
758
	udf_update_extents(inode, laarr, startnum, endnum, &prev_epos);
L
Linus Torvalds 已提交
759

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

M
Marcin Slusarz 已提交
762
	newblock = udf_get_pblock(inode->i_sb, newblocknum,
763
				iinfo->i_location.partitionReferenceNum, 0);
M
Marcin Slusarz 已提交
764
	if (!newblock)
L
Linus Torvalds 已提交
765 766 767 768
		return NULL;
	*phys = newblock;
	*err = 0;
	*new = 1;
769 770
	iinfo->i_next_alloc_block = block;
	iinfo->i_next_alloc_goal = newblocknum;
L
Linus Torvalds 已提交
771 772 773 774 775 776
	inode->i_ctime = current_fs_time(inode->i_sb);

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

L
Linus Torvalds 已提交
778 779 780
	return result;
}

781 782
static void udf_split_extents(struct inode *inode, int *c, int offset,
			      int newblocknum,
783
			      struct kernel_long_ad laarr[EXTENT_MERGE_SIZE],
784
			      int *endnum)
L
Linus Torvalds 已提交
785
{
M
Marcin Slusarz 已提交
786 787 788
	unsigned long blocksize = inode->i_sb->s_blocksize;
	unsigned char blocksize_bits = inode->i_sb->s_blocksize_bits;

L
Linus Torvalds 已提交
789
	if ((laarr[*c].extLength >> 30) == (EXT_NOT_RECORDED_ALLOCATED >> 30) ||
M
Marcin Slusarz 已提交
790 791
	    (laarr[*c].extLength >> 30) ==
				(EXT_NOT_RECORDED_NOT_ALLOCATED >> 30)) {
L
Linus Torvalds 已提交
792 793
		int curr = *c;
		int blen = ((laarr[curr].extLength & UDF_EXTENT_LENGTH_MASK) +
M
Marcin Slusarz 已提交
794
			    blocksize - 1) >> blocksize_bits;
L
Linus Torvalds 已提交
795 796
		int8_t etype = (laarr[curr].extLength >> 30);

M
Marcin Slusarz 已提交
797
		if (blen == 1)
798
			;
M
Marcin Slusarz 已提交
799
		else if (!offset || blen == offset + 1) {
800 801 802 803 804 805 806 807 808
			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 已提交
809
				udf_free_blocks(inode->i_sb, inode,
810
						&laarr[curr].extLocation,
M
Marcin Slusarz 已提交
811 812 813 814
						0, offset);
				laarr[curr].extLength =
					EXT_NOT_RECORDED_NOT_ALLOCATED |
					(offset << blocksize_bits);
L
Linus Torvalds 已提交
815
				laarr[curr].extLocation.logicalBlockNum = 0;
M
Marcin Slusarz 已提交
816 817 818
				laarr[curr].extLocation.
						partitionReferenceNum = 0;
			} else
L
Linus Torvalds 已提交
819
				laarr[curr].extLength = (etype << 30) |
M
Marcin Slusarz 已提交
820
					(offset << blocksize_bits);
821 822 823
			curr++;
			(*c)++;
			(*endnum)++;
L
Linus Torvalds 已提交
824
		}
825

L
Linus Torvalds 已提交
826 827 828
		laarr[curr].extLocation.logicalBlockNum = newblocknum;
		if (etype == (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30))
			laarr[curr].extLocation.partitionReferenceNum =
829
				UDF_I(inode)->i_location.partitionReferenceNum;
L
Linus Torvalds 已提交
830
		laarr[curr].extLength = EXT_RECORDED_ALLOCATED |
M
Marcin Slusarz 已提交
831
			blocksize;
832
		curr++;
L
Linus Torvalds 已提交
833

834
		if (blen != offset + 1) {
L
Linus Torvalds 已提交
835
			if (etype == (EXT_NOT_RECORDED_ALLOCATED >> 30))
M
Marcin Slusarz 已提交
836 837
				laarr[curr].extLocation.logicalBlockNum +=
								offset + 1;
838
			laarr[curr].extLength = (etype << 30) |
M
Marcin Slusarz 已提交
839
				((blen - (offset + 1)) << blocksize_bits);
840 841
			curr++;
			(*endnum)++;
L
Linus Torvalds 已提交
842 843 844 845 846
		}
	}
}

static void udf_prealloc_extents(struct inode *inode, int c, int lastblock,
847
				 struct kernel_long_ad laarr[EXTENT_MERGE_SIZE],
848
				 int *endnum)
L
Linus Torvalds 已提交
849 850 851
{
	int start, length = 0, currlength = 0, i;

852
	if (*endnum >= (c + 1)) {
L
Linus Torvalds 已提交
853 854 855 856
		if (!lastblock)
			return;
		else
			start = c;
857
	} else {
M
Marcin Slusarz 已提交
858 859
		if ((laarr[c + 1].extLength >> 30) ==
					(EXT_NOT_RECORDED_ALLOCATED >> 30)) {
860
			start = c + 1;
M
Marcin Slusarz 已提交
861 862 863 864 865 866
			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 已提交
867 868 869
			start = c;
	}

870 871
	for (i = start + 1; i <= *endnum; i++) {
		if (i == *endnum) {
L
Linus Torvalds 已提交
872 873
			if (lastblock)
				length += UDF_DEFAULT_PREALLOC_BLOCKS;
M
Marcin Slusarz 已提交
874 875 876 877 878 879 880
		} 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 已提交
881 882 883
			break;
	}

884
	if (length) {
L
Linus Torvalds 已提交
885
		int next = laarr[start].extLocation.logicalBlockNum +
886
			(((laarr[start].extLength & UDF_EXTENT_LENGTH_MASK) +
M
Marcin Slusarz 已提交
887 888
			  inode->i_sb->s_blocksize - 1) >>
			  inode->i_sb->s_blocksize_bits);
L
Linus Torvalds 已提交
889
		int numalloc = udf_prealloc_blocks(inode->i_sb, inode,
M
Marcin Slusarz 已提交
890 891 892 893
				laarr[start].extLocation.partitionReferenceNum,
				next, (UDF_DEFAULT_PREALLOC_BLOCKS > length ?
				length : UDF_DEFAULT_PREALLOC_BLOCKS) -
				currlength);
894
		if (numalloc) 	{
M
Marcin Slusarz 已提交
895
			if (start == (c + 1))
L
Linus Torvalds 已提交
896
				laarr[start].extLength +=
M
Marcin Slusarz 已提交
897 898 899
					(numalloc <<
					 inode->i_sb->s_blocksize_bits);
			else {
900
				memmove(&laarr[c + 2], &laarr[c + 1],
901
					sizeof(struct long_ad) * (*endnum - (c + 1)));
902 903 904
				(*endnum)++;
				laarr[c + 1].extLocation.logicalBlockNum = next;
				laarr[c + 1].extLocation.partitionReferenceNum =
M
Marcin Slusarz 已提交
905 906 907 908 909 910
					laarr[c].extLocation.
							partitionReferenceNum;
				laarr[c + 1].extLength =
					EXT_NOT_RECORDED_ALLOCATED |
					(numalloc <<
					 inode->i_sb->s_blocksize_bits);
911
				start = c + 1;
L
Linus Torvalds 已提交
912 913
			}

914
			for (i = start + 1; numalloc && i < *endnum; i++) {
M
Marcin Slusarz 已提交
915 916 917 918
				int elen = ((laarr[i].extLength &
						UDF_EXTENT_LENGTH_MASK) +
					    inode->i_sb->s_blocksize - 1) >>
					    inode->i_sb->s_blocksize_bits;
L
Linus Torvalds 已提交
919

920
				if (elen > numalloc) {
L
Linus Torvalds 已提交
921
					laarr[i].extLength -=
M
Marcin Slusarz 已提交
922 923
						(numalloc <<
						 inode->i_sb->s_blocksize_bits);
L
Linus Torvalds 已提交
924
					numalloc = 0;
925
				} else {
L
Linus Torvalds 已提交
926
					numalloc -= elen;
927
					if (*endnum > (i + 1))
M
Marcin Slusarz 已提交
928 929
						memmove(&laarr[i],
							&laarr[i + 1],
930
							sizeof(struct long_ad) *
M
Marcin Slusarz 已提交
931
							(*endnum - (i + 1)));
932 933
					i--;
					(*endnum)--;
L
Linus Torvalds 已提交
934 935
				}
			}
936
			UDF_I(inode)->i_lenExtents +=
M
Marcin Slusarz 已提交
937
				numalloc << inode->i_sb->s_blocksize_bits;
L
Linus Torvalds 已提交
938 939 940 941 942
		}
	}
}

static void udf_merge_extents(struct inode *inode,
943
			      struct kernel_long_ad laarr[EXTENT_MERGE_SIZE],
944
			      int *endnum)
L
Linus Torvalds 已提交
945 946
{
	int i;
M
Marcin Slusarz 已提交
947 948
	unsigned long blocksize = inode->i_sb->s_blocksize;
	unsigned char blocksize_bits = inode->i_sb->s_blocksize_bits;
L
Linus Torvalds 已提交
949

950
	for (i = 0; i < (*endnum - 1); i++) {
951 952
		struct kernel_long_ad *li /*l[i]*/ = &laarr[i];
		struct kernel_long_ad *lip1 /*l[i plus 1]*/ = &laarr[i + 1];
M
Marcin Slusarz 已提交
953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985

		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],
986
						sizeof(struct long_ad) *
M
Marcin Slusarz 已提交
987 988 989
						(*endnum - (i + 2)));
				i--;
				(*endnum)--;
L
Linus Torvalds 已提交
990
			}
M
Marcin Slusarz 已提交
991 992 993 994
		} else if (((li->extLength >> 30) ==
				(EXT_NOT_RECORDED_ALLOCATED >> 30)) &&
			   ((lip1->extLength >> 30) ==
				(EXT_NOT_RECORDED_NOT_ALLOCATED >> 30))) {
995
			udf_free_blocks(inode->i_sb, inode, &li->extLocation, 0,
M
Marcin Slusarz 已提交
996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013
					((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;
1014
			} else {
M
Marcin Slusarz 已提交
1015 1016 1017 1018
				li->extLength = lip1->extLength +
					(((li->extLength &
						UDF_EXTENT_LENGTH_MASK) +
					  blocksize - 1) & ~(blocksize - 1));
1019 1020
				if (*endnum > (i + 2))
					memmove(&laarr[i + 1], &laarr[i + 2],
1021
						sizeof(struct long_ad) *
M
Marcin Slusarz 已提交
1022
						(*endnum - (i + 2)));
1023 1024
				i--;
				(*endnum)--;
L
Linus Torvalds 已提交
1025
			}
M
Marcin Slusarz 已提交
1026 1027 1028
		} else if ((li->extLength >> 30) ==
					(EXT_NOT_RECORDED_ALLOCATED >> 30)) {
			udf_free_blocks(inode->i_sb, inode,
1029
					&li->extLocation, 0,
M
Marcin Slusarz 已提交
1030 1031 1032 1033 1034 1035 1036 1037
					((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 已提交
1038 1039 1040 1041 1042
		}
	}
}

static void udf_update_extents(struct inode *inode,
1043
			       struct kernel_long_ad laarr[EXTENT_MERGE_SIZE],
1044 1045
			       int startnum, int endnum,
			       struct extent_position *epos)
L
Linus Torvalds 已提交
1046 1047
{
	int start = 0, i;
1048
	struct kernel_lb_addr tmploc;
L
Linus Torvalds 已提交
1049 1050
	uint32_t tmplen;

1051 1052
	if (startnum > endnum) {
		for (i = 0; i < (startnum - endnum); i++)
J
Jan Kara 已提交
1053
			udf_delete_aext(inode, *epos, laarr[i].extLocation,
1054 1055 1056
					laarr[i].extLength);
	} else if (startnum < endnum) {
		for (i = 0; i < (endnum - startnum); i++) {
J
Jan Kara 已提交
1057
			udf_insert_aext(inode, *epos, laarr[i].extLocation,
1058
					laarr[i].extLength);
J
Jan Kara 已提交
1059
			udf_next_aext(inode, epos, &laarr[i].extLocation,
1060 1061
				      &laarr[i].extLength, 1);
			start++;
L
Linus Torvalds 已提交
1062 1063 1064
		}
	}

1065
	for (i = start; i < endnum; i++) {
J
Jan Kara 已提交
1066
		udf_next_aext(inode, epos, &tmploc, &tmplen, 0);
1067
		udf_write_aext(inode, epos, &laarr[i].extLocation,
1068
			       laarr[i].extLength, 1);
L
Linus Torvalds 已提交
1069 1070 1071
	}
}

1072 1073
struct buffer_head *udf_bread(struct inode *inode, int block,
			      int create, int *err)
L
Linus Torvalds 已提交
1074
{
1075
	struct buffer_head *bh = NULL;
L
Linus Torvalds 已提交
1076 1077 1078 1079 1080 1081 1082

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

	if (buffer_uptodate(bh))
		return bh;
1083

L
Linus Torvalds 已提交
1084
	ll_rw_block(READ, 1, &bh);
1085

L
Linus Torvalds 已提交
1086 1087 1088
	wait_on_buffer(bh);
	if (buffer_uptodate(bh))
		return bh;
1089

L
Linus Torvalds 已提交
1090 1091 1092 1093 1094
	brelse(bh);
	*err = -EIO;
	return NULL;
}

1095
int udf_setsize(struct inode *inode, loff_t newsize)
L
Linus Torvalds 已提交
1096 1097
{
	int err;
1098
	struct udf_inode_info *iinfo;
1099
	int bsize = 1 << inode->i_blkbits;
L
Linus Torvalds 已提交
1100 1101

	if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
1102
	      S_ISLNK(inode->i_mode)))
1103
		return -EINVAL;
L
Linus Torvalds 已提交
1104
	if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
1105
		return -EPERM;
L
Linus Torvalds 已提交
1106

1107
	iinfo = UDF_I(inode);
1108
	if (newsize > inode->i_size) {
1109
		down_write(&iinfo->i_data_sem);
1110 1111 1112 1113 1114 1115 1116 1117
		if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {
			if (bsize <
			    (udf_file_entry_alloc_offset(inode) + newsize)) {
				err = udf_expand_file_adinicb(inode);
				if (err) {
					up_write(&iinfo->i_data_sem);
					return err;
				}
M
Marcin Slusarz 已提交
1118
			} else
1119 1120 1121 1122 1123 1124
				iinfo->i_lenAlloc = newsize;
		}
		err = udf_extend_file(inode, newsize);
		if (err) {
			up_write(&iinfo->i_data_sem);
			return err;
L
Linus Torvalds 已提交
1125
		}
1126
		truncate_setsize(inode, newsize);
1127
		up_write(&iinfo->i_data_sem);
1128
	} else {
1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142
		if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {
			down_write(&iinfo->i_data_sem);
			memset(iinfo->i_ext.i_data + iinfo->i_lenEAttr + newsize,
			       0x00, bsize - newsize -
			       udf_file_entry_alloc_offset(inode));
			iinfo->i_lenAlloc = newsize;
			truncate_setsize(inode, newsize);
			up_write(&iinfo->i_data_sem);
			goto update_time;
		}
		err = block_truncate_page(inode->i_mapping, newsize,
					  udf_get_block);
		if (err)
			return err;
1143
		down_write(&iinfo->i_data_sem);
1144
		truncate_setsize(inode, newsize);
L
Linus Torvalds 已提交
1145
		udf_truncate_extents(inode);
1146
		up_write(&iinfo->i_data_sem);
1147
	}
1148
update_time:
L
Linus Torvalds 已提交
1149 1150
	inode->i_mtime = inode->i_ctime = current_fs_time(inode->i_sb);
	if (IS_SYNC(inode))
1151
		udf_sync_inode(inode);
L
Linus Torvalds 已提交
1152 1153
	else
		mark_inode_dirty(inode);
1154
	return 0;
L
Linus Torvalds 已提交
1155 1156
}

1157
static void __udf_read_inode(struct inode *inode)
L
Linus Torvalds 已提交
1158 1159 1160 1161
{
	struct buffer_head *bh = NULL;
	struct fileEntry *fe;
	uint16_t ident;
1162
	struct udf_inode_info *iinfo = UDF_I(inode);
L
Linus Torvalds 已提交
1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175

	/*
	 * 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;
	 */
1176
	bh = udf_read_ptagged(inode->i_sb, &iinfo->i_location, 0, &ident);
1177
	if (!bh) {
J
Joe Perches 已提交
1178
		udf_err(inode->i_sb, "(ino %ld) failed !bh\n", inode->i_ino);
L
Linus Torvalds 已提交
1179 1180 1181 1182 1183
		make_bad_inode(inode);
		return;
	}

	if (ident != TAG_IDENT_FE && ident != TAG_IDENT_EFE &&
1184
	    ident != TAG_IDENT_USE) {
J
Joe Perches 已提交
1185 1186
		udf_err(inode->i_sb, "(ino %ld) failed ident=%d\n",
			inode->i_ino, ident);
J
Jan Kara 已提交
1187
		brelse(bh);
L
Linus Torvalds 已提交
1188 1189 1190 1191 1192 1193
		make_bad_inode(inode);
		return;
	}

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

1194
	if (fe->icbTag.strategyType == cpu_to_le16(4096)) {
1195
		struct buffer_head *ibh;
L
Linus Torvalds 已提交
1196

1197
		ibh = udf_read_ptagged(inode->i_sb, &iinfo->i_location, 1,
M
Marcin Slusarz 已提交
1198
					&ident);
1199 1200
		if (ident == TAG_IDENT_IE && ibh) {
			struct buffer_head *nbh = NULL;
1201
			struct kernel_lb_addr loc;
1202 1203 1204 1205 1206 1207
			struct indirectEntry *ie;

			ie = (struct indirectEntry *)ibh->b_data;
			loc = lelb_to_cpu(ie->indirectICB.extLocation);

			if (ie->indirectICB.extLength &&
1208
				(nbh = udf_read_ptagged(inode->i_sb, &loc, 0,
1209 1210 1211 1212 1213
							&ident))) {
				if (ident == TAG_IDENT_FE ||
					ident == TAG_IDENT_EFE) {
					memcpy(&iinfo->i_location,
						&loc,
1214
						sizeof(struct kernel_lb_addr));
1215
					brelse(bh);
J
Jan Kara 已提交
1216
					brelse(ibh);
1217 1218 1219
					brelse(nbh);
					__udf_read_inode(inode);
					return;
1220
				}
1221
				brelse(nbh);
L
Linus Torvalds 已提交
1222
			}
1223
		}
1224
		brelse(ibh);
1225
	} else if (fe->icbTag.strategyType != cpu_to_le16(4)) {
J
Joe Perches 已提交
1226 1227
		udf_err(inode->i_sb, "unsupported strategy type: %d\n",
			le16_to_cpu(fe->icbTag.strategyType));
J
Jan Kara 已提交
1228
		brelse(bh);
L
Linus Torvalds 已提交
1229 1230 1231 1232
		make_bad_inode(inode);
		return;
	}
	udf_fill_inode(inode, bh);
J
Jan Kara 已提交
1233

J
Jan Kara 已提交
1234
	brelse(bh);
L
Linus Torvalds 已提交
1235 1236 1237 1238 1239 1240 1241
}

static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
{
	struct fileEntry *fe;
	struct extendedFileEntry *efe;
	int offset;
M
Marcin Slusarz 已提交
1242
	struct udf_sb_info *sbi = UDF_SB(inode->i_sb);
1243
	struct udf_inode_info *iinfo = UDF_I(inode);
L
Linus Torvalds 已提交
1244 1245 1246 1247

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

1248
	if (fe->icbTag.strategyType == cpu_to_le16(4))
1249
		iinfo->i_strat4096 = 0;
1250
	else /* if (fe->icbTag.strategyType == cpu_to_le16(4096)) */
1251
		iinfo->i_strat4096 = 1;
L
Linus Torvalds 已提交
1252

1253
	iinfo->i_alloc_type = le16_to_cpu(fe->icbTag.flags) &
M
Marcin Slusarz 已提交
1254
							ICBTAG_FLAG_AD_MASK;
1255 1256 1257 1258 1259 1260
	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;
1261
	if (fe->descTag.tagIdent == cpu_to_le16(TAG_IDENT_EFE)) {
1262 1263
		iinfo->i_efe = 1;
		iinfo->i_use = 0;
M
Marcin Slusarz 已提交
1264 1265
		if (udf_alloc_i_data(inode, inode->i_sb->s_blocksize -
					sizeof(struct extendedFileEntry))) {
1266 1267 1268
			make_bad_inode(inode);
			return;
		}
1269
		memcpy(iinfo->i_ext.i_data,
M
Marcin Slusarz 已提交
1270 1271 1272
		       bh->b_data + sizeof(struct extendedFileEntry),
		       inode->i_sb->s_blocksize -
					sizeof(struct extendedFileEntry));
1273
	} else if (fe->descTag.tagIdent == cpu_to_le16(TAG_IDENT_FE)) {
1274 1275
		iinfo->i_efe = 0;
		iinfo->i_use = 0;
M
Marcin Slusarz 已提交
1276 1277
		if (udf_alloc_i_data(inode, inode->i_sb->s_blocksize -
						sizeof(struct fileEntry))) {
1278 1279 1280
			make_bad_inode(inode);
			return;
		}
1281
		memcpy(iinfo->i_ext.i_data,
1282
		       bh->b_data + sizeof(struct fileEntry),
1283
		       inode->i_sb->s_blocksize - sizeof(struct fileEntry));
1284
	} else if (fe->descTag.tagIdent == cpu_to_le16(TAG_IDENT_USE)) {
1285 1286 1287
		iinfo->i_efe = 0;
		iinfo->i_use = 1;
		iinfo->i_lenAlloc = le32_to_cpu(
M
Marcin Slusarz 已提交
1288 1289 1290 1291
				((struct unallocSpaceEntry *)bh->b_data)->
				 lengthAllocDescs);
		if (udf_alloc_i_data(inode, inode->i_sb->s_blocksize -
					sizeof(struct unallocSpaceEntry))) {
1292 1293 1294
			make_bad_inode(inode);
			return;
		}
1295
		memcpy(iinfo->i_ext.i_data,
M
Marcin Slusarz 已提交
1296 1297 1298
		       bh->b_data + sizeof(struct unallocSpaceEntry),
		       inode->i_sb->s_blocksize -
					sizeof(struct unallocSpaceEntry));
L
Linus Torvalds 已提交
1299 1300 1301
		return;
	}

1302
	read_lock(&sbi->s_cred_lock);
L
Linus Torvalds 已提交
1303
	inode->i_uid = le32_to_cpu(fe->uid);
1304 1305 1306
	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))
1307
		inode->i_uid = UDF_SB(inode->i_sb)->s_uid;
L
Linus Torvalds 已提交
1308 1309

	inode->i_gid = le32_to_cpu(fe->gid);
1310 1311 1312
	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))
1313
		inode->i_gid = UDF_SB(inode->i_sb)->s_gid;
L
Linus Torvalds 已提交
1314

1315
	if (fe->icbTag.fileType != ICBTAG_FILE_TYPE_DIRECTORY &&
1316
			sbi->s_fmode != UDF_INVALID_MODE)
1317 1318
		inode->i_mode = sbi->s_fmode;
	else if (fe->icbTag.fileType == ICBTAG_FILE_TYPE_DIRECTORY &&
1319
			sbi->s_dmode != UDF_INVALID_MODE)
1320 1321 1322 1323
		inode->i_mode = sbi->s_dmode;
	else
		inode->i_mode = udf_convert_permissions(fe);
	inode->i_mode &= ~sbi->s_umask;
1324 1325 1326 1327 1328 1329 1330 1331
	read_unlock(&sbi->s_cred_lock);

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

	inode->i_size = le64_to_cpu(fe->informationLength);
	iinfo->i_lenExtents = inode->i_size;
L
Linus Torvalds 已提交
1332

1333
	if (iinfo->i_efe == 0) {
L
Linus Torvalds 已提交
1334
		inode->i_blocks = le64_to_cpu(fe->logicalBlocksRecorded) <<
1335
			(inode->i_sb->s_blocksize_bits - 9);
L
Linus Torvalds 已提交
1336

1337
		if (!udf_disk_stamp_to_time(&inode->i_atime, fe->accessTime))
1338 1339
			inode->i_atime = sbi->s_record_time;

1340 1341
		if (!udf_disk_stamp_to_time(&inode->i_mtime,
					    fe->modificationTime))
1342 1343
			inode->i_mtime = sbi->s_record_time;

1344
		if (!udf_disk_stamp_to_time(&inode->i_ctime, fe->attrTime))
1345
			inode->i_ctime = sbi->s_record_time;
L
Linus Torvalds 已提交
1346

1347 1348 1349 1350
		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;
1351
	} else {
1352
		inode->i_blocks = le64_to_cpu(efe->logicalBlocksRecorded) <<
1353
		    (inode->i_sb->s_blocksize_bits - 9);
L
Linus Torvalds 已提交
1354

1355
		if (!udf_disk_stamp_to_time(&inode->i_atime, efe->accessTime))
1356 1357
			inode->i_atime = sbi->s_record_time;

1358 1359
		if (!udf_disk_stamp_to_time(&inode->i_mtime,
					    efe->modificationTime))
1360 1361
			inode->i_mtime = sbi->s_record_time;

1362
		if (!udf_disk_stamp_to_time(&iinfo->i_crtime, efe->createTime))
1363 1364
			iinfo->i_crtime = sbi->s_record_time;

1365
		if (!udf_disk_stamp_to_time(&inode->i_ctime, efe->attrTime))
1366
			inode->i_ctime = sbi->s_record_time;
L
Linus Torvalds 已提交
1367

1368 1369 1370
		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 已提交
1371
		offset = sizeof(struct extendedFileEntry) +
1372
							iinfo->i_lenEAttr;
L
Linus Torvalds 已提交
1373 1374
	}

1375 1376
	switch (fe->icbTag.fileType) {
	case ICBTAG_FILE_TYPE_DIRECTORY:
1377 1378 1379 1380 1381
		inode->i_op = &udf_dir_inode_operations;
		inode->i_fop = &udf_dir_operations;
		inode->i_mode |= S_IFDIR;
		inc_nlink(inode);
		break;
1382 1383 1384
	case ICBTAG_FILE_TYPE_REALTIME:
	case ICBTAG_FILE_TYPE_REGULAR:
	case ICBTAG_FILE_TYPE_UNDEF:
J
Jan Kara 已提交
1385
	case ICBTAG_FILE_TYPE_VAT20:
1386
		if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
1387 1388 1389 1390 1391 1392 1393
			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;
1394
	case ICBTAG_FILE_TYPE_BLOCK:
1395 1396
		inode->i_mode |= S_IFBLK;
		break;
1397
	case ICBTAG_FILE_TYPE_CHAR:
1398 1399
		inode->i_mode |= S_IFCHR;
		break;
1400
	case ICBTAG_FILE_TYPE_FIFO:
1401 1402
		init_special_inode(inode, inode->i_mode | S_IFIFO, 0);
		break;
1403
	case ICBTAG_FILE_TYPE_SOCKET:
1404 1405
		init_special_inode(inode, inode->i_mode | S_IFSOCK, 0);
		break;
1406
	case ICBTAG_FILE_TYPE_SYMLINK:
1407
		inode->i_data.a_ops = &udf_symlink_aops;
1408
		inode->i_op = &udf_symlink_inode_operations;
1409 1410
		inode->i_mode = S_IFLNK | S_IRWXUGO;
		break;
1411 1412 1413 1414 1415 1416 1417 1418 1419
	case ICBTAG_FILE_TYPE_MAIN:
		udf_debug("METADATA FILE-----\n");
		break;
	case ICBTAG_FILE_TYPE_MIRROR:
		udf_debug("METADATA MIRROR FILE-----\n");
		break;
	case ICBTAG_FILE_TYPE_BITMAP:
		udf_debug("METADATA BITMAP FILE-----\n");
		break;
1420
	default:
J
Joe Perches 已提交
1421 1422
		udf_err(inode->i_sb, "(ino %ld) failed unknown file type=%d\n",
			inode->i_ino, fe->icbTag.fileType);
1423 1424
		make_bad_inode(inode);
		return;
L
Linus Torvalds 已提交
1425
	}
1426
	if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) {
M
Marcin Slusarz 已提交
1427 1428
		struct deviceSpec *dsea =
			(struct deviceSpec *)udf_get_extendedattr(inode, 12, 1);
1429 1430
		if (dsea) {
			init_special_inode(inode, inode->i_mode,
M
Marcin Slusarz 已提交
1431 1432
				MKDEV(le32_to_cpu(dsea->majorDeviceIdent),
				      le32_to_cpu(dsea->minorDeviceIdent)));
L
Linus Torvalds 已提交
1433
			/* Developer ID ??? */
M
Marcin Slusarz 已提交
1434
		} else
L
Linus Torvalds 已提交
1435 1436 1437 1438
			make_bad_inode(inode);
	}
}

1439 1440
static int udf_alloc_i_data(struct inode *inode, size_t size)
{
1441 1442
	struct udf_inode_info *iinfo = UDF_I(inode);
	iinfo->i_ext.i_data = kmalloc(size, GFP_KERNEL);
1443

1444
	if (!iinfo->i_ext.i_data) {
J
Joe Perches 已提交
1445 1446
		udf_err(inode->i_sb, "(ino %ld) no free memory\n",
			inode->i_ino);
1447 1448 1449 1450 1451 1452
		return -ENOMEM;
	}

	return 0;
}

1453
static mode_t udf_convert_permissions(struct fileEntry *fe)
L
Linus Torvalds 已提交
1454 1455 1456 1457 1458 1459 1460 1461
{
	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 已提交
1462 1463 1464 1465 1466 1467
	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 已提交
1468 1469 1470 1471

	return mode;
}

1472
int udf_write_inode(struct inode *inode, struct writeback_control *wbc)
L
Linus Torvalds 已提交
1473
{
J
Jan Kara 已提交
1474
	return udf_update_inode(inode, wbc->sync_mode == WB_SYNC_ALL);
L
Linus Torvalds 已提交
1475 1476
}

J
Jan Kara 已提交
1477
static int udf_sync_inode(struct inode *inode)
L
Linus Torvalds 已提交
1478 1479 1480 1481
{
	return udf_update_inode(inode, 1);
}

1482
static int udf_update_inode(struct inode *inode, int do_sync)
L
Linus Torvalds 已提交
1483 1484 1485 1486 1487 1488 1489 1490
{
	struct buffer_head *bh = NULL;
	struct fileEntry *fe;
	struct extendedFileEntry *efe;
	uint32_t udfperms;
	uint16_t icbflags;
	uint16_t crclen;
	int err = 0;
M
Marcin Slusarz 已提交
1491
	struct udf_sb_info *sbi = UDF_SB(inode->i_sb);
M
Marcin Slusarz 已提交
1492
	unsigned char blocksize_bits = inode->i_sb->s_blocksize_bits;
1493
	struct udf_inode_info *iinfo = UDF_I(inode);
L
Linus Torvalds 已提交
1494

1495 1496
	bh = udf_tgetblk(inode->i_sb,
			udf_get_lb_pblock(inode->i_sb, &iinfo->i_location, 0));
1497
	if (!bh) {
1498 1499
		udf_debug("getblk failure\n");
		return -ENOMEM;
L
Linus Torvalds 已提交
1500 1501
	}

1502 1503
	lock_buffer(bh);
	memset(bh->b_data, 0, inode->i_sb->s_blocksize);
L
Linus Torvalds 已提交
1504 1505 1506
	fe = (struct fileEntry *)bh->b_data;
	efe = (struct extendedFileEntry *)bh->b_data;

1507
	if (iinfo->i_use) {
L
Linus Torvalds 已提交
1508
		struct unallocSpaceEntry *use =
1509
			(struct unallocSpaceEntry *)bh->b_data;
L
Linus Torvalds 已提交
1510

1511
		use->lengthAllocDescs = cpu_to_le32(iinfo->i_lenAlloc);
M
Marcin Slusarz 已提交
1512
		memcpy(bh->b_data + sizeof(struct unallocSpaceEntry),
1513
		       iinfo->i_ext.i_data, inode->i_sb->s_blocksize -
M
Marcin Slusarz 已提交
1514
					sizeof(struct unallocSpaceEntry));
1515 1516 1517
		use->descTag.tagIdent = cpu_to_le16(TAG_IDENT_USE);
		use->descTag.tagLocation =
				cpu_to_le32(iinfo->i_location.logicalBlockNum);
M
Marcin Slusarz 已提交
1518
		crclen = sizeof(struct unallocSpaceEntry) +
1519
				iinfo->i_lenAlloc - sizeof(struct tag);
L
Linus Torvalds 已提交
1520
		use->descTag.descCRCLength = cpu_to_le16(crclen);
1521
		use->descTag.descCRC = cpu_to_le16(crc_itu_t(0, (char *)use +
1522
							   sizeof(struct tag),
1523
							   crclen));
1524
		use->descTag.tagChecksum = udf_tag_checksum(&use->descTag);
L
Linus Torvalds 已提交
1525

1526
		goto out;
L
Linus Torvalds 已提交
1527 1528
	}

1529 1530
	if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_UID_FORGET))
		fe->uid = cpu_to_le32(-1);
1531 1532
	else
		fe->uid = cpu_to_le32(inode->i_uid);
L
Linus Torvalds 已提交
1533

1534 1535
	if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_GID_FORGET))
		fe->gid = cpu_to_le32(-1);
1536 1537
	else
		fe->gid = cpu_to_le32(inode->i_gid);
L
Linus Torvalds 已提交
1538

M
Marcin Slusarz 已提交
1539 1540 1541
	udfperms = ((inode->i_mode & S_IRWXO)) |
		   ((inode->i_mode & S_IRWXG) << 2) |
		   ((inode->i_mode & S_IRWXU) << 4);
L
Linus Torvalds 已提交
1542

M
Marcin Slusarz 已提交
1543 1544 1545 1546
	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 已提交
1547 1548 1549 1550 1551 1552 1553 1554 1555
	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);

1556
	if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) {
1557
		struct regid *eid;
1558 1559
		struct deviceSpec *dsea =
			(struct deviceSpec *)udf_get_extendedattr(inode, 12, 1);
1560
		if (!dsea) {
L
Linus Torvalds 已提交
1561
			dsea = (struct deviceSpec *)
1562 1563
				udf_add_extendedattr(inode,
						     sizeof(struct deviceSpec) +
1564
						     sizeof(struct regid), 12, 0x3);
L
Linus Torvalds 已提交
1565 1566
			dsea->attrType = cpu_to_le32(12);
			dsea->attrSubtype = 1;
M
Marcin Slusarz 已提交
1567 1568
			dsea->attrLength = cpu_to_le32(
						sizeof(struct deviceSpec) +
1569 1570
						sizeof(struct regid));
			dsea->impUseLength = cpu_to_le32(sizeof(struct regid));
L
Linus Torvalds 已提交
1571
		}
1572 1573
		eid = (struct regid *)dsea->impUse;
		memset(eid, 0, sizeof(struct regid));
L
Linus Torvalds 已提交
1574 1575 1576 1577 1578 1579 1580
		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));
	}

1581
	if (iinfo->i_efe == 0) {
1582
		memcpy(bh->b_data + sizeof(struct fileEntry),
1583
		       iinfo->i_ext.i_data,
1584
		       inode->i_sb->s_blocksize - sizeof(struct fileEntry));
1585
		fe->logicalBlocksRecorded = cpu_to_le64(
M
Marcin Slusarz 已提交
1586 1587
			(inode->i_blocks + (1 << (blocksize_bits - 9)) - 1) >>
			(blocksize_bits - 9));
L
Linus Torvalds 已提交
1588

1589 1590 1591
		udf_time_to_disk_stamp(&fe->accessTime, inode->i_atime);
		udf_time_to_disk_stamp(&fe->modificationTime, inode->i_mtime);
		udf_time_to_disk_stamp(&fe->attrTime, inode->i_ctime);
1592
		memset(&(fe->impIdent), 0, sizeof(struct regid));
L
Linus Torvalds 已提交
1593 1594 1595
		strcpy(fe->impIdent.ident, UDF_ID_DEVELOPER);
		fe->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX;
		fe->impIdent.identSuffix[1] = UDF_OS_ID_LINUX;
1596 1597 1598
		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 已提交
1599 1600
		fe->descTag.tagIdent = cpu_to_le16(TAG_IDENT_FE);
		crclen = sizeof(struct fileEntry);
1601
	} else {
M
Marcin Slusarz 已提交
1602
		memcpy(bh->b_data + sizeof(struct extendedFileEntry),
1603
		       iinfo->i_ext.i_data,
M
Marcin Slusarz 已提交
1604 1605
		       inode->i_sb->s_blocksize -
					sizeof(struct extendedFileEntry));
L
Linus Torvalds 已提交
1606
		efe->objectSize = cpu_to_le64(inode->i_size);
1607
		efe->logicalBlocksRecorded = cpu_to_le64(
M
Marcin Slusarz 已提交
1608 1609
			(inode->i_blocks + (1 << (blocksize_bits - 9)) - 1) >>
			(blocksize_bits - 9));
L
Linus Torvalds 已提交
1610

1611 1612 1613 1614
		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 已提交
1615

1616 1617 1618 1619
		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 已提交
1620

1621 1622 1623 1624
		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 已提交
1625

1626 1627 1628 1629
		udf_time_to_disk_stamp(&efe->accessTime, inode->i_atime);
		udf_time_to_disk_stamp(&efe->modificationTime, inode->i_mtime);
		udf_time_to_disk_stamp(&efe->createTime, iinfo->i_crtime);
		udf_time_to_disk_stamp(&efe->attrTime, inode->i_ctime);
L
Linus Torvalds 已提交
1630

1631
		memset(&(efe->impIdent), 0, sizeof(struct regid));
L
Linus Torvalds 已提交
1632 1633 1634
		strcpy(efe->impIdent.ident, UDF_ID_DEVELOPER);
		efe->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX;
		efe->impIdent.identSuffix[1] = UDF_OS_ID_LINUX;
1635 1636 1637
		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 已提交
1638 1639 1640
		efe->descTag.tagIdent = cpu_to_le16(TAG_IDENT_EFE);
		crclen = sizeof(struct extendedFileEntry);
	}
1641
	if (iinfo->i_strat4096) {
L
Linus Torvalds 已提交
1642 1643 1644
		fe->icbTag.strategyType = cpu_to_le16(4096);
		fe->icbTag.strategyParameter = cpu_to_le16(1);
		fe->icbTag.numEntries = cpu_to_le16(2);
1645
	} else {
L
Linus Torvalds 已提交
1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664
		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;

1665
	icbflags =	iinfo->i_alloc_type |
1666 1667 1668 1669 1670 1671
			((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 已提交
1672 1673

	fe->icbTag.flags = cpu_to_le16(icbflags);
M
Marcin Slusarz 已提交
1674
	if (sbi->s_udfrev >= 0x0200)
L
Linus Torvalds 已提交
1675 1676 1677
		fe->descTag.descVersion = cpu_to_le16(3);
	else
		fe->descTag.descVersion = cpu_to_le16(2);
M
Marcin Slusarz 已提交
1678
	fe->descTag.tagSerialNum = cpu_to_le16(sbi->s_serial_number);
M
Marcin Slusarz 已提交
1679
	fe->descTag.tagLocation = cpu_to_le32(
1680
					iinfo->i_location.logicalBlockNum);
1681
	crclen += iinfo->i_lenEAttr + iinfo->i_lenAlloc - sizeof(struct tag);
L
Linus Torvalds 已提交
1682
	fe->descTag.descCRCLength = cpu_to_le16(crclen);
1683
	fe->descTag.descCRC = cpu_to_le16(crc_itu_t(0, (char *)fe + sizeof(struct tag),
1684
						  crclen));
1685
	fe->descTag.tagChecksum = udf_tag_checksum(&fe->descTag);
L
Linus Torvalds 已提交
1686

1687
out:
1688
	set_buffer_uptodate(bh);
1689 1690
	unlock_buffer(bh);

L
Linus Torvalds 已提交
1691 1692
	/* write the data blocks */
	mark_buffer_dirty(bh);
1693
	if (do_sync) {
L
Linus Torvalds 已提交
1694
		sync_dirty_buffer(bh);
1695
		if (buffer_write_io_error(bh)) {
J
Joe Perches 已提交
1696 1697
			udf_warn(inode->i_sb, "IO error syncing udf inode [%08lx]\n",
				 inode->i_ino);
L
Linus Torvalds 已提交
1698 1699 1700
			err = -EIO;
		}
	}
J
Jan Kara 已提交
1701
	brelse(bh);
1702

L
Linus Torvalds 已提交
1703 1704 1705
	return err;
}

1706
struct inode *udf_iget(struct super_block *sb, struct kernel_lb_addr *ino)
L
Linus Torvalds 已提交
1707 1708 1709 1710 1711 1712 1713 1714
{
	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) {
1715
		memcpy(&UDF_I(inode)->i_location, ino, sizeof(struct kernel_lb_addr));
L
Linus Torvalds 已提交
1716 1717 1718 1719 1720 1721 1722
		__udf_read_inode(inode);
		unlock_new_inode(inode);
	}

	if (is_bad_inode(inode))
		goto out_iput;

1723 1724
	if (ino->logicalBlockNum >= UDF_SB(sb)->
			s_partmaps[ino->partitionReferenceNum].s_partition_len) {
L
Linus Torvalds 已提交
1725
		udf_debug("block=%d, partition=%d out of range\n",
1726
			  ino->logicalBlockNum, ino->partitionReferenceNum);
L
Linus Torvalds 已提交
1727 1728 1729 1730 1731 1732
		make_bad_inode(inode);
		goto out_iput;
	}

	return inode;

1733
 out_iput:
L
Linus Torvalds 已提交
1734 1735 1736 1737
	iput(inode);
	return NULL;
}

1738 1739
int udf_add_aext(struct inode *inode, struct extent_position *epos,
		 struct kernel_lb_addr *eloc, uint32_t elen, int inc)
L
Linus Torvalds 已提交
1740 1741
{
	int adsize;
1742 1743
	struct short_ad *sad = NULL;
	struct long_ad *lad = NULL;
L
Linus Torvalds 已提交
1744 1745
	struct allocExtDesc *aed;
	uint8_t *ptr;
1746
	struct udf_inode_info *iinfo = UDF_I(inode);
L
Linus Torvalds 已提交
1747

J
Jan Kara 已提交
1748
	if (!epos->bh)
1749
		ptr = iinfo->i_ext.i_data + epos->offset -
M
Marcin Slusarz 已提交
1750
			udf_file_entry_alloc_offset(inode) +
1751
			iinfo->i_lenEAttr;
L
Linus Torvalds 已提交
1752
	else
J
Jan Kara 已提交
1753
		ptr = epos->bh->b_data + epos->offset;
L
Linus Torvalds 已提交
1754

1755
	if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
1756
		adsize = sizeof(struct short_ad);
1757
	else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
1758
		adsize = sizeof(struct long_ad);
L
Linus Torvalds 已提交
1759
	else
1760
		return -EIO;
L
Linus Torvalds 已提交
1761

1762
	if (epos->offset + (2 * adsize) > inode->i_sb->s_blocksize) {
A
Al Viro 已提交
1763
		unsigned char *sptr, *dptr;
L
Linus Torvalds 已提交
1764 1765
		struct buffer_head *nbh;
		int err, loffset;
1766
		struct kernel_lb_addr obloc = epos->block;
L
Linus Torvalds 已提交
1767

M
Marcin Slusarz 已提交
1768 1769 1770 1771
		epos->block.logicalBlockNum = udf_new_block(inode->i_sb, NULL,
						obloc.partitionReferenceNum,
						obloc.logicalBlockNum, &err);
		if (!epos->block.logicalBlockNum)
1772
			return -ENOSPC;
M
Marcin Slusarz 已提交
1773
		nbh = udf_tgetblk(inode->i_sb, udf_get_lb_pblock(inode->i_sb,
1774
								 &epos->block,
M
Marcin Slusarz 已提交
1775 1776
								 0));
		if (!nbh)
1777
			return -EIO;
L
Linus Torvalds 已提交
1778 1779 1780 1781 1782 1783 1784 1785
		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 已提交
1786 1787
			aed->previousAllocExtLocation =
					cpu_to_le32(obloc.logicalBlockNum);
1788
		if (epos->offset + adsize > inode->i_sb->s_blocksize) {
J
Jan Kara 已提交
1789
			loffset = epos->offset;
L
Linus Torvalds 已提交
1790 1791 1792 1793
			aed->lengthAllocDescs = cpu_to_le32(adsize);
			sptr = ptr - adsize;
			dptr = nbh->b_data + sizeof(struct allocExtDesc);
			memcpy(dptr, sptr, adsize);
J
Jan Kara 已提交
1794
			epos->offset = sizeof(struct allocExtDesc) + adsize;
1795
		} else {
J
Jan Kara 已提交
1796
			loffset = epos->offset + adsize;
L
Linus Torvalds 已提交
1797 1798
			aed->lengthAllocDescs = cpu_to_le32(0);
			sptr = ptr;
J
Jan Kara 已提交
1799
			epos->offset = sizeof(struct allocExtDesc);
L
Linus Torvalds 已提交
1800

1801
			if (epos->bh) {
J
Jan Kara 已提交
1802
				aed = (struct allocExtDesc *)epos->bh->b_data;
1803
				le32_add_cpu(&aed->lengthAllocDescs, adsize);
1804
			} else {
1805
				iinfo->i_lenAlloc += adsize;
L
Linus Torvalds 已提交
1806 1807 1808
				mark_inode_dirty(inode);
			}
		}
M
Marcin Slusarz 已提交
1809
		if (UDF_SB(inode->i_sb)->s_udfrev >= 0x0200)
L
Linus Torvalds 已提交
1810
			udf_new_tag(nbh->b_data, TAG_IDENT_AED, 3, 1,
1811
				    epos->block.logicalBlockNum, sizeof(struct tag));
L
Linus Torvalds 已提交
1812 1813
		else
			udf_new_tag(nbh->b_data, TAG_IDENT_AED, 2, 1,
1814
				    epos->block.logicalBlockNum, sizeof(struct tag));
1815
		switch (iinfo->i_alloc_type) {
1816
		case ICBTAG_FLAG_AD_SHORT:
1817
			sad = (struct short_ad *)sptr;
1818 1819
			sad->extLength = cpu_to_le32(EXT_NEXT_EXTENT_ALLOCDECS |
						     inode->i_sb->s_blocksize);
M
Marcin Slusarz 已提交
1820 1821
			sad->extPosition =
				cpu_to_le32(epos->block.logicalBlockNum);
1822
			break;
1823
		case ICBTAG_FLAG_AD_LONG:
1824
			lad = (struct long_ad *)sptr;
1825 1826 1827 1828 1829
			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 已提交
1830
		}
1831
		if (epos->bh) {
1832
			if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) ||
M
Marcin Slusarz 已提交
1833
			    UDF_SB(inode->i_sb)->s_udfrev >= 0x0201)
J
Jan Kara 已提交
1834
				udf_update_tag(epos->bh->b_data, loffset);
L
Linus Torvalds 已提交
1835
			else
M
Marcin Slusarz 已提交
1836 1837
				udf_update_tag(epos->bh->b_data,
						sizeof(struct allocExtDesc));
J
Jan Kara 已提交
1838
			mark_buffer_dirty_inode(epos->bh, inode);
J
Jan Kara 已提交
1839
			brelse(epos->bh);
1840
		} else {
L
Linus Torvalds 已提交
1841
			mark_inode_dirty(inode);
1842
		}
J
Jan Kara 已提交
1843
		epos->bh = nbh;
L
Linus Torvalds 已提交
1844 1845
	}

1846
	udf_write_aext(inode, epos, eloc, elen, inc);
L
Linus Torvalds 已提交
1847

1848
	if (!epos->bh) {
1849
		iinfo->i_lenAlloc += adsize;
L
Linus Torvalds 已提交
1850
		mark_inode_dirty(inode);
1851
	} else {
J
Jan Kara 已提交
1852
		aed = (struct allocExtDesc *)epos->bh->b_data;
1853
		le32_add_cpu(&aed->lengthAllocDescs, adsize);
M
Marcin Slusarz 已提交
1854 1855 1856 1857
		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 已提交
1858
		else
M
Marcin Slusarz 已提交
1859 1860
			udf_update_tag(epos->bh->b_data,
					sizeof(struct allocExtDesc));
J
Jan Kara 已提交
1861
		mark_buffer_dirty_inode(epos->bh, inode);
L
Linus Torvalds 已提交
1862 1863
	}

1864
	return 0;
L
Linus Torvalds 已提交
1865 1866
}

1867 1868
void udf_write_aext(struct inode *inode, struct extent_position *epos,
		    struct kernel_lb_addr *eloc, uint32_t elen, int inc)
L
Linus Torvalds 已提交
1869 1870 1871
{
	int adsize;
	uint8_t *ptr;
1872 1873
	struct short_ad *sad;
	struct long_ad *lad;
1874
	struct udf_inode_info *iinfo = UDF_I(inode);
L
Linus Torvalds 已提交
1875

J
Jan Kara 已提交
1876
	if (!epos->bh)
1877
		ptr = iinfo->i_ext.i_data + epos->offset -
M
Marcin Slusarz 已提交
1878
			udf_file_entry_alloc_offset(inode) +
1879
			iinfo->i_lenEAttr;
L
Linus Torvalds 已提交
1880
	else
J
Jan Kara 已提交
1881
		ptr = epos->bh->b_data + epos->offset;
L
Linus Torvalds 已提交
1882

1883
	switch (iinfo->i_alloc_type) {
1884
	case ICBTAG_FLAG_AD_SHORT:
1885
		sad = (struct short_ad *)ptr;
1886
		sad->extLength = cpu_to_le32(elen);
1887
		sad->extPosition = cpu_to_le32(eloc->logicalBlockNum);
1888
		adsize = sizeof(struct short_ad);
1889
		break;
1890
	case ICBTAG_FLAG_AD_LONG:
1891
		lad = (struct long_ad *)ptr;
1892
		lad->extLength = cpu_to_le32(elen);
1893
		lad->extLocation = cpu_to_lelb(*eloc);
1894
		memset(lad->impUse, 0x00, sizeof(lad->impUse));
1895
		adsize = sizeof(struct long_ad);
1896
		break;
1897
	default:
1898
		return;
L
Linus Torvalds 已提交
1899 1900
	}

1901
	if (epos->bh) {
1902
		if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) ||
M
Marcin Slusarz 已提交
1903
		    UDF_SB(inode->i_sb)->s_udfrev >= 0x0201) {
M
Marcin Slusarz 已提交
1904 1905
			struct allocExtDesc *aed =
				(struct allocExtDesc *)epos->bh->b_data;
J
Jan Kara 已提交
1906
			udf_update_tag(epos->bh->b_data,
M
Marcin Slusarz 已提交
1907 1908
				       le32_to_cpu(aed->lengthAllocDescs) +
				       sizeof(struct allocExtDesc));
L
Linus Torvalds 已提交
1909
		}
J
Jan Kara 已提交
1910
		mark_buffer_dirty_inode(epos->bh, inode);
1911
	} else {
L
Linus Torvalds 已提交
1912
		mark_inode_dirty(inode);
1913
	}
L
Linus Torvalds 已提交
1914 1915

	if (inc)
J
Jan Kara 已提交
1916
		epos->offset += adsize;
L
Linus Torvalds 已提交
1917 1918
}

M
Marcin Slusarz 已提交
1919
int8_t udf_next_aext(struct inode *inode, struct extent_position *epos,
1920
		     struct kernel_lb_addr *eloc, uint32_t *elen, int inc)
L
Linus Torvalds 已提交
1921 1922 1923
{
	int8_t etype;

J
Jan Kara 已提交
1924
	while ((etype = udf_current_aext(inode, epos, eloc, elen, inc)) ==
1925
	       (EXT_NEXT_EXTENT_ALLOCDECS >> 30)) {
M
Marcin Slusarz 已提交
1926
		int block;
J
Jan Kara 已提交
1927 1928
		epos->block = *eloc;
		epos->offset = sizeof(struct allocExtDesc);
J
Jan Kara 已提交
1929
		brelse(epos->bh);
1930
		block = udf_get_lb_pblock(inode->i_sb, &epos->block, 0);
M
Marcin Slusarz 已提交
1931 1932 1933
		epos->bh = udf_tread(inode->i_sb, block);
		if (!epos->bh) {
			udf_debug("reading block %d failed!\n", block);
L
Linus Torvalds 已提交
1934 1935 1936 1937 1938 1939 1940
			return -1;
		}
	}

	return etype;
}

M
Marcin Slusarz 已提交
1941
int8_t udf_current_aext(struct inode *inode, struct extent_position *epos,
1942
			struct kernel_lb_addr *eloc, uint32_t *elen, int inc)
L
Linus Torvalds 已提交
1943 1944 1945 1946
{
	int alen;
	int8_t etype;
	uint8_t *ptr;
1947 1948
	struct short_ad *sad;
	struct long_ad *lad;
1949
	struct udf_inode_info *iinfo = UDF_I(inode);
1950

1951
	if (!epos->bh) {
J
Jan Kara 已提交
1952 1953
		if (!epos->offset)
			epos->offset = udf_file_entry_alloc_offset(inode);
1954
		ptr = iinfo->i_ext.i_data + epos->offset -
M
Marcin Slusarz 已提交
1955
			udf_file_entry_alloc_offset(inode) +
1956
			iinfo->i_lenEAttr;
M
Marcin Slusarz 已提交
1957
		alen = udf_file_entry_alloc_offset(inode) +
1958
							iinfo->i_lenAlloc;
1959
	} else {
J
Jan Kara 已提交
1960 1961 1962
		if (!epos->offset)
			epos->offset = sizeof(struct allocExtDesc);
		ptr = epos->bh->b_data + epos->offset;
1963
		alen = sizeof(struct allocExtDesc) +
M
Marcin Slusarz 已提交
1964 1965
			le32_to_cpu(((struct allocExtDesc *)epos->bh->b_data)->
							lengthAllocDescs);
L
Linus Torvalds 已提交
1966 1967
	}

1968
	switch (iinfo->i_alloc_type) {
1969
	case ICBTAG_FLAG_AD_SHORT:
M
Marcin Slusarz 已提交
1970 1971
		sad = udf_get_fileshortad(ptr, alen, &epos->offset, inc);
		if (!sad)
1972 1973 1974
			return -1;
		etype = le32_to_cpu(sad->extLength) >> 30;
		eloc->logicalBlockNum = le32_to_cpu(sad->extPosition);
M
Marcin Slusarz 已提交
1975
		eloc->partitionReferenceNum =
1976
				iinfo->i_location.partitionReferenceNum;
1977 1978
		*elen = le32_to_cpu(sad->extLength) & UDF_EXTENT_LENGTH_MASK;
		break;
1979
	case ICBTAG_FLAG_AD_LONG:
M
Marcin Slusarz 已提交
1980 1981
		lad = udf_get_filelongad(ptr, alen, &epos->offset, inc);
		if (!lad)
L
Linus Torvalds 已提交
1982
			return -1;
1983 1984 1985 1986 1987
		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:
J
Joe Perches 已提交
1988
		udf_debug("alloc_type = %d unsupported\n", iinfo->i_alloc_type);
1989
		return -1;
L
Linus Torvalds 已提交
1990 1991 1992 1993 1994
	}

	return etype;
}

1995
static int8_t udf_insert_aext(struct inode *inode, struct extent_position epos,
1996
			      struct kernel_lb_addr neloc, uint32_t nelen)
L
Linus Torvalds 已提交
1997
{
1998
	struct kernel_lb_addr oeloc;
L
Linus Torvalds 已提交
1999 2000 2001
	uint32_t oelen;
	int8_t etype;

J
Jan Kara 已提交
2002
	if (epos.bh)
J
Jan Kara 已提交
2003
		get_bh(epos.bh);
L
Linus Torvalds 已提交
2004

2005
	while ((etype = udf_next_aext(inode, &epos, &oeloc, &oelen, 0)) != -1) {
2006
		udf_write_aext(inode, &epos, &neloc, nelen, 1);
L
Linus Torvalds 已提交
2007 2008 2009
		neloc = oeloc;
		nelen = (etype << 30) | oelen;
	}
2010
	udf_add_aext(inode, &epos, &neloc, nelen, 1);
J
Jan Kara 已提交
2011
	brelse(epos.bh);
2012

L
Linus Torvalds 已提交
2013 2014 2015
	return (nelen >> 30);
}

M
Marcin Slusarz 已提交
2016
int8_t udf_delete_aext(struct inode *inode, struct extent_position epos,
2017
		       struct kernel_lb_addr eloc, uint32_t elen)
L
Linus Torvalds 已提交
2018
{
J
Jan Kara 已提交
2019 2020
	struct extent_position oepos;
	int adsize;
L
Linus Torvalds 已提交
2021 2022
	int8_t etype;
	struct allocExtDesc *aed;
2023
	struct udf_inode_info *iinfo;
L
Linus Torvalds 已提交
2024

2025
	if (epos.bh) {
J
Jan Kara 已提交
2026 2027
		get_bh(epos.bh);
		get_bh(epos.bh);
L
Linus Torvalds 已提交
2028 2029
	}

2030 2031
	iinfo = UDF_I(inode);
	if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
2032
		adsize = sizeof(struct short_ad);
2033
	else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
2034
		adsize = sizeof(struct long_ad);
L
Linus Torvalds 已提交
2035 2036 2037
	else
		adsize = 0;

J
Jan Kara 已提交
2038 2039
	oepos = epos;
	if (udf_next_aext(inode, &epos, &eloc, &elen, 1) == -1)
L
Linus Torvalds 已提交
2040 2041
		return -1;

2042
	while ((etype = udf_next_aext(inode, &epos, &eloc, &elen, 1)) != -1) {
2043
		udf_write_aext(inode, &oepos, &eloc, (etype << 30) | elen, 1);
2044
		if (oepos.bh != epos.bh) {
J
Jan Kara 已提交
2045
			oepos.block = epos.block;
J
Jan Kara 已提交
2046 2047
			brelse(oepos.bh);
			get_bh(epos.bh);
J
Jan Kara 已提交
2048 2049
			oepos.bh = epos.bh;
			oepos.offset = epos.offset - adsize;
L
Linus Torvalds 已提交
2050 2051
		}
	}
2052
	memset(&eloc, 0x00, sizeof(struct kernel_lb_addr));
L
Linus Torvalds 已提交
2053 2054
	elen = 0;

2055
	if (epos.bh != oepos.bh) {
2056 2057 2058
		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);
2059
		if (!oepos.bh) {
2060
			iinfo->i_lenAlloc -= (adsize * 2);
L
Linus Torvalds 已提交
2061
			mark_inode_dirty(inode);
2062
		} else {
J
Jan Kara 已提交
2063
			aed = (struct allocExtDesc *)oepos.bh->b_data;
2064
			le32_add_cpu(&aed->lengthAllocDescs, -(2 * adsize));
2065
			if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) ||
M
Marcin Slusarz 已提交
2066
			    UDF_SB(inode->i_sb)->s_udfrev >= 0x0201)
M
Marcin Slusarz 已提交
2067 2068
				udf_update_tag(oepos.bh->b_data,
						oepos.offset - (2 * adsize));
L
Linus Torvalds 已提交
2069
			else
M
Marcin Slusarz 已提交
2070 2071
				udf_update_tag(oepos.bh->b_data,
						sizeof(struct allocExtDesc));
J
Jan Kara 已提交
2072
			mark_buffer_dirty_inode(oepos.bh, inode);
L
Linus Torvalds 已提交
2073
		}
2074
	} else {
2075
		udf_write_aext(inode, &oepos, &eloc, elen, 1);
2076
		if (!oepos.bh) {
2077
			iinfo->i_lenAlloc -= adsize;
L
Linus Torvalds 已提交
2078
			mark_inode_dirty(inode);
2079
		} else {
J
Jan Kara 已提交
2080
			aed = (struct allocExtDesc *)oepos.bh->b_data;
2081
			le32_add_cpu(&aed->lengthAllocDescs, -adsize);
2082
			if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) ||
M
Marcin Slusarz 已提交
2083
			    UDF_SB(inode->i_sb)->s_udfrev >= 0x0201)
M
Marcin Slusarz 已提交
2084 2085
				udf_update_tag(oepos.bh->b_data,
						epos.offset - adsize);
L
Linus Torvalds 已提交
2086
			else
M
Marcin Slusarz 已提交
2087 2088
				udf_update_tag(oepos.bh->b_data,
						sizeof(struct allocExtDesc));
J
Jan Kara 已提交
2089
			mark_buffer_dirty_inode(oepos.bh, inode);
L
Linus Torvalds 已提交
2090 2091
		}
	}
2092

J
Jan Kara 已提交
2093 2094
	brelse(epos.bh);
	brelse(oepos.bh);
2095

L
Linus Torvalds 已提交
2096 2097 2098
	return (elen >> 30);
}

M
Marcin Slusarz 已提交
2099
int8_t inode_bmap(struct inode *inode, sector_t block,
2100
		  struct extent_position *pos, struct kernel_lb_addr *eloc,
M
Marcin Slusarz 已提交
2101
		  uint32_t *elen, sector_t *offset)
L
Linus Torvalds 已提交
2102
{
M
Marcin Slusarz 已提交
2103
	unsigned char blocksize_bits = inode->i_sb->s_blocksize_bits;
2104
	loff_t lbcount = 0, bcount =
M
Marcin Slusarz 已提交
2105
	    (loff_t) block << blocksize_bits;
L
Linus Torvalds 已提交
2106
	int8_t etype;
2107
	struct udf_inode_info *iinfo;
L
Linus Torvalds 已提交
2108

2109
	iinfo = UDF_I(inode);
J
Jan Kara 已提交
2110
	pos->offset = 0;
2111
	pos->block = iinfo->i_location;
J
Jan Kara 已提交
2112
	pos->bh = NULL;
L
Linus Torvalds 已提交
2113 2114
	*elen = 0;

2115
	do {
M
Marcin Slusarz 已提交
2116 2117 2118
		etype = udf_next_aext(inode, pos, eloc, elen, 1);
		if (etype == -1) {
			*offset = (bcount - lbcount) >> blocksize_bits;
2119
			iinfo->i_lenExtents = lbcount;
L
Linus Torvalds 已提交
2120 2121 2122 2123 2124
			return -1;
		}
		lbcount += *elen;
	} while (lbcount <= bcount);

M
Marcin Slusarz 已提交
2125
	*offset = (bcount + *elen - lbcount) >> blocksize_bits;
L
Linus Torvalds 已提交
2126 2127 2128 2129

	return etype;
}

2130
long udf_block_map(struct inode *inode, sector_t block)
L
Linus Torvalds 已提交
2131
{
2132
	struct kernel_lb_addr eloc;
J
Jan Kara 已提交
2133
	uint32_t elen;
2134
	sector_t offset;
2135
	struct extent_position epos = {};
L
Linus Torvalds 已提交
2136 2137
	int ret;

2138
	down_read(&UDF_I(inode)->i_data_sem);
L
Linus Torvalds 已提交
2139

M
Marcin Slusarz 已提交
2140 2141
	if (inode_bmap(inode, block, &epos, &eloc, &elen, &offset) ==
						(EXT_RECORDED_ALLOCATED >> 30))
2142
		ret = udf_get_lb_pblock(inode->i_sb, &eloc, offset);
L
Linus Torvalds 已提交
2143 2144 2145
	else
		ret = 0;

2146
	up_read(&UDF_I(inode)->i_data_sem);
J
Jan Kara 已提交
2147
	brelse(epos.bh);
L
Linus Torvalds 已提交
2148 2149 2150 2151 2152 2153

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