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

#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

A
Al Viro 已提交
51
static umode_t udf_convert_permissions(struct fileEntry *);
L
Linus Torvalds 已提交
52
static int udf_update_inode(struct inode *, int);
J
Jan Kara 已提交
53
static int udf_sync_inode(struct inode *inode);
54
static int udf_alloc_i_data(struct inode *inode, size_t size);
55
static sector_t inode_getblk(struct inode *, sector_t, int *, int *);
J
Jan Kara 已提交
56
static int8_t udf_insert_aext(struct inode *, struct extent_position,
57
			      struct kernel_lb_addr, uint32_t);
L
Linus Torvalds 已提交
58
static void udf_split_extents(struct inode *, int *, int, int,
59
			      struct kernel_long_ad[EXTENT_MERGE_SIZE], int *);
L
Linus Torvalds 已提交
60
static void udf_prealloc_extents(struct inode *, int, int,
61
				 struct kernel_long_ad[EXTENT_MERGE_SIZE], int *);
L
Linus Torvalds 已提交
62
static void udf_merge_extents(struct inode *,
63
			      struct kernel_long_ad[EXTENT_MERGE_SIZE], int *);
L
Linus Torvalds 已提交
64
static void udf_update_extents(struct inode *,
65
			       struct kernel_long_ad[EXTENT_MERGE_SIZE], int, int,
66
			       struct extent_position *);
L
Linus Torvalds 已提交
67 68
static int udf_get_block(struct inode *, sector_t, struct buffer_head *, int);

69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136
static void __udf_clear_extent_cache(struct inode *inode)
{
	struct udf_inode_info *iinfo = UDF_I(inode);

	if (iinfo->cached_extent.lstart != -1) {
		brelse(iinfo->cached_extent.epos.bh);
		iinfo->cached_extent.lstart = -1;
	}
}

/* Invalidate extent cache */
static void udf_clear_extent_cache(struct inode *inode)
{
	struct udf_inode_info *iinfo = UDF_I(inode);

	spin_lock(&iinfo->i_extent_cache_lock);
	__udf_clear_extent_cache(inode);
	spin_unlock(&iinfo->i_extent_cache_lock);
}

/* Return contents of extent cache */
static int udf_read_extent_cache(struct inode *inode, loff_t bcount,
				 loff_t *lbcount, struct extent_position *pos)
{
	struct udf_inode_info *iinfo = UDF_I(inode);
	int ret = 0;

	spin_lock(&iinfo->i_extent_cache_lock);
	if ((iinfo->cached_extent.lstart <= bcount) &&
	    (iinfo->cached_extent.lstart != -1)) {
		/* Cache hit */
		*lbcount = iinfo->cached_extent.lstart;
		memcpy(pos, &iinfo->cached_extent.epos,
		       sizeof(struct extent_position));
		if (pos->bh)
			get_bh(pos->bh);
		ret = 1;
	}
	spin_unlock(&iinfo->i_extent_cache_lock);
	return ret;
}

/* Add extent to extent cache */
static void udf_update_extent_cache(struct inode *inode, loff_t estart,
				    struct extent_position *pos, int next_epos)
{
	struct udf_inode_info *iinfo = UDF_I(inode);

	spin_lock(&iinfo->i_extent_cache_lock);
	/* Invalidate previously cached extent */
	__udf_clear_extent_cache(inode);
	if (pos->bh)
		get_bh(pos->bh);
	memcpy(&iinfo->cached_extent.epos, pos,
	       sizeof(struct extent_position));
	iinfo->cached_extent.lstart = estart;
	if (next_epos)
		switch (iinfo->i_alloc_type) {
		case ICBTAG_FLAG_AD_SHORT:
			iinfo->cached_extent.epos.offset -=
			sizeof(struct short_ad);
			break;
		case ICBTAG_FLAG_AD_LONG:
			iinfo->cached_extent.epos.offset -=
			sizeof(struct long_ad);
		}
	spin_unlock(&iinfo->i_extent_cache_lock);
}
137

A
Al Viro 已提交
138
void udf_evict_inode(struct inode *inode)
L
Linus Torvalds 已提交
139
{
J
Jan Kara 已提交
140
	struct udf_inode_info *iinfo = UDF_I(inode);
A
Al Viro 已提交
141 142 143 144
	int want_delete = 0;

	if (!inode->i_nlink && !is_bad_inode(inode)) {
		want_delete = 1;
145
		udf_setsize(inode, 0);
A
Al Viro 已提交
146
		udf_update_inode(inode, IS_SYNC(inode));
147 148
	}
	truncate_inode_pages_final(&inode->i_data);
A
Al Viro 已提交
149
	invalidate_inode_buffers(inode);
150
	clear_inode(inode);
J
Jan Kara 已提交
151 152
	if (iinfo->i_alloc_type != ICBTAG_FLAG_AD_IN_ICB &&
	    inode->i_size != iinfo->i_lenExtents) {
J
Joe Perches 已提交
153 154 155 156
		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 已提交
157
	}
158 159
	kfree(iinfo->i_ext.i_data);
	iinfo->i_ext.i_data = NULL;
160
	udf_clear_extent_cache(inode);
A
Al Viro 已提交
161 162 163
	if (want_delete) {
		udf_free_inode(inode);
	}
L
Linus Torvalds 已提交
164 165
}

I
Ian Abbott 已提交
166 167 168 169 170 171 172
static void udf_write_failed(struct address_space *mapping, loff_t to)
{
	struct inode *inode = mapping->host;
	struct udf_inode_info *iinfo = UDF_I(inode);
	loff_t isize = inode->i_size;

	if (to > isize) {
173
		truncate_pagecache(inode, isize);
I
Ian Abbott 已提交
174 175
		if (iinfo->i_alloc_type != ICBTAG_FLAG_AD_IN_ICB) {
			down_write(&iinfo->i_data_sem);
176
			udf_clear_extent_cache(inode);
I
Ian Abbott 已提交
177 178 179 180 181 182
			udf_truncate_extents(inode);
			up_write(&iinfo->i_data_sem);
		}
	}
}

L
Linus Torvalds 已提交
183 184 185 186 187
static int udf_writepage(struct page *page, struct writeback_control *wbc)
{
	return block_write_full_page(page, udf_get_block, wbc);
}

188 189 190 191 192 193
static int udf_writepages(struct address_space *mapping,
			struct writeback_control *wbc)
{
	return mpage_writepages(mapping, wbc, udf_get_block);
}

L
Linus Torvalds 已提交
194 195
static int udf_readpage(struct file *file, struct page *page)
{
N
Namjae Jeon 已提交
196 197 198 199 200 201 202
	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 已提交
203 204
}

N
Nick Piggin 已提交
205 206 207
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 已提交
208
{
209 210 211
	int ret;

	ret = block_write_begin(mapping, pos, len, flags, pagep, udf_get_block);
I
Ian Abbott 已提交
212 213 214 215
	if (unlikely(ret))
		udf_write_failed(mapping, pos + len);
	return ret;
}
216

I
Ian Abbott 已提交
217
static ssize_t udf_direct_IO(int rw, struct kiocb *iocb,
A
Al Viro 已提交
218 219
			     struct iov_iter *iter,
			     loff_t offset)
I
Ian Abbott 已提交
220 221 222 223
{
	struct file *file = iocb->ki_filp;
	struct address_space *mapping = file->f_mapping;
	struct inode *inode = mapping->host;
224
	size_t count = iov_iter_count(iter);
I
Ian Abbott 已提交
225 226
	ssize_t ret;

227
	ret = blockdev_direct_IO(rw, iocb, inode, iter, offset, udf_get_block);
I
Ian Abbott 已提交
228
	if (unlikely(ret < 0 && (rw & WRITE)))
229
		udf_write_failed(mapping, offset + count);
230
	return ret;
L
Linus Torvalds 已提交
231 232 233 234
}

static sector_t udf_bmap(struct address_space *mapping, sector_t block)
{
235
	return generic_block_bmap(mapping, block, udf_get_block);
L
Linus Torvalds 已提交
236 237
}

238
const struct address_space_operations udf_aops = {
239
	.readpage	= udf_readpage,
N
Namjae Jeon 已提交
240
	.readpages	= udf_readpages,
241
	.writepage	= udf_writepage,
242
	.writepages	= udf_writepages,
I
Ian Abbott 已提交
243 244 245
	.write_begin	= udf_write_begin,
	.write_end	= generic_write_end,
	.direct_IO	= udf_direct_IO,
246
	.bmap		= udf_bmap,
L
Linus Torvalds 已提交
247 248
};

249 250 251 252 253 254
/*
 * Expand file stored in ICB to a normal one-block-file
 *
 * This function requires i_data_sem for writing and releases it.
 * This function requires i_mutex held
 */
255
int udf_expand_file_adinicb(struct inode *inode)
L
Linus Torvalds 已提交
256 257 258
{
	struct page *page;
	char *kaddr;
259
	struct udf_inode_info *iinfo = UDF_I(inode);
260
	int err;
L
Linus Torvalds 已提交
261 262 263 264 265
	struct writeback_control udf_wbc = {
		.sync_mode = WB_SYNC_NONE,
		.nr_to_write = 1,
	};

266
	WARN_ON_ONCE(!mutex_is_locked(&inode->i_mutex));
267
	if (!iinfo->i_lenAlloc) {
L
Linus Torvalds 已提交
268
		if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_SHORT_AD))
269
			iinfo->i_alloc_type = ICBTAG_FLAG_AD_SHORT;
L
Linus Torvalds 已提交
270
		else
271
			iinfo->i_alloc_type = ICBTAG_FLAG_AD_LONG;
272 273
		/* from now on we have normal address_space methods */
		inode->i_data.a_ops = &udf_aops;
274
		up_write(&iinfo->i_data_sem);
L
Linus Torvalds 已提交
275
		mark_inode_dirty(inode);
276
		return 0;
L
Linus Torvalds 已提交
277
	}
278 279 280 281 282
	/*
	 * Release i_data_sem so that we can lock a page - page lock ranks
	 * above i_data_sem. i_mutex still protects us against file changes.
	 */
	up_write(&iinfo->i_data_sem);
L
Linus Torvalds 已提交
283

284 285 286
	page = find_or_create_page(inode->i_mapping, 0, GFP_NOFS);
	if (!page)
		return -ENOMEM;
M
Matt Mackall 已提交
287

288
	if (!PageUptodate(page)) {
L
Linus Torvalds 已提交
289
		kaddr = kmap(page);
290 291 292 293
		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 已提交
294 295 296 297
		flush_dcache_page(page);
		SetPageUptodate(page);
		kunmap(page);
	}
298
	down_write(&iinfo->i_data_sem);
299 300 301
	memset(iinfo->i_ext.i_data + iinfo->i_lenEAttr, 0x00,
	       iinfo->i_lenAlloc);
	iinfo->i_lenAlloc = 0;
L
Linus Torvalds 已提交
302
	if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_SHORT_AD))
303
		iinfo->i_alloc_type = ICBTAG_FLAG_AD_SHORT;
L
Linus Torvalds 已提交
304
	else
305
		iinfo->i_alloc_type = ICBTAG_FLAG_AD_LONG;
306 307
	/* from now on we have normal address_space methods */
	inode->i_data.a_ops = &udf_aops;
308
	up_write(&iinfo->i_data_sem);
309 310 311 312 313
	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);
314
		down_write(&iinfo->i_data_sem);
315 316 317 318 319 320
		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;
321
		up_write(&iinfo->i_data_sem);
322
	}
L
Linus Torvalds 已提交
323 324
	page_cache_release(page);
	mark_inode_dirty(inode);
325 326

	return err;
L
Linus Torvalds 已提交
327 328
}

329 330
struct buffer_head *udf_expand_dir_adinicb(struct inode *inode, int *block,
					   int *err)
L
Linus Torvalds 已提交
331 332
{
	int newblock;
J
Jan Kara 已提交
333
	struct buffer_head *dbh = NULL;
334
	struct kernel_lb_addr eloc;
L
Linus Torvalds 已提交
335
	uint8_t alloctype;
J
Jan Kara 已提交
336
	struct extent_position epos;
L
Linus Torvalds 已提交
337 338

	struct udf_fileident_bh sfibh, dfibh;
339 340
	loff_t f_pos = udf_ext0_offset(inode);
	int size = udf_ext0_offset(inode) + inode->i_size;
L
Linus Torvalds 已提交
341
	struct fileIdentDesc cfi, *sfi, *dfi;
342
	struct udf_inode_info *iinfo = UDF_I(inode);
L
Linus Torvalds 已提交
343 344 345 346 347 348

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

349
	if (!inode->i_size) {
350
		iinfo->i_alloc_type = alloctype;
L
Linus Torvalds 已提交
351 352 353 354 355 356
		mark_inode_dirty(inode);
		return NULL;
	}

	/* alloc block, and copy data to it */
	*block = udf_new_block(inode->i_sb, inode,
357 358
			       iinfo->i_location.partitionReferenceNum,
			       iinfo->i_location.logicalBlockNum, err);
L
Linus Torvalds 已提交
359 360 361
	if (!(*block))
		return NULL;
	newblock = udf_get_pblock(inode->i_sb, *block,
362
				  iinfo->i_location.partitionReferenceNum,
363
				0);
L
Linus Torvalds 已提交
364 365 366 367 368 369 370 371 372 373 374
	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 已提交
375
	sfibh.soffset = sfibh.eoffset =
376
			f_pos & (inode->i_sb->s_blocksize - 1);
J
Jan Kara 已提交
377
	sfibh.sbh = sfibh.ebh = NULL;
L
Linus Torvalds 已提交
378 379
	dfibh.soffset = dfibh.eoffset = 0;
	dfibh.sbh = dfibh.ebh = dbh;
380
	while (f_pos < size) {
381
		iinfo->i_alloc_type = ICBTAG_FLAG_AD_IN_ICB;
M
Marcin Slusarz 已提交
382 383
		sfi = udf_fileident_read(inode, &f_pos, &sfibh, &cfi, NULL,
					 NULL, NULL, NULL);
384
		if (!sfi) {
J
Jan Kara 已提交
385
			brelse(dbh);
L
Linus Torvalds 已提交
386 387
			return NULL;
		}
388
		iinfo->i_alloc_type = alloctype;
L
Linus Torvalds 已提交
389 390 391 392 393
		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 已提交
394 395
				 sfi->fileIdent +
					le16_to_cpu(sfi->lengthOfImpUse))) {
396
			iinfo->i_alloc_type = ICBTAG_FLAG_AD_IN_ICB;
J
Jan Kara 已提交
397
			brelse(dbh);
L
Linus Torvalds 已提交
398 399 400 401 402
			return NULL;
		}
	}
	mark_buffer_dirty_inode(dbh, inode);

403 404 405
	memset(iinfo->i_ext.i_data + iinfo->i_lenEAttr, 0,
		iinfo->i_lenAlloc);
	iinfo->i_lenAlloc = 0;
L
Linus Torvalds 已提交
406
	eloc.logicalBlockNum = *block;
M
Marcin Slusarz 已提交
407
	eloc.partitionReferenceNum =
408
				iinfo->i_location.partitionReferenceNum;
J
Jan Kara 已提交
409
	iinfo->i_lenExtents = inode->i_size;
J
Jan Kara 已提交
410
	epos.bh = NULL;
411
	epos.block = iinfo->i_location;
J
Jan Kara 已提交
412
	epos.offset = udf_file_entry_alloc_offset(inode);
J
Jan Kara 已提交
413
	udf_add_aext(inode, &epos, &eloc, inode->i_size, 0);
L
Linus Torvalds 已提交
414 415
	/* UniqueID stuff */

J
Jan Kara 已提交
416
	brelse(epos.bh);
L
Linus Torvalds 已提交
417 418 419 420
	mark_inode_dirty(inode);
	return dbh;
}

421 422
static int udf_get_block(struct inode *inode, sector_t block,
			 struct buffer_head *bh_result, int create)
L
Linus Torvalds 已提交
423 424
{
	int err, new;
425
	sector_t phys = 0;
426
	struct udf_inode_info *iinfo;
L
Linus Torvalds 已提交
427

428
	if (!create) {
L
Linus Torvalds 已提交
429 430 431 432 433 434 435 436
		phys = udf_block_map(inode, block);
		if (phys)
			map_bh(bh_result, inode->i_sb, phys);
		return 0;
	}

	err = -EIO;
	new = 0;
437
	iinfo = UDF_I(inode);
438 439

	down_write(&iinfo->i_data_sem);
440 441 442
	if (block == iinfo->i_next_alloc_block + 1) {
		iinfo->i_next_alloc_block++;
		iinfo->i_next_alloc_goal++;
L
Linus Torvalds 已提交
443 444
	}

445
	udf_clear_extent_cache(inode);
446 447
	phys = inode_getblk(inode, block, &err, &new);
	if (!phys)
L
Linus Torvalds 已提交
448 449 450 451 452
		goto abort;

	if (new)
		set_buffer_new(bh_result);
	map_bh(bh_result, inode->i_sb, phys);
453 454

abort:
455
	up_write(&iinfo->i_data_sem);
L
Linus Torvalds 已提交
456 457 458
	return err;
}

459 460
static struct buffer_head *udf_getblk(struct inode *inode, long block,
				      int create, int *err)
L
Linus Torvalds 已提交
461
{
462
	struct buffer_head *bh;
L
Linus Torvalds 已提交
463 464 465 466 467
	struct buffer_head dummy;

	dummy.b_state = 0;
	dummy.b_blocknr = -1000;
	*err = udf_get_block(inode, block, &dummy, create);
468
	if (!*err && buffer_mapped(&dummy)) {
L
Linus Torvalds 已提交
469
		bh = sb_getblk(inode->i_sb, dummy.b_blocknr);
470
		if (buffer_new(&dummy)) {
L
Linus Torvalds 已提交
471 472 473 474 475 476 477 478
			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;
	}
479

L
Linus Torvalds 已提交
480 481 482
	return NULL;
}

J
Jan Kara 已提交
483
/* Extend the file by 'blocks' blocks, return the number of extents added */
484 485 486 487
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 已提交
488 489 490 491
{
	sector_t add;
	int count = 0, fake = !(last_ext->extLength & UDF_EXTENT_LENGTH_MASK);
	struct super_block *sb = inode->i_sb;
492
	struct kernel_lb_addr prealloc_loc = {};
J
Jan Kara 已提交
493
	int prealloc_len = 0;
494
	struct udf_inode_info *iinfo;
495
	int err;
J
Jan Kara 已提交
496 497 498 499 500

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

502
	iinfo = UDF_I(inode);
J
Jan Kara 已提交
503 504 505
	/* Round the last extent up to a multiple of block size */
	if (last_ext->extLength & (sb->s_blocksize - 1)) {
		last_ext->extLength =
506 507 508
			(last_ext->extLength & UDF_EXTENT_FLAG_MASK) |
			(((last_ext->extLength & UDF_EXTENT_LENGTH_MASK) +
			  sb->s_blocksize - 1) & ~(sb->s_blocksize - 1));
509 510
		iinfo->i_lenExtents =
			(iinfo->i_lenExtents + sb->s_blocksize - 1) &
511
			~(sb->s_blocksize - 1);
J
Jan Kara 已提交
512
	}
513

J
Jan Kara 已提交
514
	/* Last extent are just preallocated blocks? */
M
Marcin Slusarz 已提交
515 516
	if ((last_ext->extLength & UDF_EXTENT_FLAG_MASK) ==
						EXT_NOT_RECORDED_ALLOCATED) {
J
Jan Kara 已提交
517 518 519 520 521
		/* 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 |
522
			(last_ext->extLength & UDF_EXTENT_LENGTH_MASK);
J
Jan Kara 已提交
523
		last_ext->extLocation.logicalBlockNum = 0;
M
Marcin Slusarz 已提交
524
		last_ext->extLocation.partitionReferenceNum = 0;
J
Jan Kara 已提交
525
	}
526

J
Jan Kara 已提交
527
	/* Can we merge with the previous extent? */
M
Marcin Slusarz 已提交
528 529 530 531 532
	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 已提交
533 534 535 536 537 538 539
		if (add > blocks)
			add = blocks;
		blocks -= add;
		last_ext->extLength += add << sb->s_blocksize_bits;
	}

	if (fake) {
540
		udf_add_aext(inode, last_pos, &last_ext->extLocation,
541
			     last_ext->extLength, 1);
J
Jan Kara 已提交
542
		count++;
M
Marcin Slusarz 已提交
543
	} else
544
		udf_write_aext(inode, last_pos, &last_ext->extLocation,
M
Marcin Slusarz 已提交
545
				last_ext->extLength, 1);
546

J
Jan Kara 已提交
547 548 549 550 551 552
	/* 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 已提交
553
	last_ext->extLocation.partitionReferenceNum = 0;
554
	add = (1 << (30-sb->s_blocksize_bits)) - 1;
M
Marcin Slusarz 已提交
555 556
	last_ext->extLength = EXT_NOT_RECORDED_NOT_ALLOCATED |
				(add << sb->s_blocksize_bits);
557

J
Jan Kara 已提交
558 559 560
	/* Create enough extents to cover the whole hole */
	while (blocks > add) {
		blocks -= add;
561 562 563 564
		err = udf_add_aext(inode, last_pos, &last_ext->extLocation,
				   last_ext->extLength, 1);
		if (err)
			return err;
J
Jan Kara 已提交
565 566 567 568
		count++;
	}
	if (blocks) {
		last_ext->extLength = EXT_NOT_RECORDED_NOT_ALLOCATED |
569
			(blocks << sb->s_blocksize_bits);
570 571 572 573
		err = udf_add_aext(inode, last_pos, &last_ext->extLocation,
				   last_ext->extLength, 1);
		if (err)
			return err;
J
Jan Kara 已提交
574 575
		count++;
	}
576 577

out:
J
Jan Kara 已提交
578 579
	/* Do we have some preallocated blocks saved? */
	if (prealloc_len) {
580 581 582 583
		err = udf_add_aext(inode, last_pos, &prealloc_loc,
				   prealloc_len, 1);
		if (err)
			return err;
J
Jan Kara 已提交
584 585 586 587
		last_ext->extLocation = prealloc_loc;
		last_ext->extLength = prealloc_len;
		count++;
	}
588

J
Jan Kara 已提交
589
	/* last_pos should point to the last written extent... */
590
	if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
591
		last_pos->offset -= sizeof(struct short_ad);
592
	else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
593
		last_pos->offset -= sizeof(struct long_ad);
J
Jan Kara 已提交
594
	else
595
		return -EIO;
596

J
Jan Kara 已提交
597 598 599
	return count;
}

600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656
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;
}

657 658
static sector_t inode_getblk(struct inode *inode, sector_t block,
			     int *err, int *new)
L
Linus Torvalds 已提交
659
{
660
	struct kernel_long_ad laarr[EXTENT_MERGE_SIZE];
J
Jan Kara 已提交
661
	struct extent_position prev_epos, cur_epos, next_epos;
L
Linus Torvalds 已提交
662
	int count = 0, startnum = 0, endnum = 0;
J
Jan Kara 已提交
663
	uint32_t elen = 0, tmpelen;
664
	struct kernel_lb_addr eloc, tmpeloc;
L
Linus Torvalds 已提交
665
	int c = 1;
666 667 668
	loff_t lbcount = 0, b_off = 0;
	uint32_t newblocknum, newblock;
	sector_t offset = 0;
L
Linus Torvalds 已提交
669
	int8_t etype;
670 671
	struct udf_inode_info *iinfo = UDF_I(inode);
	int goal = 0, pgoal = iinfo->i_location.logicalBlockNum;
J
Jan Kara 已提交
672
	int lastblock = 0;
673
	bool isBeyondEOF;
L
Linus Torvalds 已提交
674

675 676
	*err = 0;
	*new = 0;
J
Jan Kara 已提交
677
	prev_epos.offset = udf_file_entry_alloc_offset(inode);
678
	prev_epos.block = iinfo->i_location;
J
Jan Kara 已提交
679 680
	prev_epos.bh = NULL;
	cur_epos = next_epos = prev_epos;
681
	b_off = (loff_t)block << inode->i_sb->s_blocksize_bits;
L
Linus Torvalds 已提交
682 683

	/* find the extent which contains the block we are looking for.
684 685 686 687
	   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 已提交
688 689
			brelse(prev_epos.bh);
			get_bh(cur_epos.bh);
J
Jan Kara 已提交
690
			prev_epos.bh = cur_epos.bh;
L
Linus Torvalds 已提交
691
		}
692
		if (cur_epos.bh != next_epos.bh) {
J
Jan Kara 已提交
693 694
			brelse(cur_epos.bh);
			get_bh(next_epos.bh);
J
Jan Kara 已提交
695
			cur_epos.bh = next_epos.bh;
L
Linus Torvalds 已提交
696 697 698 699
		}

		lbcount += elen;

J
Jan Kara 已提交
700 701
		prev_epos.block = cur_epos.block;
		cur_epos.block = next_epos.block;
L
Linus Torvalds 已提交
702

J
Jan Kara 已提交
703 704
		prev_epos.offset = cur_epos.offset;
		cur_epos.offset = next_epos.offset;
L
Linus Torvalds 已提交
705

M
Marcin Slusarz 已提交
706 707
		etype = udf_next_aext(inode, &next_epos, &eloc, &elen, 1);
		if (etype == -1)
L
Linus Torvalds 已提交
708 709 710 711 712 713 714 715 716
			break;

		c = !c;

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

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

720
		count++;
L
Linus Torvalds 已提交
721 722 723 724
	} while (lbcount + elen <= b_off);

	b_off -= lbcount;
	offset = b_off >> inode->i_sb->s_blocksize_bits;
J
Jan Kara 已提交
725 726 727 728 729 730
	/*
	 * 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 已提交
731 732

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

735 736
	if (etype == (EXT_RECORDED_ALLOCATED >> 30)) {
		if (elen & (inode->i_sb->s_blocksize - 1)) {
L
Linus Torvalds 已提交
737
			elen = EXT_RECORDED_ALLOCATED |
738 739
				((elen + inode->i_sb->s_blocksize - 1) &
				 ~(inode->i_sb->s_blocksize - 1));
740
			udf_write_aext(inode, &cur_epos, &eloc, elen, 1);
L
Linus Torvalds 已提交
741
		}
J
Jan Kara 已提交
742 743 744
		brelse(prev_epos.bh);
		brelse(cur_epos.bh);
		brelse(next_epos.bh);
745
		newblock = udf_get_lb_pblock(inode->i_sb, &eloc, offset);
746
		return newblock;
L
Linus Torvalds 已提交
747 748
	}

J
Jan Kara 已提交
749
	/* Are we beyond EOF? */
750
	if (etype == -1) {
J
Jan Kara 已提交
751
		int ret;
752
		isBeyondEOF = true;
J
Jan Kara 已提交
753 754 755 756
		if (count) {
			if (c)
				laarr[0] = laarr[1];
			startnum = 1;
757
		} else {
J
Jan Kara 已提交
758
			/* Create a fake extent when there's not one */
M
Marcin Slusarz 已提交
759
			memset(&laarr[0].extLocation, 0x00,
760
				sizeof(struct kernel_lb_addr));
J
Jan Kara 已提交
761
			laarr[0].extLength = EXT_NOT_RECORDED_NOT_ALLOCATED;
762
			/* Will udf_do_extend_file() create real extent from
M
Marcin Slusarz 已提交
763
			   a fake one? */
J
Jan Kara 已提交
764 765 766
			startnum = (offset > 0);
		}
		/* Create extents for the hole between EOF and offset */
767 768
		ret = udf_do_extend_file(inode, &prev_epos, laarr, offset);
		if (ret < 0) {
J
Jan Kara 已提交
769 770 771
			brelse(prev_epos.bh);
			brelse(cur_epos.bh);
			brelse(next_epos.bh);
772
			*err = ret;
773
			return 0;
J
Jan Kara 已提交
774 775 776 777 778
		}
		c = 0;
		offset = 0;
		count += ret;
		/* We are not covered by a preallocated extent? */
M
Marcin Slusarz 已提交
779 780
		if ((laarr[0].extLength & UDF_EXTENT_FLAG_MASK) !=
						EXT_NOT_RECORDED_ALLOCATED) {
J
Jan Kara 已提交
781 782 783 784 785
			/* Is there any real extent? - otherwise we overwrite
			 * the fake one... */
			if (count)
				c = !c;
			laarr[c].extLength = EXT_NOT_RECORDED_NOT_ALLOCATED |
786
				inode->i_sb->s_blocksize;
M
Marcin Slusarz 已提交
787
			memset(&laarr[c].extLocation, 0x00,
788
				sizeof(struct kernel_lb_addr));
789
			count++;
J
Jan Kara 已提交
790
		}
791
		endnum = c + 1;
L
Linus Torvalds 已提交
792
		lastblock = 1;
793
	} else {
794
		isBeyondEOF = false;
L
Linus Torvalds 已提交
795 796
		endnum = startnum = ((count > 2) ? 2 : count);

M
Marcin Slusarz 已提交
797 798
		/* if the current extent is in position 0,
		   swap it with the previous */
799
		if (!c && count != 1) {
J
Jan Kara 已提交
800 801 802 803 804
			laarr[2] = laarr[0];
			laarr[0] = laarr[1];
			laarr[1] = laarr[2];
			c = 1;
		}
L
Linus Torvalds 已提交
805

M
Marcin Slusarz 已提交
806 807 808 809
		/* 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) {
810 811 812 813 814
			laarr[c + 1].extLength = (etype << 30) | elen;
			laarr[c + 1].extLocation = eloc;
			count++;
			startnum++;
			endnum++;
M
Marcin Slusarz 已提交
815
		} else
L
Linus Torvalds 已提交
816 817 818 819
			lastblock = 1;
	}

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

827
		if (!goal) {
M
Marcin Slusarz 已提交
828
			if (!(goal = pgoal)) /* XXX: what was intended here? */
829
				goal = iinfo->i_location.logicalBlockNum + 1;
L
Linus Torvalds 已提交
830 831
		}

M
Marcin Slusarz 已提交
832
		newblocknum = udf_new_block(inode->i_sb, inode,
833
				iinfo->i_location.partitionReferenceNum,
M
Marcin Slusarz 已提交
834 835
				goal, err);
		if (!newblocknum) {
J
Jan Kara 已提交
836
			brelse(prev_epos.bh);
837 838
			brelse(cur_epos.bh);
			brelse(next_epos.bh);
L
Linus Torvalds 已提交
839
			*err = -ENOSPC;
840
			return 0;
L
Linus Torvalds 已提交
841
		}
842 843
		if (isBeyondEOF)
			iinfo->i_lenExtents += inode->i_sb->s_blocksize;
L
Linus Torvalds 已提交
844 845
	}

M
Marcin Slusarz 已提交
846 847 848 849
	/* 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 已提交
850 851 852
	udf_split_extents(inode, &c, offset, newblocknum, laarr, &endnum);

#ifdef UDF_PREALLOCATE
853 854 855 856 857 858
	/* 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 已提交
859 860 861 862 863 864
#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
865 866
	 * 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 已提交
867
	udf_update_extents(inode, laarr, startnum, endnum, &prev_epos);
L
Linus Torvalds 已提交
868

J
Jan Kara 已提交
869
	brelse(prev_epos.bh);
870 871
	brelse(cur_epos.bh);
	brelse(next_epos.bh);
L
Linus Torvalds 已提交
872

M
Marcin Slusarz 已提交
873
	newblock = udf_get_pblock(inode->i_sb, newblocknum,
874
				iinfo->i_location.partitionReferenceNum, 0);
875 876 877 878
	if (!newblock) {
		*err = -EIO;
		return 0;
	}
L
Linus Torvalds 已提交
879
	*new = 1;
880 881
	iinfo->i_next_alloc_block = block;
	iinfo->i_next_alloc_goal = newblocknum;
L
Linus Torvalds 已提交
882 883 884 885 886 887
	inode->i_ctime = current_fs_time(inode->i_sb);

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

889
	return newblock;
L
Linus Torvalds 已提交
890 891
}

892 893
static void udf_split_extents(struct inode *inode, int *c, int offset,
			      int newblocknum,
894
			      struct kernel_long_ad laarr[EXTENT_MERGE_SIZE],
895
			      int *endnum)
L
Linus Torvalds 已提交
896
{
M
Marcin Slusarz 已提交
897 898 899
	unsigned long blocksize = inode->i_sb->s_blocksize;
	unsigned char blocksize_bits = inode->i_sb->s_blocksize_bits;

L
Linus Torvalds 已提交
900
	if ((laarr[*c].extLength >> 30) == (EXT_NOT_RECORDED_ALLOCATED >> 30) ||
M
Marcin Slusarz 已提交
901 902
	    (laarr[*c].extLength >> 30) ==
				(EXT_NOT_RECORDED_NOT_ALLOCATED >> 30)) {
L
Linus Torvalds 已提交
903 904
		int curr = *c;
		int blen = ((laarr[curr].extLength & UDF_EXTENT_LENGTH_MASK) +
M
Marcin Slusarz 已提交
905
			    blocksize - 1) >> blocksize_bits;
L
Linus Torvalds 已提交
906 907
		int8_t etype = (laarr[curr].extLength >> 30);

M
Marcin Slusarz 已提交
908
		if (blen == 1)
909
			;
M
Marcin Slusarz 已提交
910
		else if (!offset || blen == offset + 1) {
911 912 913 914 915 916 917 918 919
			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 已提交
920
				udf_free_blocks(inode->i_sb, inode,
921
						&laarr[curr].extLocation,
M
Marcin Slusarz 已提交
922 923 924 925
						0, offset);
				laarr[curr].extLength =
					EXT_NOT_RECORDED_NOT_ALLOCATED |
					(offset << blocksize_bits);
L
Linus Torvalds 已提交
926
				laarr[curr].extLocation.logicalBlockNum = 0;
M
Marcin Slusarz 已提交
927 928 929
				laarr[curr].extLocation.
						partitionReferenceNum = 0;
			} else
L
Linus Torvalds 已提交
930
				laarr[curr].extLength = (etype << 30) |
M
Marcin Slusarz 已提交
931
					(offset << blocksize_bits);
932 933 934
			curr++;
			(*c)++;
			(*endnum)++;
L
Linus Torvalds 已提交
935
		}
936

L
Linus Torvalds 已提交
937 938 939
		laarr[curr].extLocation.logicalBlockNum = newblocknum;
		if (etype == (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30))
			laarr[curr].extLocation.partitionReferenceNum =
940
				UDF_I(inode)->i_location.partitionReferenceNum;
L
Linus Torvalds 已提交
941
		laarr[curr].extLength = EXT_RECORDED_ALLOCATED |
M
Marcin Slusarz 已提交
942
			blocksize;
943
		curr++;
L
Linus Torvalds 已提交
944

945
		if (blen != offset + 1) {
L
Linus Torvalds 已提交
946
			if (etype == (EXT_NOT_RECORDED_ALLOCATED >> 30))
M
Marcin Slusarz 已提交
947 948
				laarr[curr].extLocation.logicalBlockNum +=
								offset + 1;
949
			laarr[curr].extLength = (etype << 30) |
M
Marcin Slusarz 已提交
950
				((blen - (offset + 1)) << blocksize_bits);
951 952
			curr++;
			(*endnum)++;
L
Linus Torvalds 已提交
953 954 955 956 957
		}
	}
}

static void udf_prealloc_extents(struct inode *inode, int c, int lastblock,
958
				 struct kernel_long_ad laarr[EXTENT_MERGE_SIZE],
959
				 int *endnum)
L
Linus Torvalds 已提交
960 961 962
{
	int start, length = 0, currlength = 0, i;

963
	if (*endnum >= (c + 1)) {
L
Linus Torvalds 已提交
964 965 966 967
		if (!lastblock)
			return;
		else
			start = c;
968
	} else {
M
Marcin Slusarz 已提交
969 970
		if ((laarr[c + 1].extLength >> 30) ==
					(EXT_NOT_RECORDED_ALLOCATED >> 30)) {
971
			start = c + 1;
M
Marcin Slusarz 已提交
972 973 974 975 976 977
			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 已提交
978 979 980
			start = c;
	}

981 982
	for (i = start + 1; i <= *endnum; i++) {
		if (i == *endnum) {
L
Linus Torvalds 已提交
983 984
			if (lastblock)
				length += UDF_DEFAULT_PREALLOC_BLOCKS;
M
Marcin Slusarz 已提交
985 986 987 988 989 990 991
		} 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 已提交
992 993 994
			break;
	}

995
	if (length) {
L
Linus Torvalds 已提交
996
		int next = laarr[start].extLocation.logicalBlockNum +
997
			(((laarr[start].extLength & UDF_EXTENT_LENGTH_MASK) +
M
Marcin Slusarz 已提交
998 999
			  inode->i_sb->s_blocksize - 1) >>
			  inode->i_sb->s_blocksize_bits);
L
Linus Torvalds 已提交
1000
		int numalloc = udf_prealloc_blocks(inode->i_sb, inode,
M
Marcin Slusarz 已提交
1001 1002 1003 1004
				laarr[start].extLocation.partitionReferenceNum,
				next, (UDF_DEFAULT_PREALLOC_BLOCKS > length ?
				length : UDF_DEFAULT_PREALLOC_BLOCKS) -
				currlength);
1005
		if (numalloc) 	{
M
Marcin Slusarz 已提交
1006
			if (start == (c + 1))
L
Linus Torvalds 已提交
1007
				laarr[start].extLength +=
M
Marcin Slusarz 已提交
1008 1009 1010
					(numalloc <<
					 inode->i_sb->s_blocksize_bits);
			else {
1011
				memmove(&laarr[c + 2], &laarr[c + 1],
1012
					sizeof(struct long_ad) * (*endnum - (c + 1)));
1013 1014 1015
				(*endnum)++;
				laarr[c + 1].extLocation.logicalBlockNum = next;
				laarr[c + 1].extLocation.partitionReferenceNum =
M
Marcin Slusarz 已提交
1016 1017 1018 1019 1020 1021
					laarr[c].extLocation.
							partitionReferenceNum;
				laarr[c + 1].extLength =
					EXT_NOT_RECORDED_ALLOCATED |
					(numalloc <<
					 inode->i_sb->s_blocksize_bits);
1022
				start = c + 1;
L
Linus Torvalds 已提交
1023 1024
			}

1025
			for (i = start + 1; numalloc && i < *endnum; i++) {
M
Marcin Slusarz 已提交
1026 1027 1028 1029
				int elen = ((laarr[i].extLength &
						UDF_EXTENT_LENGTH_MASK) +
					    inode->i_sb->s_blocksize - 1) >>
					    inode->i_sb->s_blocksize_bits;
L
Linus Torvalds 已提交
1030

1031
				if (elen > numalloc) {
L
Linus Torvalds 已提交
1032
					laarr[i].extLength -=
M
Marcin Slusarz 已提交
1033 1034
						(numalloc <<
						 inode->i_sb->s_blocksize_bits);
L
Linus Torvalds 已提交
1035
					numalloc = 0;
1036
				} else {
L
Linus Torvalds 已提交
1037
					numalloc -= elen;
1038
					if (*endnum > (i + 1))
M
Marcin Slusarz 已提交
1039 1040
						memmove(&laarr[i],
							&laarr[i + 1],
1041
							sizeof(struct long_ad) *
M
Marcin Slusarz 已提交
1042
							(*endnum - (i + 1)));
1043 1044
					i--;
					(*endnum)--;
L
Linus Torvalds 已提交
1045 1046
				}
			}
1047
			UDF_I(inode)->i_lenExtents +=
M
Marcin Slusarz 已提交
1048
				numalloc << inode->i_sb->s_blocksize_bits;
L
Linus Torvalds 已提交
1049 1050 1051 1052 1053
		}
	}
}

static void udf_merge_extents(struct inode *inode,
1054
			      struct kernel_long_ad laarr[EXTENT_MERGE_SIZE],
1055
			      int *endnum)
L
Linus Torvalds 已提交
1056 1057
{
	int i;
M
Marcin Slusarz 已提交
1058 1059
	unsigned long blocksize = inode->i_sb->s_blocksize;
	unsigned char blocksize_bits = inode->i_sb->s_blocksize_bits;
L
Linus Torvalds 已提交
1060

1061
	for (i = 0; i < (*endnum - 1); i++) {
1062 1063
		struct kernel_long_ad *li /*l[i]*/ = &laarr[i];
		struct kernel_long_ad *lip1 /*l[i plus 1]*/ = &laarr[i + 1];
M
Marcin Slusarz 已提交
1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096

		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],
1097
						sizeof(struct long_ad) *
M
Marcin Slusarz 已提交
1098 1099 1100
						(*endnum - (i + 2)));
				i--;
				(*endnum)--;
L
Linus Torvalds 已提交
1101
			}
M
Marcin Slusarz 已提交
1102 1103 1104 1105
		} else if (((li->extLength >> 30) ==
				(EXT_NOT_RECORDED_ALLOCATED >> 30)) &&
			   ((lip1->extLength >> 30) ==
				(EXT_NOT_RECORDED_NOT_ALLOCATED >> 30))) {
1106
			udf_free_blocks(inode->i_sb, inode, &li->extLocation, 0,
M
Marcin Slusarz 已提交
1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124
					((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;
1125
			} else {
M
Marcin Slusarz 已提交
1126 1127 1128 1129
				li->extLength = lip1->extLength +
					(((li->extLength &
						UDF_EXTENT_LENGTH_MASK) +
					  blocksize - 1) & ~(blocksize - 1));
1130 1131
				if (*endnum > (i + 2))
					memmove(&laarr[i + 1], &laarr[i + 2],
1132
						sizeof(struct long_ad) *
M
Marcin Slusarz 已提交
1133
						(*endnum - (i + 2)));
1134 1135
				i--;
				(*endnum)--;
L
Linus Torvalds 已提交
1136
			}
M
Marcin Slusarz 已提交
1137 1138 1139
		} else if ((li->extLength >> 30) ==
					(EXT_NOT_RECORDED_ALLOCATED >> 30)) {
			udf_free_blocks(inode->i_sb, inode,
1140
					&li->extLocation, 0,
M
Marcin Slusarz 已提交
1141 1142 1143 1144 1145 1146 1147 1148
					((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 已提交
1149 1150 1151 1152 1153
		}
	}
}

static void udf_update_extents(struct inode *inode,
1154
			       struct kernel_long_ad laarr[EXTENT_MERGE_SIZE],
1155 1156
			       int startnum, int endnum,
			       struct extent_position *epos)
L
Linus Torvalds 已提交
1157 1158
{
	int start = 0, i;
1159
	struct kernel_lb_addr tmploc;
L
Linus Torvalds 已提交
1160 1161
	uint32_t tmplen;

1162 1163
	if (startnum > endnum) {
		for (i = 0; i < (startnum - endnum); i++)
J
Jan Kara 已提交
1164
			udf_delete_aext(inode, *epos, laarr[i].extLocation,
1165 1166 1167
					laarr[i].extLength);
	} else if (startnum < endnum) {
		for (i = 0; i < (endnum - startnum); i++) {
J
Jan Kara 已提交
1168
			udf_insert_aext(inode, *epos, laarr[i].extLocation,
1169
					laarr[i].extLength);
J
Jan Kara 已提交
1170
			udf_next_aext(inode, epos, &laarr[i].extLocation,
1171 1172
				      &laarr[i].extLength, 1);
			start++;
L
Linus Torvalds 已提交
1173 1174 1175
		}
	}

1176
	for (i = start; i < endnum; i++) {
J
Jan Kara 已提交
1177
		udf_next_aext(inode, epos, &tmploc, &tmplen, 0);
1178
		udf_write_aext(inode, epos, &laarr[i].extLocation,
1179
			       laarr[i].extLength, 1);
L
Linus Torvalds 已提交
1180 1181 1182
	}
}

1183 1184
struct buffer_head *udf_bread(struct inode *inode, int block,
			      int create, int *err)
L
Linus Torvalds 已提交
1185
{
1186
	struct buffer_head *bh = NULL;
L
Linus Torvalds 已提交
1187 1188 1189 1190 1191 1192 1193

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

	if (buffer_uptodate(bh))
		return bh;
1194

L
Linus Torvalds 已提交
1195
	ll_rw_block(READ, 1, &bh);
1196

L
Linus Torvalds 已提交
1197 1198 1199
	wait_on_buffer(bh);
	if (buffer_uptodate(bh))
		return bh;
1200

L
Linus Torvalds 已提交
1201 1202 1203 1204 1205
	brelse(bh);
	*err = -EIO;
	return NULL;
}

1206
int udf_setsize(struct inode *inode, loff_t newsize)
L
Linus Torvalds 已提交
1207 1208
{
	int err;
1209
	struct udf_inode_info *iinfo;
1210
	int bsize = 1 << inode->i_blkbits;
L
Linus Torvalds 已提交
1211 1212

	if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
1213
	      S_ISLNK(inode->i_mode)))
1214
		return -EINVAL;
L
Linus Torvalds 已提交
1215
	if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
1216
		return -EPERM;
L
Linus Torvalds 已提交
1217

1218
	iinfo = UDF_I(inode);
1219
	if (newsize > inode->i_size) {
1220
		down_write(&iinfo->i_data_sem);
1221 1222 1223 1224
		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);
1225
				if (err)
1226
					return err;
1227
				down_write(&iinfo->i_data_sem);
1228
			} else {
1229
				iinfo->i_lenAlloc = newsize;
1230 1231
				goto set_size;
			}
1232 1233 1234 1235 1236
		}
		err = udf_extend_file(inode, newsize);
		if (err) {
			up_write(&iinfo->i_data_sem);
			return err;
L
Linus Torvalds 已提交
1237
		}
1238
set_size:
1239
		truncate_setsize(inode, newsize);
1240
		up_write(&iinfo->i_data_sem);
1241
	} else {
1242 1243
		if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {
			down_write(&iinfo->i_data_sem);
1244
			udf_clear_extent_cache(inode);
1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256
			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;
1257
		down_write(&iinfo->i_data_sem);
1258
		udf_clear_extent_cache(inode);
1259
		truncate_setsize(inode, newsize);
L
Linus Torvalds 已提交
1260
		udf_truncate_extents(inode);
1261
		up_write(&iinfo->i_data_sem);
1262
	}
1263
update_time:
L
Linus Torvalds 已提交
1264 1265
	inode->i_mtime = inode->i_ctime = current_fs_time(inode->i_sb);
	if (IS_SYNC(inode))
1266
		udf_sync_inode(inode);
L
Linus Torvalds 已提交
1267 1268
	else
		mark_inode_dirty(inode);
1269
	return 0;
L
Linus Torvalds 已提交
1270 1271
}

1272 1273 1274 1275 1276 1277 1278
/*
 * Maximum length of linked list formed by ICB hierarchy. The chosen number is
 * arbitrary - just that we hopefully don't limit any real use of rewritten
 * inode on write-once media but avoid looping for too long on corrupted media.
 */
#define UDF_MAX_ICB_NESTING 1024

J
Jan Kara 已提交
1279
static int udf_read_inode(struct inode *inode, bool hidden_inode)
L
Linus Torvalds 已提交
1280 1281 1282
{
	struct buffer_head *bh = NULL;
	struct fileEntry *fe;
1283
	struct extendedFileEntry *efe;
L
Linus Torvalds 已提交
1284
	uint16_t ident;
1285
	struct udf_inode_info *iinfo = UDF_I(inode);
1286
	struct udf_sb_info *sbi = UDF_SB(inode->i_sb);
1287
	struct kernel_lb_addr *iloc = &iinfo->i_location;
1288
	unsigned int link_count;
1289
	unsigned int indirections = 0;
J
Jan Kara 已提交
1290
	int bs = inode->i_sb->s_blocksize;
1291
	int ret = -EIO;
L
Linus Torvalds 已提交
1292

1293
reread:
1294 1295 1296 1297 1298 1299 1300
	if (iloc->logicalBlockNum >=
	    sbi->s_partmaps[iloc->partitionReferenceNum].s_partition_len) {
		udf_debug("block=%d, partition=%d out of range\n",
			  iloc->logicalBlockNum, iloc->partitionReferenceNum);
		return -EIO;
	}

L
Linus Torvalds 已提交
1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312
	/*
	 * 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;
	 */
1313
	bh = udf_read_ptagged(inode->i_sb, iloc, 0, &ident);
1314
	if (!bh) {
J
Joe Perches 已提交
1315
		udf_err(inode->i_sb, "(ino %ld) failed !bh\n", inode->i_ino);
1316
		return -EIO;
L
Linus Torvalds 已提交
1317 1318 1319
	}

	if (ident != TAG_IDENT_FE && ident != TAG_IDENT_EFE &&
1320
	    ident != TAG_IDENT_USE) {
J
Joe Perches 已提交
1321 1322
		udf_err(inode->i_sb, "(ino %ld) failed ident=%d\n",
			inode->i_ino, ident);
1323
		goto out;
L
Linus Torvalds 已提交
1324 1325 1326
	}

	fe = (struct fileEntry *)bh->b_data;
1327
	efe = (struct extendedFileEntry *)bh->b_data;
L
Linus Torvalds 已提交
1328

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

1332
		ibh = udf_read_ptagged(inode->i_sb, iloc, 1, &ident);
1333
		if (ident == TAG_IDENT_IE && ibh) {
1334
			struct kernel_lb_addr loc;
1335 1336 1337 1338 1339
			struct indirectEntry *ie;

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

1340 1341 1342 1343 1344 1345 1346 1347 1348
			if (ie->indirectICB.extLength) {
				brelse(ibh);
				memcpy(&iinfo->i_location, &loc,
				       sizeof(struct kernel_lb_addr));
				if (++indirections > UDF_MAX_ICB_NESTING) {
					udf_err(inode->i_sb,
						"too many ICBs in ICB hierarchy"
						" (max %d supported)\n",
						UDF_MAX_ICB_NESTING);
1349
					goto out;
1350
				}
1351
				brelse(bh);
1352
				goto reread;
L
Linus Torvalds 已提交
1353
			}
1354
		}
1355
		brelse(ibh);
1356
	} else if (fe->icbTag.strategyType != cpu_to_le16(4)) {
J
Joe Perches 已提交
1357 1358
		udf_err(inode->i_sb, "unsupported strategy type: %d\n",
			le16_to_cpu(fe->icbTag.strategyType));
1359
		goto out;
L
Linus Torvalds 已提交
1360
	}
1361
	if (fe->icbTag.strategyType == cpu_to_le16(4))
1362
		iinfo->i_strat4096 = 0;
1363
	else /* if (fe->icbTag.strategyType == cpu_to_le16(4096)) */
1364
		iinfo->i_strat4096 = 1;
L
Linus Torvalds 已提交
1365

1366
	iinfo->i_alloc_type = le16_to_cpu(fe->icbTag.flags) &
M
Marcin Slusarz 已提交
1367
							ICBTAG_FLAG_AD_MASK;
1368 1369 1370 1371 1372 1373
	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;
1374
	if (fe->descTag.tagIdent == cpu_to_le16(TAG_IDENT_EFE)) {
1375 1376
		iinfo->i_efe = 1;
		iinfo->i_use = 0;
J
Jan Kara 已提交
1377
		ret = udf_alloc_i_data(inode, bs -
1378 1379 1380
					sizeof(struct extendedFileEntry));
		if (ret)
			goto out;
1381
		memcpy(iinfo->i_ext.i_data,
M
Marcin Slusarz 已提交
1382
		       bh->b_data + sizeof(struct extendedFileEntry),
J
Jan Kara 已提交
1383
		       bs - sizeof(struct extendedFileEntry));
1384
	} else if (fe->descTag.tagIdent == cpu_to_le16(TAG_IDENT_FE)) {
1385 1386
		iinfo->i_efe = 0;
		iinfo->i_use = 0;
J
Jan Kara 已提交
1387
		ret = udf_alloc_i_data(inode, bs - sizeof(struct fileEntry));
1388 1389
		if (ret)
			goto out;
1390
		memcpy(iinfo->i_ext.i_data,
1391
		       bh->b_data + sizeof(struct fileEntry),
J
Jan Kara 已提交
1392
		       bs - sizeof(struct fileEntry));
1393
	} else if (fe->descTag.tagIdent == cpu_to_le16(TAG_IDENT_USE)) {
1394 1395 1396
		iinfo->i_efe = 0;
		iinfo->i_use = 1;
		iinfo->i_lenAlloc = le32_to_cpu(
M
Marcin Slusarz 已提交
1397 1398
				((struct unallocSpaceEntry *)bh->b_data)->
				 lengthAllocDescs);
J
Jan Kara 已提交
1399
		ret = udf_alloc_i_data(inode, bs -
1400 1401 1402
					sizeof(struct unallocSpaceEntry));
		if (ret)
			goto out;
1403
		memcpy(iinfo->i_ext.i_data,
M
Marcin Slusarz 已提交
1404
		       bh->b_data + sizeof(struct unallocSpaceEntry),
J
Jan Kara 已提交
1405
		       bs - sizeof(struct unallocSpaceEntry));
1406
		return 0;
L
Linus Torvalds 已提交
1407 1408
	}

1409
	ret = -EIO;
1410
	read_lock(&sbi->s_cred_lock);
1411 1412
	i_uid_write(inode, le32_to_cpu(fe->uid));
	if (!uid_valid(inode->i_uid) ||
1413 1414
	    UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_UID_IGNORE) ||
	    UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_UID_SET))
1415
		inode->i_uid = UDF_SB(inode->i_sb)->s_uid;
L
Linus Torvalds 已提交
1416

1417 1418
	i_gid_write(inode, le32_to_cpu(fe->gid));
	if (!gid_valid(inode->i_gid) ||
1419 1420
	    UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_GID_IGNORE) ||
	    UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_GID_SET))
1421
		inode->i_gid = UDF_SB(inode->i_sb)->s_gid;
L
Linus Torvalds 已提交
1422

1423
	if (fe->icbTag.fileType != ICBTAG_FILE_TYPE_DIRECTORY &&
1424
			sbi->s_fmode != UDF_INVALID_MODE)
1425 1426
		inode->i_mode = sbi->s_fmode;
	else if (fe->icbTag.fileType == ICBTAG_FILE_TYPE_DIRECTORY &&
1427
			sbi->s_dmode != UDF_INVALID_MODE)
1428 1429 1430 1431
		inode->i_mode = sbi->s_dmode;
	else
		inode->i_mode = udf_convert_permissions(fe);
	inode->i_mode &= ~sbi->s_umask;
1432 1433
	read_unlock(&sbi->s_cred_lock);

M
Miklos Szeredi 已提交
1434
	link_count = le16_to_cpu(fe->fileLinkCount);
J
Jan Kara 已提交
1435
	if (!link_count) {
J
Jan Kara 已提交
1436 1437 1438 1439 1440
		if (!hidden_inode) {
			ret = -ESTALE;
			goto out;
		}
		link_count = 1;
J
Jan Kara 已提交
1441
	}
M
Miklos Szeredi 已提交
1442
	set_nlink(inode, link_count);
1443 1444 1445

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

1447
	if (iinfo->i_efe == 0) {
L
Linus Torvalds 已提交
1448
		inode->i_blocks = le64_to_cpu(fe->logicalBlocksRecorded) <<
1449
			(inode->i_sb->s_blocksize_bits - 9);
L
Linus Torvalds 已提交
1450

1451
		if (!udf_disk_stamp_to_time(&inode->i_atime, fe->accessTime))
1452 1453
			inode->i_atime = sbi->s_record_time;

1454 1455
		if (!udf_disk_stamp_to_time(&inode->i_mtime,
					    fe->modificationTime))
1456 1457
			inode->i_mtime = sbi->s_record_time;

1458
		if (!udf_disk_stamp_to_time(&inode->i_ctime, fe->attrTime))
1459
			inode->i_ctime = sbi->s_record_time;
L
Linus Torvalds 已提交
1460

1461 1462 1463
		iinfo->i_unique = le64_to_cpu(fe->uniqueID);
		iinfo->i_lenEAttr = le32_to_cpu(fe->lengthExtendedAttr);
		iinfo->i_lenAlloc = le32_to_cpu(fe->lengthAllocDescs);
1464
		iinfo->i_checkpoint = le32_to_cpu(fe->checkpoint);
1465
	} else {
1466
		inode->i_blocks = le64_to_cpu(efe->logicalBlocksRecorded) <<
1467
		    (inode->i_sb->s_blocksize_bits - 9);
L
Linus Torvalds 已提交
1468

1469
		if (!udf_disk_stamp_to_time(&inode->i_atime, efe->accessTime))
1470 1471
			inode->i_atime = sbi->s_record_time;

1472 1473
		if (!udf_disk_stamp_to_time(&inode->i_mtime,
					    efe->modificationTime))
1474 1475
			inode->i_mtime = sbi->s_record_time;

1476
		if (!udf_disk_stamp_to_time(&iinfo->i_crtime, efe->createTime))
1477 1478
			iinfo->i_crtime = sbi->s_record_time;

1479
		if (!udf_disk_stamp_to_time(&inode->i_ctime, efe->attrTime))
1480
			inode->i_ctime = sbi->s_record_time;
L
Linus Torvalds 已提交
1481

1482 1483 1484
		iinfo->i_unique = le64_to_cpu(efe->uniqueID);
		iinfo->i_lenEAttr = le32_to_cpu(efe->lengthExtendedAttr);
		iinfo->i_lenAlloc = le32_to_cpu(efe->lengthAllocDescs);
1485
		iinfo->i_checkpoint = le32_to_cpu(efe->checkpoint);
L
Linus Torvalds 已提交
1486
	}
J
Jan Kara 已提交
1487
	inode->i_generation = iinfo->i_unique;
L
Linus Torvalds 已提交
1488

1489 1490 1491 1492 1493 1494 1495 1496 1497
	/*
	 * Sanity check length of allocation descriptors and extended attrs to
	 * avoid integer overflows
	 */
	if (iinfo->i_lenEAttr > bs || iinfo->i_lenAlloc > bs)
		goto out;
	/* Now do exact checks */
	if (udf_file_entry_alloc_offset(inode) + iinfo->i_lenAlloc > bs)
		goto out;
J
Jan Kara 已提交
1498 1499 1500 1501 1502 1503 1504 1505 1506
	/* Sanity checks for files in ICB so that we don't get confused later */
	if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {
		/*
		 * For file in ICB data is stored in allocation descriptor
		 * so sizes should match
		 */
		if (iinfo->i_lenAlloc != inode->i_size)
			goto out;
		/* File in ICB has to fit in there... */
J
Jan Kara 已提交
1507
		if (inode->i_size > bs - udf_file_entry_alloc_offset(inode))
J
Jan Kara 已提交
1508 1509 1510
			goto out;
	}

1511 1512
	switch (fe->icbTag.fileType) {
	case ICBTAG_FILE_TYPE_DIRECTORY:
1513 1514 1515 1516 1517
		inode->i_op = &udf_dir_inode_operations;
		inode->i_fop = &udf_dir_operations;
		inode->i_mode |= S_IFDIR;
		inc_nlink(inode);
		break;
1518 1519 1520
	case ICBTAG_FILE_TYPE_REALTIME:
	case ICBTAG_FILE_TYPE_REGULAR:
	case ICBTAG_FILE_TYPE_UNDEF:
J
Jan Kara 已提交
1521
	case ICBTAG_FILE_TYPE_VAT20:
1522
		if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
1523 1524 1525 1526 1527 1528 1529
			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;
1530
	case ICBTAG_FILE_TYPE_BLOCK:
1531 1532
		inode->i_mode |= S_IFBLK;
		break;
1533
	case ICBTAG_FILE_TYPE_CHAR:
1534 1535
		inode->i_mode |= S_IFCHR;
		break;
1536
	case ICBTAG_FILE_TYPE_FIFO:
1537 1538
		init_special_inode(inode, inode->i_mode | S_IFIFO, 0);
		break;
1539
	case ICBTAG_FILE_TYPE_SOCKET:
1540 1541
		init_special_inode(inode, inode->i_mode | S_IFSOCK, 0);
		break;
1542
	case ICBTAG_FILE_TYPE_SYMLINK:
1543
		inode->i_data.a_ops = &udf_symlink_aops;
1544
		inode->i_op = &udf_symlink_inode_operations;
1545 1546
		inode->i_mode = S_IFLNK | S_IRWXUGO;
		break;
1547 1548 1549 1550 1551 1552 1553 1554 1555
	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;
1556
	default:
J
Joe Perches 已提交
1557 1558
		udf_err(inode->i_sb, "(ino %ld) failed unknown file type=%d\n",
			inode->i_ino, fe->icbTag.fileType);
1559
		goto out;
L
Linus Torvalds 已提交
1560
	}
1561
	if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) {
M
Marcin Slusarz 已提交
1562 1563
		struct deviceSpec *dsea =
			(struct deviceSpec *)udf_get_extendedattr(inode, 12, 1);
1564 1565
		if (dsea) {
			init_special_inode(inode, inode->i_mode,
M
Marcin Slusarz 已提交
1566 1567
				MKDEV(le32_to_cpu(dsea->majorDeviceIdent),
				      le32_to_cpu(dsea->minorDeviceIdent)));
L
Linus Torvalds 已提交
1568
			/* Developer ID ??? */
M
Marcin Slusarz 已提交
1569
		} else
1570
			goto out;
L
Linus Torvalds 已提交
1571
	}
1572 1573
	ret = 0;
out:
1574
	brelse(bh);
1575
	return ret;
L
Linus Torvalds 已提交
1576 1577
}

1578 1579
static int udf_alloc_i_data(struct inode *inode, size_t size)
{
1580 1581
	struct udf_inode_info *iinfo = UDF_I(inode);
	iinfo->i_ext.i_data = kmalloc(size, GFP_KERNEL);
1582

1583
	if (!iinfo->i_ext.i_data) {
J
Joe Perches 已提交
1584 1585
		udf_err(inode->i_sb, "(ino %ld) no free memory\n",
			inode->i_ino);
1586 1587 1588 1589 1590 1591
		return -ENOMEM;
	}

	return 0;
}

A
Al Viro 已提交
1592
static umode_t udf_convert_permissions(struct fileEntry *fe)
L
Linus Torvalds 已提交
1593
{
A
Al Viro 已提交
1594
	umode_t mode;
L
Linus Torvalds 已提交
1595 1596 1597 1598 1599 1600
	uint32_t permissions;
	uint32_t flags;

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

M
Marcin Slusarz 已提交
1601 1602 1603 1604 1605 1606
	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 已提交
1607 1608 1609 1610

	return mode;
}

1611
int udf_write_inode(struct inode *inode, struct writeback_control *wbc)
L
Linus Torvalds 已提交
1612
{
J
Jan Kara 已提交
1613
	return udf_update_inode(inode, wbc->sync_mode == WB_SYNC_ALL);
L
Linus Torvalds 已提交
1614 1615
}

J
Jan Kara 已提交
1616
static int udf_sync_inode(struct inode *inode)
L
Linus Torvalds 已提交
1617 1618 1619 1620
{
	return udf_update_inode(inode, 1);
}

1621
static int udf_update_inode(struct inode *inode, int do_sync)
L
Linus Torvalds 已提交
1622 1623 1624 1625
{
	struct buffer_head *bh = NULL;
	struct fileEntry *fe;
	struct extendedFileEntry *efe;
1626
	uint64_t lb_recorded;
L
Linus Torvalds 已提交
1627 1628 1629 1630
	uint32_t udfperms;
	uint16_t icbflags;
	uint16_t crclen;
	int err = 0;
M
Marcin Slusarz 已提交
1631
	struct udf_sb_info *sbi = UDF_SB(inode->i_sb);
M
Marcin Slusarz 已提交
1632
	unsigned char blocksize_bits = inode->i_sb->s_blocksize_bits;
1633
	struct udf_inode_info *iinfo = UDF_I(inode);
L
Linus Torvalds 已提交
1634

1635 1636
	bh = udf_tgetblk(inode->i_sb,
			udf_get_lb_pblock(inode->i_sb, &iinfo->i_location, 0));
1637
	if (!bh) {
1638 1639
		udf_debug("getblk failure\n");
		return -ENOMEM;
L
Linus Torvalds 已提交
1640 1641
	}

1642 1643
	lock_buffer(bh);
	memset(bh->b_data, 0, inode->i_sb->s_blocksize);
L
Linus Torvalds 已提交
1644 1645 1646
	fe = (struct fileEntry *)bh->b_data;
	efe = (struct extendedFileEntry *)bh->b_data;

1647
	if (iinfo->i_use) {
L
Linus Torvalds 已提交
1648
		struct unallocSpaceEntry *use =
1649
			(struct unallocSpaceEntry *)bh->b_data;
L
Linus Torvalds 已提交
1650

1651
		use->lengthAllocDescs = cpu_to_le32(iinfo->i_lenAlloc);
M
Marcin Slusarz 已提交
1652
		memcpy(bh->b_data + sizeof(struct unallocSpaceEntry),
1653
		       iinfo->i_ext.i_data, inode->i_sb->s_blocksize -
M
Marcin Slusarz 已提交
1654
					sizeof(struct unallocSpaceEntry));
1655 1656 1657
		use->descTag.tagIdent = cpu_to_le16(TAG_IDENT_USE);
		use->descTag.tagLocation =
				cpu_to_le32(iinfo->i_location.logicalBlockNum);
M
Marcin Slusarz 已提交
1658
		crclen = sizeof(struct unallocSpaceEntry) +
1659
				iinfo->i_lenAlloc - sizeof(struct tag);
L
Linus Torvalds 已提交
1660
		use->descTag.descCRCLength = cpu_to_le16(crclen);
1661
		use->descTag.descCRC = cpu_to_le16(crc_itu_t(0, (char *)use +
1662
							   sizeof(struct tag),
1663
							   crclen));
1664
		use->descTag.tagChecksum = udf_tag_checksum(&use->descTag);
L
Linus Torvalds 已提交
1665

1666
		goto out;
L
Linus Torvalds 已提交
1667 1668
	}

1669 1670
	if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_UID_FORGET))
		fe->uid = cpu_to_le32(-1);
1671
	else
1672
		fe->uid = cpu_to_le32(i_uid_read(inode));
L
Linus Torvalds 已提交
1673

1674 1675
	if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_GID_FORGET))
		fe->gid = cpu_to_le32(-1);
1676
	else
1677
		fe->gid = cpu_to_le32(i_gid_read(inode));
L
Linus Torvalds 已提交
1678

M
Marcin Slusarz 已提交
1679 1680 1681
	udfperms = ((inode->i_mode & S_IRWXO)) |
		   ((inode->i_mode & S_IRWXG) << 2) |
		   ((inode->i_mode & S_IRWXU) << 4);
L
Linus Torvalds 已提交
1682

M
Marcin Slusarz 已提交
1683 1684 1685 1686
	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 已提交
1687 1688
	fe->permissions = cpu_to_le32(udfperms);

1689
	if (S_ISDIR(inode->i_mode) && inode->i_nlink > 0)
L
Linus Torvalds 已提交
1690 1691 1692 1693 1694 1695
		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);

1696
	if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) {
1697
		struct regid *eid;
1698 1699
		struct deviceSpec *dsea =
			(struct deviceSpec *)udf_get_extendedattr(inode, 12, 1);
1700
		if (!dsea) {
L
Linus Torvalds 已提交
1701
			dsea = (struct deviceSpec *)
1702 1703
				udf_add_extendedattr(inode,
						     sizeof(struct deviceSpec) +
1704
						     sizeof(struct regid), 12, 0x3);
L
Linus Torvalds 已提交
1705 1706
			dsea->attrType = cpu_to_le32(12);
			dsea->attrSubtype = 1;
M
Marcin Slusarz 已提交
1707 1708
			dsea->attrLength = cpu_to_le32(
						sizeof(struct deviceSpec) +
1709 1710
						sizeof(struct regid));
			dsea->impUseLength = cpu_to_le32(sizeof(struct regid));
L
Linus Torvalds 已提交
1711
		}
1712 1713
		eid = (struct regid *)dsea->impUse;
		memset(eid, 0, sizeof(struct regid));
L
Linus Torvalds 已提交
1714 1715 1716 1717 1718 1719 1720
		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));
	}

1721 1722 1723 1724 1725 1726 1727
	if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
		lb_recorded = 0; /* No extents => no blocks! */
	else
		lb_recorded =
			(inode->i_blocks + (1 << (blocksize_bits - 9)) - 1) >>
			(blocksize_bits - 9);

1728
	if (iinfo->i_efe == 0) {
1729
		memcpy(bh->b_data + sizeof(struct fileEntry),
1730
		       iinfo->i_ext.i_data,
1731
		       inode->i_sb->s_blocksize - sizeof(struct fileEntry));
1732
		fe->logicalBlocksRecorded = cpu_to_le64(lb_recorded);
L
Linus Torvalds 已提交
1733

1734 1735 1736
		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);
1737
		memset(&(fe->impIdent), 0, sizeof(struct regid));
L
Linus Torvalds 已提交
1738 1739 1740
		strcpy(fe->impIdent.ident, UDF_ID_DEVELOPER);
		fe->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX;
		fe->impIdent.identSuffix[1] = UDF_OS_ID_LINUX;
1741 1742 1743
		fe->uniqueID = cpu_to_le64(iinfo->i_unique);
		fe->lengthExtendedAttr = cpu_to_le32(iinfo->i_lenEAttr);
		fe->lengthAllocDescs = cpu_to_le32(iinfo->i_lenAlloc);
1744
		fe->checkpoint = cpu_to_le32(iinfo->i_checkpoint);
L
Linus Torvalds 已提交
1745 1746
		fe->descTag.tagIdent = cpu_to_le16(TAG_IDENT_FE);
		crclen = sizeof(struct fileEntry);
1747
	} else {
M
Marcin Slusarz 已提交
1748
		memcpy(bh->b_data + sizeof(struct extendedFileEntry),
1749
		       iinfo->i_ext.i_data,
M
Marcin Slusarz 已提交
1750 1751
		       inode->i_sb->s_blocksize -
					sizeof(struct extendedFileEntry));
L
Linus Torvalds 已提交
1752
		efe->objectSize = cpu_to_le64(inode->i_size);
1753
		efe->logicalBlocksRecorded = cpu_to_le64(lb_recorded);
L
Linus Torvalds 已提交
1754

1755 1756 1757 1758
		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 已提交
1759

1760 1761 1762 1763
		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 已提交
1764

1765 1766 1767 1768
		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 已提交
1769

1770 1771 1772 1773
		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 已提交
1774

1775
		memset(&(efe->impIdent), 0, sizeof(struct regid));
L
Linus Torvalds 已提交
1776 1777 1778
		strcpy(efe->impIdent.ident, UDF_ID_DEVELOPER);
		efe->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX;
		efe->impIdent.identSuffix[1] = UDF_OS_ID_LINUX;
1779 1780 1781
		efe->uniqueID = cpu_to_le64(iinfo->i_unique);
		efe->lengthExtendedAttr = cpu_to_le32(iinfo->i_lenEAttr);
		efe->lengthAllocDescs = cpu_to_le32(iinfo->i_lenAlloc);
1782
		efe->checkpoint = cpu_to_le32(iinfo->i_checkpoint);
L
Linus Torvalds 已提交
1783 1784 1785
		efe->descTag.tagIdent = cpu_to_le16(TAG_IDENT_EFE);
		crclen = sizeof(struct extendedFileEntry);
	}
1786
	if (iinfo->i_strat4096) {
L
Linus Torvalds 已提交
1787 1788 1789
		fe->icbTag.strategyType = cpu_to_le16(4096);
		fe->icbTag.strategyParameter = cpu_to_le16(1);
		fe->icbTag.numEntries = cpu_to_le16(2);
1790
	} else {
L
Linus Torvalds 已提交
1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809
		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;

1810
	icbflags =	iinfo->i_alloc_type |
1811 1812 1813 1814 1815 1816
			((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 已提交
1817 1818

	fe->icbTag.flags = cpu_to_le16(icbflags);
M
Marcin Slusarz 已提交
1819
	if (sbi->s_udfrev >= 0x0200)
L
Linus Torvalds 已提交
1820 1821 1822
		fe->descTag.descVersion = cpu_to_le16(3);
	else
		fe->descTag.descVersion = cpu_to_le16(2);
M
Marcin Slusarz 已提交
1823
	fe->descTag.tagSerialNum = cpu_to_le16(sbi->s_serial_number);
M
Marcin Slusarz 已提交
1824
	fe->descTag.tagLocation = cpu_to_le32(
1825
					iinfo->i_location.logicalBlockNum);
1826
	crclen += iinfo->i_lenEAttr + iinfo->i_lenAlloc - sizeof(struct tag);
L
Linus Torvalds 已提交
1827
	fe->descTag.descCRCLength = cpu_to_le16(crclen);
1828
	fe->descTag.descCRC = cpu_to_le16(crc_itu_t(0, (char *)fe + sizeof(struct tag),
1829
						  crclen));
1830
	fe->descTag.tagChecksum = udf_tag_checksum(&fe->descTag);
L
Linus Torvalds 已提交
1831

1832
out:
1833
	set_buffer_uptodate(bh);
1834 1835
	unlock_buffer(bh);

L
Linus Torvalds 已提交
1836 1837
	/* write the data blocks */
	mark_buffer_dirty(bh);
1838
	if (do_sync) {
L
Linus Torvalds 已提交
1839
		sync_dirty_buffer(bh);
1840
		if (buffer_write_io_error(bh)) {
J
Joe Perches 已提交
1841 1842
			udf_warn(inode->i_sb, "IO error syncing udf inode [%08lx]\n",
				 inode->i_ino);
L
Linus Torvalds 已提交
1843 1844 1845
			err = -EIO;
		}
	}
J
Jan Kara 已提交
1846
	brelse(bh);
1847

L
Linus Torvalds 已提交
1848 1849 1850
	return err;
}

J
Jan Kara 已提交
1851 1852
struct inode *__udf_iget(struct super_block *sb, struct kernel_lb_addr *ino,
			 bool hidden_inode)
L
Linus Torvalds 已提交
1853 1854 1855
{
	unsigned long block = udf_get_lb_pblock(sb, ino, 0);
	struct inode *inode = iget_locked(sb, block);
1856
	int err;
L
Linus Torvalds 已提交
1857 1858

	if (!inode)
1859
		return ERR_PTR(-ENOMEM);
L
Linus Torvalds 已提交
1860

1861 1862
	if (!(inode->i_state & I_NEW))
		return inode;
L
Linus Torvalds 已提交
1863

1864
	memcpy(&UDF_I(inode)->i_location, ino, sizeof(struct kernel_lb_addr));
J
Jan Kara 已提交
1865
	err = udf_read_inode(inode, hidden_inode);
1866 1867 1868
	if (err < 0) {
		iget_failed(inode);
		return ERR_PTR(err);
L
Linus Torvalds 已提交
1869
	}
1870
	unlock_new_inode(inode);
L
Linus Torvalds 已提交
1871 1872 1873 1874

	return inode;
}

1875 1876
int udf_add_aext(struct inode *inode, struct extent_position *epos,
		 struct kernel_lb_addr *eloc, uint32_t elen, int inc)
L
Linus Torvalds 已提交
1877 1878
{
	int adsize;
1879 1880
	struct short_ad *sad = NULL;
	struct long_ad *lad = NULL;
L
Linus Torvalds 已提交
1881 1882
	struct allocExtDesc *aed;
	uint8_t *ptr;
1883
	struct udf_inode_info *iinfo = UDF_I(inode);
L
Linus Torvalds 已提交
1884

J
Jan Kara 已提交
1885
	if (!epos->bh)
1886
		ptr = iinfo->i_ext.i_data + epos->offset -
M
Marcin Slusarz 已提交
1887
			udf_file_entry_alloc_offset(inode) +
1888
			iinfo->i_lenEAttr;
L
Linus Torvalds 已提交
1889
	else
J
Jan Kara 已提交
1890
		ptr = epos->bh->b_data + epos->offset;
L
Linus Torvalds 已提交
1891

1892
	if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
1893
		adsize = sizeof(struct short_ad);
1894
	else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
1895
		adsize = sizeof(struct long_ad);
L
Linus Torvalds 已提交
1896
	else
1897
		return -EIO;
L
Linus Torvalds 已提交
1898

1899
	if (epos->offset + (2 * adsize) > inode->i_sb->s_blocksize) {
A
Al Viro 已提交
1900
		unsigned char *sptr, *dptr;
L
Linus Torvalds 已提交
1901 1902
		struct buffer_head *nbh;
		int err, loffset;
1903
		struct kernel_lb_addr obloc = epos->block;
L
Linus Torvalds 已提交
1904

M
Marcin Slusarz 已提交
1905 1906 1907 1908
		epos->block.logicalBlockNum = udf_new_block(inode->i_sb, NULL,
						obloc.partitionReferenceNum,
						obloc.logicalBlockNum, &err);
		if (!epos->block.logicalBlockNum)
1909
			return -ENOSPC;
M
Marcin Slusarz 已提交
1910
		nbh = udf_tgetblk(inode->i_sb, udf_get_lb_pblock(inode->i_sb,
1911
								 &epos->block,
M
Marcin Slusarz 已提交
1912 1913
								 0));
		if (!nbh)
1914
			return -EIO;
L
Linus Torvalds 已提交
1915 1916 1917 1918 1919 1920 1921 1922
		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 已提交
1923 1924
			aed->previousAllocExtLocation =
					cpu_to_le32(obloc.logicalBlockNum);
1925
		if (epos->offset + adsize > inode->i_sb->s_blocksize) {
J
Jan Kara 已提交
1926
			loffset = epos->offset;
L
Linus Torvalds 已提交
1927 1928 1929 1930
			aed->lengthAllocDescs = cpu_to_le32(adsize);
			sptr = ptr - adsize;
			dptr = nbh->b_data + sizeof(struct allocExtDesc);
			memcpy(dptr, sptr, adsize);
J
Jan Kara 已提交
1931
			epos->offset = sizeof(struct allocExtDesc) + adsize;
1932
		} else {
J
Jan Kara 已提交
1933
			loffset = epos->offset + adsize;
L
Linus Torvalds 已提交
1934 1935
			aed->lengthAllocDescs = cpu_to_le32(0);
			sptr = ptr;
J
Jan Kara 已提交
1936
			epos->offset = sizeof(struct allocExtDesc);
L
Linus Torvalds 已提交
1937

1938
			if (epos->bh) {
J
Jan Kara 已提交
1939
				aed = (struct allocExtDesc *)epos->bh->b_data;
1940
				le32_add_cpu(&aed->lengthAllocDescs, adsize);
1941
			} else {
1942
				iinfo->i_lenAlloc += adsize;
L
Linus Torvalds 已提交
1943 1944 1945
				mark_inode_dirty(inode);
			}
		}
M
Marcin Slusarz 已提交
1946
		if (UDF_SB(inode->i_sb)->s_udfrev >= 0x0200)
L
Linus Torvalds 已提交
1947
			udf_new_tag(nbh->b_data, TAG_IDENT_AED, 3, 1,
1948
				    epos->block.logicalBlockNum, sizeof(struct tag));
L
Linus Torvalds 已提交
1949 1950
		else
			udf_new_tag(nbh->b_data, TAG_IDENT_AED, 2, 1,
1951
				    epos->block.logicalBlockNum, sizeof(struct tag));
1952
		switch (iinfo->i_alloc_type) {
1953
		case ICBTAG_FLAG_AD_SHORT:
1954
			sad = (struct short_ad *)sptr;
1955 1956
			sad->extLength = cpu_to_le32(EXT_NEXT_EXTENT_ALLOCDECS |
						     inode->i_sb->s_blocksize);
M
Marcin Slusarz 已提交
1957 1958
			sad->extPosition =
				cpu_to_le32(epos->block.logicalBlockNum);
1959
			break;
1960
		case ICBTAG_FLAG_AD_LONG:
1961
			lad = (struct long_ad *)sptr;
1962 1963 1964 1965 1966
			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 已提交
1967
		}
1968
		if (epos->bh) {
1969
			if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) ||
M
Marcin Slusarz 已提交
1970
			    UDF_SB(inode->i_sb)->s_udfrev >= 0x0201)
J
Jan Kara 已提交
1971
				udf_update_tag(epos->bh->b_data, loffset);
L
Linus Torvalds 已提交
1972
			else
M
Marcin Slusarz 已提交
1973 1974
				udf_update_tag(epos->bh->b_data,
						sizeof(struct allocExtDesc));
J
Jan Kara 已提交
1975
			mark_buffer_dirty_inode(epos->bh, inode);
J
Jan Kara 已提交
1976
			brelse(epos->bh);
1977
		} else {
L
Linus Torvalds 已提交
1978
			mark_inode_dirty(inode);
1979
		}
J
Jan Kara 已提交
1980
		epos->bh = nbh;
L
Linus Torvalds 已提交
1981 1982
	}

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

1985
	if (!epos->bh) {
1986
		iinfo->i_lenAlloc += adsize;
L
Linus Torvalds 已提交
1987
		mark_inode_dirty(inode);
1988
	} else {
J
Jan Kara 已提交
1989
		aed = (struct allocExtDesc *)epos->bh->b_data;
1990
		le32_add_cpu(&aed->lengthAllocDescs, adsize);
M
Marcin Slusarz 已提交
1991 1992 1993 1994
		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 已提交
1995
		else
M
Marcin Slusarz 已提交
1996 1997
			udf_update_tag(epos->bh->b_data,
					sizeof(struct allocExtDesc));
J
Jan Kara 已提交
1998
		mark_buffer_dirty_inode(epos->bh, inode);
L
Linus Torvalds 已提交
1999 2000
	}

2001
	return 0;
L
Linus Torvalds 已提交
2002 2003
}

2004 2005
void udf_write_aext(struct inode *inode, struct extent_position *epos,
		    struct kernel_lb_addr *eloc, uint32_t elen, int inc)
L
Linus Torvalds 已提交
2006 2007 2008
{
	int adsize;
	uint8_t *ptr;
2009 2010
	struct short_ad *sad;
	struct long_ad *lad;
2011
	struct udf_inode_info *iinfo = UDF_I(inode);
L
Linus Torvalds 已提交
2012

J
Jan Kara 已提交
2013
	if (!epos->bh)
2014
		ptr = iinfo->i_ext.i_data + epos->offset -
M
Marcin Slusarz 已提交
2015
			udf_file_entry_alloc_offset(inode) +
2016
			iinfo->i_lenEAttr;
L
Linus Torvalds 已提交
2017
	else
J
Jan Kara 已提交
2018
		ptr = epos->bh->b_data + epos->offset;
L
Linus Torvalds 已提交
2019

2020
	switch (iinfo->i_alloc_type) {
2021
	case ICBTAG_FLAG_AD_SHORT:
2022
		sad = (struct short_ad *)ptr;
2023
		sad->extLength = cpu_to_le32(elen);
2024
		sad->extPosition = cpu_to_le32(eloc->logicalBlockNum);
2025
		adsize = sizeof(struct short_ad);
2026
		break;
2027
	case ICBTAG_FLAG_AD_LONG:
2028
		lad = (struct long_ad *)ptr;
2029
		lad->extLength = cpu_to_le32(elen);
2030
		lad->extLocation = cpu_to_lelb(*eloc);
2031
		memset(lad->impUse, 0x00, sizeof(lad->impUse));
2032
		adsize = sizeof(struct long_ad);
2033
		break;
2034
	default:
2035
		return;
L
Linus Torvalds 已提交
2036 2037
	}

2038
	if (epos->bh) {
2039
		if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) ||
M
Marcin Slusarz 已提交
2040
		    UDF_SB(inode->i_sb)->s_udfrev >= 0x0201) {
M
Marcin Slusarz 已提交
2041 2042
			struct allocExtDesc *aed =
				(struct allocExtDesc *)epos->bh->b_data;
J
Jan Kara 已提交
2043
			udf_update_tag(epos->bh->b_data,
M
Marcin Slusarz 已提交
2044 2045
				       le32_to_cpu(aed->lengthAllocDescs) +
				       sizeof(struct allocExtDesc));
L
Linus Torvalds 已提交
2046
		}
J
Jan Kara 已提交
2047
		mark_buffer_dirty_inode(epos->bh, inode);
2048
	} else {
L
Linus Torvalds 已提交
2049
		mark_inode_dirty(inode);
2050
	}
L
Linus Torvalds 已提交
2051 2052

	if (inc)
J
Jan Kara 已提交
2053
		epos->offset += adsize;
L
Linus Torvalds 已提交
2054 2055
}

M
Marcin Slusarz 已提交
2056
int8_t udf_next_aext(struct inode *inode, struct extent_position *epos,
2057
		     struct kernel_lb_addr *eloc, uint32_t *elen, int inc)
L
Linus Torvalds 已提交
2058 2059 2060
{
	int8_t etype;

J
Jan Kara 已提交
2061
	while ((etype = udf_current_aext(inode, epos, eloc, elen, inc)) ==
2062
	       (EXT_NEXT_EXTENT_ALLOCDECS >> 30)) {
M
Marcin Slusarz 已提交
2063
		int block;
J
Jan Kara 已提交
2064 2065
		epos->block = *eloc;
		epos->offset = sizeof(struct allocExtDesc);
J
Jan Kara 已提交
2066
		brelse(epos->bh);
2067
		block = udf_get_lb_pblock(inode->i_sb, &epos->block, 0);
M
Marcin Slusarz 已提交
2068 2069 2070
		epos->bh = udf_tread(inode->i_sb, block);
		if (!epos->bh) {
			udf_debug("reading block %d failed!\n", block);
L
Linus Torvalds 已提交
2071 2072 2073 2074 2075 2076 2077
			return -1;
		}
	}

	return etype;
}

M
Marcin Slusarz 已提交
2078
int8_t udf_current_aext(struct inode *inode, struct extent_position *epos,
2079
			struct kernel_lb_addr *eloc, uint32_t *elen, int inc)
L
Linus Torvalds 已提交
2080 2081 2082 2083
{
	int alen;
	int8_t etype;
	uint8_t *ptr;
2084 2085
	struct short_ad *sad;
	struct long_ad *lad;
2086
	struct udf_inode_info *iinfo = UDF_I(inode);
2087

2088
	if (!epos->bh) {
J
Jan Kara 已提交
2089 2090
		if (!epos->offset)
			epos->offset = udf_file_entry_alloc_offset(inode);
2091
		ptr = iinfo->i_ext.i_data + epos->offset -
M
Marcin Slusarz 已提交
2092
			udf_file_entry_alloc_offset(inode) +
2093
			iinfo->i_lenEAttr;
M
Marcin Slusarz 已提交
2094
		alen = udf_file_entry_alloc_offset(inode) +
2095
							iinfo->i_lenAlloc;
2096
	} else {
J
Jan Kara 已提交
2097 2098 2099
		if (!epos->offset)
			epos->offset = sizeof(struct allocExtDesc);
		ptr = epos->bh->b_data + epos->offset;
2100
		alen = sizeof(struct allocExtDesc) +
M
Marcin Slusarz 已提交
2101 2102
			le32_to_cpu(((struct allocExtDesc *)epos->bh->b_data)->
							lengthAllocDescs);
L
Linus Torvalds 已提交
2103 2104
	}

2105
	switch (iinfo->i_alloc_type) {
2106
	case ICBTAG_FLAG_AD_SHORT:
M
Marcin Slusarz 已提交
2107 2108
		sad = udf_get_fileshortad(ptr, alen, &epos->offset, inc);
		if (!sad)
2109 2110 2111
			return -1;
		etype = le32_to_cpu(sad->extLength) >> 30;
		eloc->logicalBlockNum = le32_to_cpu(sad->extPosition);
M
Marcin Slusarz 已提交
2112
		eloc->partitionReferenceNum =
2113
				iinfo->i_location.partitionReferenceNum;
2114 2115
		*elen = le32_to_cpu(sad->extLength) & UDF_EXTENT_LENGTH_MASK;
		break;
2116
	case ICBTAG_FLAG_AD_LONG:
M
Marcin Slusarz 已提交
2117 2118
		lad = udf_get_filelongad(ptr, alen, &epos->offset, inc);
		if (!lad)
L
Linus Torvalds 已提交
2119
			return -1;
2120 2121 2122 2123 2124
		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 已提交
2125
		udf_debug("alloc_type = %d unsupported\n", iinfo->i_alloc_type);
2126
		return -1;
L
Linus Torvalds 已提交
2127 2128 2129 2130 2131
	}

	return etype;
}

2132
static int8_t udf_insert_aext(struct inode *inode, struct extent_position epos,
2133
			      struct kernel_lb_addr neloc, uint32_t nelen)
L
Linus Torvalds 已提交
2134
{
2135
	struct kernel_lb_addr oeloc;
L
Linus Torvalds 已提交
2136 2137 2138
	uint32_t oelen;
	int8_t etype;

J
Jan Kara 已提交
2139
	if (epos.bh)
J
Jan Kara 已提交
2140
		get_bh(epos.bh);
L
Linus Torvalds 已提交
2141

2142
	while ((etype = udf_next_aext(inode, &epos, &oeloc, &oelen, 0)) != -1) {
2143
		udf_write_aext(inode, &epos, &neloc, nelen, 1);
L
Linus Torvalds 已提交
2144 2145 2146
		neloc = oeloc;
		nelen = (etype << 30) | oelen;
	}
2147
	udf_add_aext(inode, &epos, &neloc, nelen, 1);
J
Jan Kara 已提交
2148
	brelse(epos.bh);
2149

L
Linus Torvalds 已提交
2150 2151 2152
	return (nelen >> 30);
}

M
Marcin Slusarz 已提交
2153
int8_t udf_delete_aext(struct inode *inode, struct extent_position epos,
2154
		       struct kernel_lb_addr eloc, uint32_t elen)
L
Linus Torvalds 已提交
2155
{
J
Jan Kara 已提交
2156 2157
	struct extent_position oepos;
	int adsize;
L
Linus Torvalds 已提交
2158 2159
	int8_t etype;
	struct allocExtDesc *aed;
2160
	struct udf_inode_info *iinfo;
L
Linus Torvalds 已提交
2161

2162
	if (epos.bh) {
J
Jan Kara 已提交
2163 2164
		get_bh(epos.bh);
		get_bh(epos.bh);
L
Linus Torvalds 已提交
2165 2166
	}

2167 2168
	iinfo = UDF_I(inode);
	if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
2169
		adsize = sizeof(struct short_ad);
2170
	else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
2171
		adsize = sizeof(struct long_ad);
L
Linus Torvalds 已提交
2172 2173 2174
	else
		adsize = 0;

J
Jan Kara 已提交
2175 2176
	oepos = epos;
	if (udf_next_aext(inode, &epos, &eloc, &elen, 1) == -1)
L
Linus Torvalds 已提交
2177 2178
		return -1;

2179
	while ((etype = udf_next_aext(inode, &epos, &eloc, &elen, 1)) != -1) {
2180
		udf_write_aext(inode, &oepos, &eloc, (etype << 30) | elen, 1);
2181
		if (oepos.bh != epos.bh) {
J
Jan Kara 已提交
2182
			oepos.block = epos.block;
J
Jan Kara 已提交
2183 2184
			brelse(oepos.bh);
			get_bh(epos.bh);
J
Jan Kara 已提交
2185 2186
			oepos.bh = epos.bh;
			oepos.offset = epos.offset - adsize;
L
Linus Torvalds 已提交
2187 2188
		}
	}
2189
	memset(&eloc, 0x00, sizeof(struct kernel_lb_addr));
L
Linus Torvalds 已提交
2190 2191
	elen = 0;

2192
	if (epos.bh != oepos.bh) {
2193 2194 2195
		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);
2196
		if (!oepos.bh) {
2197
			iinfo->i_lenAlloc -= (adsize * 2);
L
Linus Torvalds 已提交
2198
			mark_inode_dirty(inode);
2199
		} else {
J
Jan Kara 已提交
2200
			aed = (struct allocExtDesc *)oepos.bh->b_data;
2201
			le32_add_cpu(&aed->lengthAllocDescs, -(2 * adsize));
2202
			if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) ||
M
Marcin Slusarz 已提交
2203
			    UDF_SB(inode->i_sb)->s_udfrev >= 0x0201)
M
Marcin Slusarz 已提交
2204 2205
				udf_update_tag(oepos.bh->b_data,
						oepos.offset - (2 * adsize));
L
Linus Torvalds 已提交
2206
			else
M
Marcin Slusarz 已提交
2207 2208
				udf_update_tag(oepos.bh->b_data,
						sizeof(struct allocExtDesc));
J
Jan Kara 已提交
2209
			mark_buffer_dirty_inode(oepos.bh, inode);
L
Linus Torvalds 已提交
2210
		}
2211
	} else {
2212
		udf_write_aext(inode, &oepos, &eloc, elen, 1);
2213
		if (!oepos.bh) {
2214
			iinfo->i_lenAlloc -= adsize;
L
Linus Torvalds 已提交
2215
			mark_inode_dirty(inode);
2216
		} else {
J
Jan Kara 已提交
2217
			aed = (struct allocExtDesc *)oepos.bh->b_data;
2218
			le32_add_cpu(&aed->lengthAllocDescs, -adsize);
2219
			if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) ||
M
Marcin Slusarz 已提交
2220
			    UDF_SB(inode->i_sb)->s_udfrev >= 0x0201)
M
Marcin Slusarz 已提交
2221 2222
				udf_update_tag(oepos.bh->b_data,
						epos.offset - adsize);
L
Linus Torvalds 已提交
2223
			else
M
Marcin Slusarz 已提交
2224 2225
				udf_update_tag(oepos.bh->b_data,
						sizeof(struct allocExtDesc));
J
Jan Kara 已提交
2226
			mark_buffer_dirty_inode(oepos.bh, inode);
L
Linus Torvalds 已提交
2227 2228
		}
	}
2229

J
Jan Kara 已提交
2230 2231
	brelse(epos.bh);
	brelse(oepos.bh);
2232

L
Linus Torvalds 已提交
2233 2234 2235
	return (elen >> 30);
}

M
Marcin Slusarz 已提交
2236
int8_t inode_bmap(struct inode *inode, sector_t block,
2237
		  struct extent_position *pos, struct kernel_lb_addr *eloc,
M
Marcin Slusarz 已提交
2238
		  uint32_t *elen, sector_t *offset)
L
Linus Torvalds 已提交
2239
{
M
Marcin Slusarz 已提交
2240
	unsigned char blocksize_bits = inode->i_sb->s_blocksize_bits;
2241
	loff_t lbcount = 0, bcount =
M
Marcin Slusarz 已提交
2242
	    (loff_t) block << blocksize_bits;
L
Linus Torvalds 已提交
2243
	int8_t etype;
2244
	struct udf_inode_info *iinfo;
L
Linus Torvalds 已提交
2245

2246
	iinfo = UDF_I(inode);
2247 2248 2249 2250 2251
	if (!udf_read_extent_cache(inode, bcount, &lbcount, pos)) {
		pos->offset = 0;
		pos->block = iinfo->i_location;
		pos->bh = NULL;
	}
L
Linus Torvalds 已提交
2252
	*elen = 0;
2253
	do {
M
Marcin Slusarz 已提交
2254 2255 2256
		etype = udf_next_aext(inode, pos, eloc, elen, 1);
		if (etype == -1) {
			*offset = (bcount - lbcount) >> blocksize_bits;
2257
			iinfo->i_lenExtents = lbcount;
L
Linus Torvalds 已提交
2258 2259 2260 2261
			return -1;
		}
		lbcount += *elen;
	} while (lbcount <= bcount);
2262 2263
	/* update extent cache */
	udf_update_extent_cache(inode, lbcount - *elen, pos, 1);
M
Marcin Slusarz 已提交
2264
	*offset = (bcount + *elen - lbcount) >> blocksize_bits;
L
Linus Torvalds 已提交
2265 2266 2267 2268

	return etype;
}

2269
long udf_block_map(struct inode *inode, sector_t block)
L
Linus Torvalds 已提交
2270
{
2271
	struct kernel_lb_addr eloc;
J
Jan Kara 已提交
2272
	uint32_t elen;
2273
	sector_t offset;
2274
	struct extent_position epos = {};
L
Linus Torvalds 已提交
2275 2276
	int ret;

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

M
Marcin Slusarz 已提交
2279 2280
	if (inode_bmap(inode, block, &epos, &eloc, &elen, &offset) ==
						(EXT_RECORDED_ALLOCATED >> 30))
2281
		ret = udf_get_lb_pblock(inode->i_sb, &eloc, offset);
L
Linus Torvalds 已提交
2282 2283 2284
	else
		ret = 0;

2285
	up_read(&UDF_I(inode)->i_data_sem);
J
Jan Kara 已提交
2286
	brelse(epos.bh);
L
Linus Torvalds 已提交
2287 2288 2289 2290 2291 2292

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