inode.c 64.4 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>
41
#include <linux/aio.h>
L
Linus Torvalds 已提交
42 43 44 45 46 47 48 49 50 51

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

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 137
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);
}
138

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

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

I
Ian Abbott 已提交
167 168 169 170 171 172 173
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) {
174
		truncate_pagecache(inode, isize);
I
Ian Abbott 已提交
175 176
		if (iinfo->i_alloc_type != ICBTAG_FLAG_AD_IN_ICB) {
			down_write(&iinfo->i_data_sem);
177
			udf_clear_extent_cache(inode);
I
Ian Abbott 已提交
178 179 180 181 182 183
			udf_truncate_extents(inode);
			up_write(&iinfo->i_data_sem);
		}
	}
}

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

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

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

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

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

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

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

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

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

250 251 252 253 254 255
/*
 * 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
 */
256
int udf_expand_file_adinicb(struct inode *inode)
L
Linus Torvalds 已提交
257 258 259
{
	struct page *page;
	char *kaddr;
260
	struct udf_inode_info *iinfo = UDF_I(inode);
261
	int err;
L
Linus Torvalds 已提交
262 263 264 265 266
	struct writeback_control udf_wbc = {
		.sync_mode = WB_SYNC_NONE,
		.nr_to_write = 1,
	};

267
	WARN_ON_ONCE(!mutex_is_locked(&inode->i_mutex));
268
	if (!iinfo->i_lenAlloc) {
L
Linus Torvalds 已提交
269
		if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_SHORT_AD))
270
			iinfo->i_alloc_type = ICBTAG_FLAG_AD_SHORT;
L
Linus Torvalds 已提交
271
		else
272
			iinfo->i_alloc_type = ICBTAG_FLAG_AD_LONG;
273 274
		/* from now on we have normal address_space methods */
		inode->i_data.a_ops = &udf_aops;
275
		up_write(&iinfo->i_data_sem);
L
Linus Torvalds 已提交
276
		mark_inode_dirty(inode);
277
		return 0;
L
Linus Torvalds 已提交
278
	}
279 280 281 282 283
	/*
	 * 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 已提交
284

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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 657
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;
}

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

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

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

		lbcount += elen;

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

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

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

		c = !c;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1062
	for (i = 0; i < (*endnum - 1); i++) {
1063 1064
		struct kernel_long_ad *li /*l[i]*/ = &laarr[i];
		struct kernel_long_ad *lip1 /*l[i plus 1]*/ = &laarr[i + 1];
M
Marcin Slusarz 已提交
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 1097

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

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

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

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

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

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

	if (buffer_uptodate(bh))
		return bh;
1195

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

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

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

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

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

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

1273
static void __udf_read_inode(struct inode *inode)
L
Linus Torvalds 已提交
1274 1275 1276
{
	struct buffer_head *bh = NULL;
	struct fileEntry *fe;
1277
	struct extendedFileEntry *efe;
L
Linus Torvalds 已提交
1278
	uint16_t ident;
1279
	struct udf_inode_info *iinfo = UDF_I(inode);
1280 1281
	struct udf_sb_info *sbi = UDF_SB(inode->i_sb);
	unsigned int link_count;
L
Linus Torvalds 已提交
1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294

	/*
	 * 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;
	 */
1295
	bh = udf_read_ptagged(inode->i_sb, &iinfo->i_location, 0, &ident);
1296
	if (!bh) {
J
Joe Perches 已提交
1297
		udf_err(inode->i_sb, "(ino %ld) failed !bh\n", inode->i_ino);
L
Linus Torvalds 已提交
1298 1299 1300 1301 1302
		make_bad_inode(inode);
		return;
	}

	if (ident != TAG_IDENT_FE && ident != TAG_IDENT_EFE &&
1303
	    ident != TAG_IDENT_USE) {
J
Joe Perches 已提交
1304 1305
		udf_err(inode->i_sb, "(ino %ld) failed ident=%d\n",
			inode->i_ino, ident);
J
Jan Kara 已提交
1306
		brelse(bh);
L
Linus Torvalds 已提交
1307 1308 1309 1310 1311
		make_bad_inode(inode);
		return;
	}

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

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

1317
		ibh = udf_read_ptagged(inode->i_sb, &iinfo->i_location, 1,
M
Marcin Slusarz 已提交
1318
					&ident);
1319 1320
		if (ident == TAG_IDENT_IE && ibh) {
			struct buffer_head *nbh = NULL;
1321
			struct kernel_lb_addr loc;
1322 1323 1324 1325 1326 1327
			struct indirectEntry *ie;

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

			if (ie->indirectICB.extLength &&
1328
				(nbh = udf_read_ptagged(inode->i_sb, &loc, 0,
1329 1330 1331 1332 1333
							&ident))) {
				if (ident == TAG_IDENT_FE ||
					ident == TAG_IDENT_EFE) {
					memcpy(&iinfo->i_location,
						&loc,
1334
						sizeof(struct kernel_lb_addr));
1335
					brelse(bh);
J
Jan Kara 已提交
1336
					brelse(ibh);
1337 1338 1339
					brelse(nbh);
					__udf_read_inode(inode);
					return;
1340
				}
1341
				brelse(nbh);
L
Linus Torvalds 已提交
1342
			}
1343
		}
1344
		brelse(ibh);
1345
	} else if (fe->icbTag.strategyType != cpu_to_le16(4)) {
J
Joe Perches 已提交
1346 1347
		udf_err(inode->i_sb, "unsupported strategy type: %d\n",
			le16_to_cpu(fe->icbTag.strategyType));
J
Jan Kara 已提交
1348
		brelse(bh);
L
Linus Torvalds 已提交
1349 1350 1351
		make_bad_inode(inode);
		return;
	}
1352
	if (fe->icbTag.strategyType == cpu_to_le16(4))
1353
		iinfo->i_strat4096 = 0;
1354
	else /* if (fe->icbTag.strategyType == cpu_to_le16(4096)) */
1355
		iinfo->i_strat4096 = 1;
L
Linus Torvalds 已提交
1356

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

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

1413 1414
	i_gid_write(inode, le32_to_cpu(fe->gid));
	if (!gid_valid(inode->i_gid) ||
1415 1416
	    UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_GID_IGNORE) ||
	    UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_GID_SET))
1417
		inode->i_gid = UDF_SB(inode->i_sb)->s_gid;
L
Linus Torvalds 已提交
1418

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

M
Miklos Szeredi 已提交
1430 1431 1432 1433
	link_count = le16_to_cpu(fe->fileLinkCount);
	if (!link_count)
		link_count = 1;
	set_nlink(inode, link_count);
1434 1435 1436

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

1438
	if (iinfo->i_efe == 0) {
L
Linus Torvalds 已提交
1439
		inode->i_blocks = le64_to_cpu(fe->logicalBlocksRecorded) <<
1440
			(inode->i_sb->s_blocksize_bits - 9);
L
Linus Torvalds 已提交
1441

1442
		if (!udf_disk_stamp_to_time(&inode->i_atime, fe->accessTime))
1443 1444
			inode->i_atime = sbi->s_record_time;

1445 1446
		if (!udf_disk_stamp_to_time(&inode->i_mtime,
					    fe->modificationTime))
1447 1448
			inode->i_mtime = sbi->s_record_time;

1449
		if (!udf_disk_stamp_to_time(&inode->i_ctime, fe->attrTime))
1450
			inode->i_ctime = sbi->s_record_time;
L
Linus Torvalds 已提交
1451

1452 1453 1454
		iinfo->i_unique = le64_to_cpu(fe->uniqueID);
		iinfo->i_lenEAttr = le32_to_cpu(fe->lengthExtendedAttr);
		iinfo->i_lenAlloc = le32_to_cpu(fe->lengthAllocDescs);
1455
		iinfo->i_checkpoint = le32_to_cpu(fe->checkpoint);
1456
	} else {
1457
		inode->i_blocks = le64_to_cpu(efe->logicalBlocksRecorded) <<
1458
		    (inode->i_sb->s_blocksize_bits - 9);
L
Linus Torvalds 已提交
1459

1460
		if (!udf_disk_stamp_to_time(&inode->i_atime, efe->accessTime))
1461 1462
			inode->i_atime = sbi->s_record_time;

1463 1464
		if (!udf_disk_stamp_to_time(&inode->i_mtime,
					    efe->modificationTime))
1465 1466
			inode->i_mtime = sbi->s_record_time;

1467
		if (!udf_disk_stamp_to_time(&iinfo->i_crtime, efe->createTime))
1468 1469
			iinfo->i_crtime = sbi->s_record_time;

1470
		if (!udf_disk_stamp_to_time(&inode->i_ctime, efe->attrTime))
1471
			inode->i_ctime = sbi->s_record_time;
L
Linus Torvalds 已提交
1472

1473 1474 1475
		iinfo->i_unique = le64_to_cpu(efe->uniqueID);
		iinfo->i_lenEAttr = le32_to_cpu(efe->lengthExtendedAttr);
		iinfo->i_lenAlloc = le32_to_cpu(efe->lengthAllocDescs);
1476
		iinfo->i_checkpoint = le32_to_cpu(efe->checkpoint);
L
Linus Torvalds 已提交
1477 1478
	}

1479 1480
	switch (fe->icbTag.fileType) {
	case ICBTAG_FILE_TYPE_DIRECTORY:
1481 1482 1483 1484 1485
		inode->i_op = &udf_dir_inode_operations;
		inode->i_fop = &udf_dir_operations;
		inode->i_mode |= S_IFDIR;
		inc_nlink(inode);
		break;
1486 1487 1488
	case ICBTAG_FILE_TYPE_REALTIME:
	case ICBTAG_FILE_TYPE_REGULAR:
	case ICBTAG_FILE_TYPE_UNDEF:
J
Jan Kara 已提交
1489
	case ICBTAG_FILE_TYPE_VAT20:
1490
		if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
1491 1492 1493 1494 1495 1496 1497
			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;
1498
	case ICBTAG_FILE_TYPE_BLOCK:
1499 1500
		inode->i_mode |= S_IFBLK;
		break;
1501
	case ICBTAG_FILE_TYPE_CHAR:
1502 1503
		inode->i_mode |= S_IFCHR;
		break;
1504
	case ICBTAG_FILE_TYPE_FIFO:
1505 1506
		init_special_inode(inode, inode->i_mode | S_IFIFO, 0);
		break;
1507
	case ICBTAG_FILE_TYPE_SOCKET:
1508 1509
		init_special_inode(inode, inode->i_mode | S_IFSOCK, 0);
		break;
1510
	case ICBTAG_FILE_TYPE_SYMLINK:
1511
		inode->i_data.a_ops = &udf_symlink_aops;
1512
		inode->i_op = &udf_symlink_inode_operations;
1513 1514
		inode->i_mode = S_IFLNK | S_IRWXUGO;
		break;
1515 1516 1517 1518 1519 1520 1521 1522 1523
	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;
1524
	default:
J
Joe Perches 已提交
1525 1526
		udf_err(inode->i_sb, "(ino %ld) failed unknown file type=%d\n",
			inode->i_ino, fe->icbTag.fileType);
1527 1528
		make_bad_inode(inode);
		return;
L
Linus Torvalds 已提交
1529
	}
1530
	if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) {
M
Marcin Slusarz 已提交
1531 1532
		struct deviceSpec *dsea =
			(struct deviceSpec *)udf_get_extendedattr(inode, 12, 1);
1533 1534
		if (dsea) {
			init_special_inode(inode, inode->i_mode,
M
Marcin Slusarz 已提交
1535 1536
				MKDEV(le32_to_cpu(dsea->majorDeviceIdent),
				      le32_to_cpu(dsea->minorDeviceIdent)));
L
Linus Torvalds 已提交
1537
			/* Developer ID ??? */
M
Marcin Slusarz 已提交
1538
		} else
L
Linus Torvalds 已提交
1539 1540
			make_bad_inode(inode);
	}
1541
	brelse(bh);
L
Linus Torvalds 已提交
1542 1543
}

1544 1545
static int udf_alloc_i_data(struct inode *inode, size_t size)
{
1546 1547
	struct udf_inode_info *iinfo = UDF_I(inode);
	iinfo->i_ext.i_data = kmalloc(size, GFP_KERNEL);
1548

1549
	if (!iinfo->i_ext.i_data) {
J
Joe Perches 已提交
1550 1551
		udf_err(inode->i_sb, "(ino %ld) no free memory\n",
			inode->i_ino);
1552 1553 1554 1555 1556 1557
		return -ENOMEM;
	}

	return 0;
}

A
Al Viro 已提交
1558
static umode_t udf_convert_permissions(struct fileEntry *fe)
L
Linus Torvalds 已提交
1559
{
A
Al Viro 已提交
1560
	umode_t mode;
L
Linus Torvalds 已提交
1561 1562 1563 1564 1565 1566
	uint32_t permissions;
	uint32_t flags;

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

M
Marcin Slusarz 已提交
1567 1568 1569 1570 1571 1572
	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 已提交
1573 1574 1575 1576

	return mode;
}

1577
int udf_write_inode(struct inode *inode, struct writeback_control *wbc)
L
Linus Torvalds 已提交
1578
{
J
Jan Kara 已提交
1579
	return udf_update_inode(inode, wbc->sync_mode == WB_SYNC_ALL);
L
Linus Torvalds 已提交
1580 1581
}

J
Jan Kara 已提交
1582
static int udf_sync_inode(struct inode *inode)
L
Linus Torvalds 已提交
1583 1584 1585 1586
{
	return udf_update_inode(inode, 1);
}

1587
static int udf_update_inode(struct inode *inode, int do_sync)
L
Linus Torvalds 已提交
1588 1589 1590 1591
{
	struct buffer_head *bh = NULL;
	struct fileEntry *fe;
	struct extendedFileEntry *efe;
1592
	uint64_t lb_recorded;
L
Linus Torvalds 已提交
1593 1594 1595 1596
	uint32_t udfperms;
	uint16_t icbflags;
	uint16_t crclen;
	int err = 0;
M
Marcin Slusarz 已提交
1597
	struct udf_sb_info *sbi = UDF_SB(inode->i_sb);
M
Marcin Slusarz 已提交
1598
	unsigned char blocksize_bits = inode->i_sb->s_blocksize_bits;
1599
	struct udf_inode_info *iinfo = UDF_I(inode);
L
Linus Torvalds 已提交
1600

1601 1602
	bh = udf_tgetblk(inode->i_sb,
			udf_get_lb_pblock(inode->i_sb, &iinfo->i_location, 0));
1603
	if (!bh) {
1604 1605
		udf_debug("getblk failure\n");
		return -ENOMEM;
L
Linus Torvalds 已提交
1606 1607
	}

1608 1609
	lock_buffer(bh);
	memset(bh->b_data, 0, inode->i_sb->s_blocksize);
L
Linus Torvalds 已提交
1610 1611 1612
	fe = (struct fileEntry *)bh->b_data;
	efe = (struct extendedFileEntry *)bh->b_data;

1613
	if (iinfo->i_use) {
L
Linus Torvalds 已提交
1614
		struct unallocSpaceEntry *use =
1615
			(struct unallocSpaceEntry *)bh->b_data;
L
Linus Torvalds 已提交
1616

1617
		use->lengthAllocDescs = cpu_to_le32(iinfo->i_lenAlloc);
M
Marcin Slusarz 已提交
1618
		memcpy(bh->b_data + sizeof(struct unallocSpaceEntry),
1619
		       iinfo->i_ext.i_data, inode->i_sb->s_blocksize -
M
Marcin Slusarz 已提交
1620
					sizeof(struct unallocSpaceEntry));
1621 1622 1623
		use->descTag.tagIdent = cpu_to_le16(TAG_IDENT_USE);
		use->descTag.tagLocation =
				cpu_to_le32(iinfo->i_location.logicalBlockNum);
M
Marcin Slusarz 已提交
1624
		crclen = sizeof(struct unallocSpaceEntry) +
1625
				iinfo->i_lenAlloc - sizeof(struct tag);
L
Linus Torvalds 已提交
1626
		use->descTag.descCRCLength = cpu_to_le16(crclen);
1627
		use->descTag.descCRC = cpu_to_le16(crc_itu_t(0, (char *)use +
1628
							   sizeof(struct tag),
1629
							   crclen));
1630
		use->descTag.tagChecksum = udf_tag_checksum(&use->descTag);
L
Linus Torvalds 已提交
1631

1632
		goto out;
L
Linus Torvalds 已提交
1633 1634
	}

1635 1636
	if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_UID_FORGET))
		fe->uid = cpu_to_le32(-1);
1637
	else
1638
		fe->uid = cpu_to_le32(i_uid_read(inode));
L
Linus Torvalds 已提交
1639

1640 1641
	if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_GID_FORGET))
		fe->gid = cpu_to_le32(-1);
1642
	else
1643
		fe->gid = cpu_to_le32(i_gid_read(inode));
L
Linus Torvalds 已提交
1644

M
Marcin Slusarz 已提交
1645 1646 1647
	udfperms = ((inode->i_mode & S_IRWXO)) |
		   ((inode->i_mode & S_IRWXG) << 2) |
		   ((inode->i_mode & S_IRWXU) << 4);
L
Linus Torvalds 已提交
1648

M
Marcin Slusarz 已提交
1649 1650 1651 1652
	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 已提交
1653 1654
	fe->permissions = cpu_to_le32(udfperms);

1655
	if (S_ISDIR(inode->i_mode) && inode->i_nlink > 0)
L
Linus Torvalds 已提交
1656 1657 1658 1659 1660 1661
		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);

1662
	if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) {
1663
		struct regid *eid;
1664 1665
		struct deviceSpec *dsea =
			(struct deviceSpec *)udf_get_extendedattr(inode, 12, 1);
1666
		if (!dsea) {
L
Linus Torvalds 已提交
1667
			dsea = (struct deviceSpec *)
1668 1669
				udf_add_extendedattr(inode,
						     sizeof(struct deviceSpec) +
1670
						     sizeof(struct regid), 12, 0x3);
L
Linus Torvalds 已提交
1671 1672
			dsea->attrType = cpu_to_le32(12);
			dsea->attrSubtype = 1;
M
Marcin Slusarz 已提交
1673 1674
			dsea->attrLength = cpu_to_le32(
						sizeof(struct deviceSpec) +
1675 1676
						sizeof(struct regid));
			dsea->impUseLength = cpu_to_le32(sizeof(struct regid));
L
Linus Torvalds 已提交
1677
		}
1678 1679
		eid = (struct regid *)dsea->impUse;
		memset(eid, 0, sizeof(struct regid));
L
Linus Torvalds 已提交
1680 1681 1682 1683 1684 1685 1686
		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));
	}

1687 1688 1689 1690 1691 1692 1693
	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);

1694
	if (iinfo->i_efe == 0) {
1695
		memcpy(bh->b_data + sizeof(struct fileEntry),
1696
		       iinfo->i_ext.i_data,
1697
		       inode->i_sb->s_blocksize - sizeof(struct fileEntry));
1698
		fe->logicalBlocksRecorded = cpu_to_le64(lb_recorded);
L
Linus Torvalds 已提交
1699

1700 1701 1702
		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);
1703
		memset(&(fe->impIdent), 0, sizeof(struct regid));
L
Linus Torvalds 已提交
1704 1705 1706
		strcpy(fe->impIdent.ident, UDF_ID_DEVELOPER);
		fe->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX;
		fe->impIdent.identSuffix[1] = UDF_OS_ID_LINUX;
1707 1708 1709
		fe->uniqueID = cpu_to_le64(iinfo->i_unique);
		fe->lengthExtendedAttr = cpu_to_le32(iinfo->i_lenEAttr);
		fe->lengthAllocDescs = cpu_to_le32(iinfo->i_lenAlloc);
1710
		fe->checkpoint = cpu_to_le32(iinfo->i_checkpoint);
L
Linus Torvalds 已提交
1711 1712
		fe->descTag.tagIdent = cpu_to_le16(TAG_IDENT_FE);
		crclen = sizeof(struct fileEntry);
1713
	} else {
M
Marcin Slusarz 已提交
1714
		memcpy(bh->b_data + sizeof(struct extendedFileEntry),
1715
		       iinfo->i_ext.i_data,
M
Marcin Slusarz 已提交
1716 1717
		       inode->i_sb->s_blocksize -
					sizeof(struct extendedFileEntry));
L
Linus Torvalds 已提交
1718
		efe->objectSize = cpu_to_le64(inode->i_size);
1719
		efe->logicalBlocksRecorded = cpu_to_le64(lb_recorded);
L
Linus Torvalds 已提交
1720

1721 1722 1723 1724
		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 已提交
1725

1726 1727 1728 1729
		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 已提交
1730

1731 1732 1733 1734
		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 已提交
1735

1736 1737 1738 1739
		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 已提交
1740

1741
		memset(&(efe->impIdent), 0, sizeof(struct regid));
L
Linus Torvalds 已提交
1742 1743 1744
		strcpy(efe->impIdent.ident, UDF_ID_DEVELOPER);
		efe->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX;
		efe->impIdent.identSuffix[1] = UDF_OS_ID_LINUX;
1745 1746 1747
		efe->uniqueID = cpu_to_le64(iinfo->i_unique);
		efe->lengthExtendedAttr = cpu_to_le32(iinfo->i_lenEAttr);
		efe->lengthAllocDescs = cpu_to_le32(iinfo->i_lenAlloc);
1748
		efe->checkpoint = cpu_to_le32(iinfo->i_checkpoint);
L
Linus Torvalds 已提交
1749 1750 1751
		efe->descTag.tagIdent = cpu_to_le16(TAG_IDENT_EFE);
		crclen = sizeof(struct extendedFileEntry);
	}
1752
	if (iinfo->i_strat4096) {
L
Linus Torvalds 已提交
1753 1754 1755
		fe->icbTag.strategyType = cpu_to_le16(4096);
		fe->icbTag.strategyParameter = cpu_to_le16(1);
		fe->icbTag.numEntries = cpu_to_le16(2);
1756
	} else {
L
Linus Torvalds 已提交
1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775
		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;

1776
	icbflags =	iinfo->i_alloc_type |
1777 1778 1779 1780 1781 1782
			((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 已提交
1783 1784

	fe->icbTag.flags = cpu_to_le16(icbflags);
M
Marcin Slusarz 已提交
1785
	if (sbi->s_udfrev >= 0x0200)
L
Linus Torvalds 已提交
1786 1787 1788
		fe->descTag.descVersion = cpu_to_le16(3);
	else
		fe->descTag.descVersion = cpu_to_le16(2);
M
Marcin Slusarz 已提交
1789
	fe->descTag.tagSerialNum = cpu_to_le16(sbi->s_serial_number);
M
Marcin Slusarz 已提交
1790
	fe->descTag.tagLocation = cpu_to_le32(
1791
					iinfo->i_location.logicalBlockNum);
1792
	crclen += iinfo->i_lenEAttr + iinfo->i_lenAlloc - sizeof(struct tag);
L
Linus Torvalds 已提交
1793
	fe->descTag.descCRCLength = cpu_to_le16(crclen);
1794
	fe->descTag.descCRC = cpu_to_le16(crc_itu_t(0, (char *)fe + sizeof(struct tag),
1795
						  crclen));
1796
	fe->descTag.tagChecksum = udf_tag_checksum(&fe->descTag);
L
Linus Torvalds 已提交
1797

1798
out:
1799
	set_buffer_uptodate(bh);
1800 1801
	unlock_buffer(bh);

L
Linus Torvalds 已提交
1802 1803
	/* write the data blocks */
	mark_buffer_dirty(bh);
1804
	if (do_sync) {
L
Linus Torvalds 已提交
1805
		sync_dirty_buffer(bh);
1806
		if (buffer_write_io_error(bh)) {
J
Joe Perches 已提交
1807 1808
			udf_warn(inode->i_sb, "IO error syncing udf inode [%08lx]\n",
				 inode->i_ino);
L
Linus Torvalds 已提交
1809 1810 1811
			err = -EIO;
		}
	}
J
Jan Kara 已提交
1812
	brelse(bh);
1813

L
Linus Torvalds 已提交
1814 1815 1816
	return err;
}

1817
struct inode *udf_iget(struct super_block *sb, struct kernel_lb_addr *ino)
L
Linus Torvalds 已提交
1818 1819 1820 1821 1822 1823 1824 1825
{
	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) {
1826
		memcpy(&UDF_I(inode)->i_location, ino, sizeof(struct kernel_lb_addr));
L
Linus Torvalds 已提交
1827 1828 1829 1830 1831 1832 1833
		__udf_read_inode(inode);
		unlock_new_inode(inode);
	}

	if (is_bad_inode(inode))
		goto out_iput;

1834 1835
	if (ino->logicalBlockNum >= UDF_SB(sb)->
			s_partmaps[ino->partitionReferenceNum].s_partition_len) {
L
Linus Torvalds 已提交
1836
		udf_debug("block=%d, partition=%d out of range\n",
1837
			  ino->logicalBlockNum, ino->partitionReferenceNum);
L
Linus Torvalds 已提交
1838 1839 1840 1841 1842 1843
		make_bad_inode(inode);
		goto out_iput;
	}

	return inode;

1844
 out_iput:
L
Linus Torvalds 已提交
1845 1846 1847 1848
	iput(inode);
	return NULL;
}

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

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

1866
	if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
1867
		adsize = sizeof(struct short_ad);
1868
	else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
1869
		adsize = sizeof(struct long_ad);
L
Linus Torvalds 已提交
1870
	else
1871
		return -EIO;
L
Linus Torvalds 已提交
1872

1873
	if (epos->offset + (2 * adsize) > inode->i_sb->s_blocksize) {
A
Al Viro 已提交
1874
		unsigned char *sptr, *dptr;
L
Linus Torvalds 已提交
1875 1876
		struct buffer_head *nbh;
		int err, loffset;
1877
		struct kernel_lb_addr obloc = epos->block;
L
Linus Torvalds 已提交
1878

M
Marcin Slusarz 已提交
1879 1880 1881 1882
		epos->block.logicalBlockNum = udf_new_block(inode->i_sb, NULL,
						obloc.partitionReferenceNum,
						obloc.logicalBlockNum, &err);
		if (!epos->block.logicalBlockNum)
1883
			return -ENOSPC;
M
Marcin Slusarz 已提交
1884
		nbh = udf_tgetblk(inode->i_sb, udf_get_lb_pblock(inode->i_sb,
1885
								 &epos->block,
M
Marcin Slusarz 已提交
1886 1887
								 0));
		if (!nbh)
1888
			return -EIO;
L
Linus Torvalds 已提交
1889 1890 1891 1892 1893 1894 1895 1896
		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 已提交
1897 1898
			aed->previousAllocExtLocation =
					cpu_to_le32(obloc.logicalBlockNum);
1899
		if (epos->offset + adsize > inode->i_sb->s_blocksize) {
J
Jan Kara 已提交
1900
			loffset = epos->offset;
L
Linus Torvalds 已提交
1901 1902 1903 1904
			aed->lengthAllocDescs = cpu_to_le32(adsize);
			sptr = ptr - adsize;
			dptr = nbh->b_data + sizeof(struct allocExtDesc);
			memcpy(dptr, sptr, adsize);
J
Jan Kara 已提交
1905
			epos->offset = sizeof(struct allocExtDesc) + adsize;
1906
		} else {
J
Jan Kara 已提交
1907
			loffset = epos->offset + adsize;
L
Linus Torvalds 已提交
1908 1909
			aed->lengthAllocDescs = cpu_to_le32(0);
			sptr = ptr;
J
Jan Kara 已提交
1910
			epos->offset = sizeof(struct allocExtDesc);
L
Linus Torvalds 已提交
1911

1912
			if (epos->bh) {
J
Jan Kara 已提交
1913
				aed = (struct allocExtDesc *)epos->bh->b_data;
1914
				le32_add_cpu(&aed->lengthAllocDescs, adsize);
1915
			} else {
1916
				iinfo->i_lenAlloc += adsize;
L
Linus Torvalds 已提交
1917 1918 1919
				mark_inode_dirty(inode);
			}
		}
M
Marcin Slusarz 已提交
1920
		if (UDF_SB(inode->i_sb)->s_udfrev >= 0x0200)
L
Linus Torvalds 已提交
1921
			udf_new_tag(nbh->b_data, TAG_IDENT_AED, 3, 1,
1922
				    epos->block.logicalBlockNum, sizeof(struct tag));
L
Linus Torvalds 已提交
1923 1924
		else
			udf_new_tag(nbh->b_data, TAG_IDENT_AED, 2, 1,
1925
				    epos->block.logicalBlockNum, sizeof(struct tag));
1926
		switch (iinfo->i_alloc_type) {
1927
		case ICBTAG_FLAG_AD_SHORT:
1928
			sad = (struct short_ad *)sptr;
1929 1930
			sad->extLength = cpu_to_le32(EXT_NEXT_EXTENT_ALLOCDECS |
						     inode->i_sb->s_blocksize);
M
Marcin Slusarz 已提交
1931 1932
			sad->extPosition =
				cpu_to_le32(epos->block.logicalBlockNum);
1933
			break;
1934
		case ICBTAG_FLAG_AD_LONG:
1935
			lad = (struct long_ad *)sptr;
1936 1937 1938 1939 1940
			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 已提交
1941
		}
1942
		if (epos->bh) {
1943
			if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) ||
M
Marcin Slusarz 已提交
1944
			    UDF_SB(inode->i_sb)->s_udfrev >= 0x0201)
J
Jan Kara 已提交
1945
				udf_update_tag(epos->bh->b_data, loffset);
L
Linus Torvalds 已提交
1946
			else
M
Marcin Slusarz 已提交
1947 1948
				udf_update_tag(epos->bh->b_data,
						sizeof(struct allocExtDesc));
J
Jan Kara 已提交
1949
			mark_buffer_dirty_inode(epos->bh, inode);
J
Jan Kara 已提交
1950
			brelse(epos->bh);
1951
		} else {
L
Linus Torvalds 已提交
1952
			mark_inode_dirty(inode);
1953
		}
J
Jan Kara 已提交
1954
		epos->bh = nbh;
L
Linus Torvalds 已提交
1955 1956
	}

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

1959
	if (!epos->bh) {
1960
		iinfo->i_lenAlloc += adsize;
L
Linus Torvalds 已提交
1961
		mark_inode_dirty(inode);
1962
	} else {
J
Jan Kara 已提交
1963
		aed = (struct allocExtDesc *)epos->bh->b_data;
1964
		le32_add_cpu(&aed->lengthAllocDescs, adsize);
M
Marcin Slusarz 已提交
1965 1966 1967 1968
		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 已提交
1969
		else
M
Marcin Slusarz 已提交
1970 1971
			udf_update_tag(epos->bh->b_data,
					sizeof(struct allocExtDesc));
J
Jan Kara 已提交
1972
		mark_buffer_dirty_inode(epos->bh, inode);
L
Linus Torvalds 已提交
1973 1974
	}

1975
	return 0;
L
Linus Torvalds 已提交
1976 1977
}

1978 1979
void udf_write_aext(struct inode *inode, struct extent_position *epos,
		    struct kernel_lb_addr *eloc, uint32_t elen, int inc)
L
Linus Torvalds 已提交
1980 1981 1982
{
	int adsize;
	uint8_t *ptr;
1983 1984
	struct short_ad *sad;
	struct long_ad *lad;
1985
	struct udf_inode_info *iinfo = UDF_I(inode);
L
Linus Torvalds 已提交
1986

J
Jan Kara 已提交
1987
	if (!epos->bh)
1988
		ptr = iinfo->i_ext.i_data + epos->offset -
M
Marcin Slusarz 已提交
1989
			udf_file_entry_alloc_offset(inode) +
1990
			iinfo->i_lenEAttr;
L
Linus Torvalds 已提交
1991
	else
J
Jan Kara 已提交
1992
		ptr = epos->bh->b_data + epos->offset;
L
Linus Torvalds 已提交
1993

1994
	switch (iinfo->i_alloc_type) {
1995
	case ICBTAG_FLAG_AD_SHORT:
1996
		sad = (struct short_ad *)ptr;
1997
		sad->extLength = cpu_to_le32(elen);
1998
		sad->extPosition = cpu_to_le32(eloc->logicalBlockNum);
1999
		adsize = sizeof(struct short_ad);
2000
		break;
2001
	case ICBTAG_FLAG_AD_LONG:
2002
		lad = (struct long_ad *)ptr;
2003
		lad->extLength = cpu_to_le32(elen);
2004
		lad->extLocation = cpu_to_lelb(*eloc);
2005
		memset(lad->impUse, 0x00, sizeof(lad->impUse));
2006
		adsize = sizeof(struct long_ad);
2007
		break;
2008
	default:
2009
		return;
L
Linus Torvalds 已提交
2010 2011
	}

2012
	if (epos->bh) {
2013
		if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) ||
M
Marcin Slusarz 已提交
2014
		    UDF_SB(inode->i_sb)->s_udfrev >= 0x0201) {
M
Marcin Slusarz 已提交
2015 2016
			struct allocExtDesc *aed =
				(struct allocExtDesc *)epos->bh->b_data;
J
Jan Kara 已提交
2017
			udf_update_tag(epos->bh->b_data,
M
Marcin Slusarz 已提交
2018 2019
				       le32_to_cpu(aed->lengthAllocDescs) +
				       sizeof(struct allocExtDesc));
L
Linus Torvalds 已提交
2020
		}
J
Jan Kara 已提交
2021
		mark_buffer_dirty_inode(epos->bh, inode);
2022
	} else {
L
Linus Torvalds 已提交
2023
		mark_inode_dirty(inode);
2024
	}
L
Linus Torvalds 已提交
2025 2026

	if (inc)
J
Jan Kara 已提交
2027
		epos->offset += adsize;
L
Linus Torvalds 已提交
2028 2029
}

M
Marcin Slusarz 已提交
2030
int8_t udf_next_aext(struct inode *inode, struct extent_position *epos,
2031
		     struct kernel_lb_addr *eloc, uint32_t *elen, int inc)
L
Linus Torvalds 已提交
2032 2033 2034
{
	int8_t etype;

J
Jan Kara 已提交
2035
	while ((etype = udf_current_aext(inode, epos, eloc, elen, inc)) ==
2036
	       (EXT_NEXT_EXTENT_ALLOCDECS >> 30)) {
M
Marcin Slusarz 已提交
2037
		int block;
J
Jan Kara 已提交
2038 2039
		epos->block = *eloc;
		epos->offset = sizeof(struct allocExtDesc);
J
Jan Kara 已提交
2040
		brelse(epos->bh);
2041
		block = udf_get_lb_pblock(inode->i_sb, &epos->block, 0);
M
Marcin Slusarz 已提交
2042 2043 2044
		epos->bh = udf_tread(inode->i_sb, block);
		if (!epos->bh) {
			udf_debug("reading block %d failed!\n", block);
L
Linus Torvalds 已提交
2045 2046 2047 2048 2049 2050 2051
			return -1;
		}
	}

	return etype;
}

M
Marcin Slusarz 已提交
2052
int8_t udf_current_aext(struct inode *inode, struct extent_position *epos,
2053
			struct kernel_lb_addr *eloc, uint32_t *elen, int inc)
L
Linus Torvalds 已提交
2054 2055 2056 2057
{
	int alen;
	int8_t etype;
	uint8_t *ptr;
2058 2059
	struct short_ad *sad;
	struct long_ad *lad;
2060
	struct udf_inode_info *iinfo = UDF_I(inode);
2061

2062
	if (!epos->bh) {
J
Jan Kara 已提交
2063 2064
		if (!epos->offset)
			epos->offset = udf_file_entry_alloc_offset(inode);
2065
		ptr = iinfo->i_ext.i_data + epos->offset -
M
Marcin Slusarz 已提交
2066
			udf_file_entry_alloc_offset(inode) +
2067
			iinfo->i_lenEAttr;
M
Marcin Slusarz 已提交
2068
		alen = udf_file_entry_alloc_offset(inode) +
2069
							iinfo->i_lenAlloc;
2070
	} else {
J
Jan Kara 已提交
2071 2072 2073
		if (!epos->offset)
			epos->offset = sizeof(struct allocExtDesc);
		ptr = epos->bh->b_data + epos->offset;
2074
		alen = sizeof(struct allocExtDesc) +
M
Marcin Slusarz 已提交
2075 2076
			le32_to_cpu(((struct allocExtDesc *)epos->bh->b_data)->
							lengthAllocDescs);
L
Linus Torvalds 已提交
2077 2078
	}

2079
	switch (iinfo->i_alloc_type) {
2080
	case ICBTAG_FLAG_AD_SHORT:
M
Marcin Slusarz 已提交
2081 2082
		sad = udf_get_fileshortad(ptr, alen, &epos->offset, inc);
		if (!sad)
2083 2084 2085
			return -1;
		etype = le32_to_cpu(sad->extLength) >> 30;
		eloc->logicalBlockNum = le32_to_cpu(sad->extPosition);
M
Marcin Slusarz 已提交
2086
		eloc->partitionReferenceNum =
2087
				iinfo->i_location.partitionReferenceNum;
2088 2089
		*elen = le32_to_cpu(sad->extLength) & UDF_EXTENT_LENGTH_MASK;
		break;
2090
	case ICBTAG_FLAG_AD_LONG:
M
Marcin Slusarz 已提交
2091 2092
		lad = udf_get_filelongad(ptr, alen, &epos->offset, inc);
		if (!lad)
L
Linus Torvalds 已提交
2093
			return -1;
2094 2095 2096 2097 2098
		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 已提交
2099
		udf_debug("alloc_type = %d unsupported\n", iinfo->i_alloc_type);
2100
		return -1;
L
Linus Torvalds 已提交
2101 2102 2103 2104 2105
	}

	return etype;
}

2106
static int8_t udf_insert_aext(struct inode *inode, struct extent_position epos,
2107
			      struct kernel_lb_addr neloc, uint32_t nelen)
L
Linus Torvalds 已提交
2108
{
2109
	struct kernel_lb_addr oeloc;
L
Linus Torvalds 已提交
2110 2111 2112
	uint32_t oelen;
	int8_t etype;

J
Jan Kara 已提交
2113
	if (epos.bh)
J
Jan Kara 已提交
2114
		get_bh(epos.bh);
L
Linus Torvalds 已提交
2115

2116
	while ((etype = udf_next_aext(inode, &epos, &oeloc, &oelen, 0)) != -1) {
2117
		udf_write_aext(inode, &epos, &neloc, nelen, 1);
L
Linus Torvalds 已提交
2118 2119 2120
		neloc = oeloc;
		nelen = (etype << 30) | oelen;
	}
2121
	udf_add_aext(inode, &epos, &neloc, nelen, 1);
J
Jan Kara 已提交
2122
	brelse(epos.bh);
2123

L
Linus Torvalds 已提交
2124 2125 2126
	return (nelen >> 30);
}

M
Marcin Slusarz 已提交
2127
int8_t udf_delete_aext(struct inode *inode, struct extent_position epos,
2128
		       struct kernel_lb_addr eloc, uint32_t elen)
L
Linus Torvalds 已提交
2129
{
J
Jan Kara 已提交
2130 2131
	struct extent_position oepos;
	int adsize;
L
Linus Torvalds 已提交
2132 2133
	int8_t etype;
	struct allocExtDesc *aed;
2134
	struct udf_inode_info *iinfo;
L
Linus Torvalds 已提交
2135

2136
	if (epos.bh) {
J
Jan Kara 已提交
2137 2138
		get_bh(epos.bh);
		get_bh(epos.bh);
L
Linus Torvalds 已提交
2139 2140
	}

2141 2142
	iinfo = UDF_I(inode);
	if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
2143
		adsize = sizeof(struct short_ad);
2144
	else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
2145
		adsize = sizeof(struct long_ad);
L
Linus Torvalds 已提交
2146 2147 2148
	else
		adsize = 0;

J
Jan Kara 已提交
2149 2150
	oepos = epos;
	if (udf_next_aext(inode, &epos, &eloc, &elen, 1) == -1)
L
Linus Torvalds 已提交
2151 2152
		return -1;

2153
	while ((etype = udf_next_aext(inode, &epos, &eloc, &elen, 1)) != -1) {
2154
		udf_write_aext(inode, &oepos, &eloc, (etype << 30) | elen, 1);
2155
		if (oepos.bh != epos.bh) {
J
Jan Kara 已提交
2156
			oepos.block = epos.block;
J
Jan Kara 已提交
2157 2158
			brelse(oepos.bh);
			get_bh(epos.bh);
J
Jan Kara 已提交
2159 2160
			oepos.bh = epos.bh;
			oepos.offset = epos.offset - adsize;
L
Linus Torvalds 已提交
2161 2162
		}
	}
2163
	memset(&eloc, 0x00, sizeof(struct kernel_lb_addr));
L
Linus Torvalds 已提交
2164 2165
	elen = 0;

2166
	if (epos.bh != oepos.bh) {
2167 2168 2169
		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);
2170
		if (!oepos.bh) {
2171
			iinfo->i_lenAlloc -= (adsize * 2);
L
Linus Torvalds 已提交
2172
			mark_inode_dirty(inode);
2173
		} else {
J
Jan Kara 已提交
2174
			aed = (struct allocExtDesc *)oepos.bh->b_data;
2175
			le32_add_cpu(&aed->lengthAllocDescs, -(2 * adsize));
2176
			if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) ||
M
Marcin Slusarz 已提交
2177
			    UDF_SB(inode->i_sb)->s_udfrev >= 0x0201)
M
Marcin Slusarz 已提交
2178 2179
				udf_update_tag(oepos.bh->b_data,
						oepos.offset - (2 * adsize));
L
Linus Torvalds 已提交
2180
			else
M
Marcin Slusarz 已提交
2181 2182
				udf_update_tag(oepos.bh->b_data,
						sizeof(struct allocExtDesc));
J
Jan Kara 已提交
2183
			mark_buffer_dirty_inode(oepos.bh, inode);
L
Linus Torvalds 已提交
2184
		}
2185
	} else {
2186
		udf_write_aext(inode, &oepos, &eloc, elen, 1);
2187
		if (!oepos.bh) {
2188
			iinfo->i_lenAlloc -= adsize;
L
Linus Torvalds 已提交
2189
			mark_inode_dirty(inode);
2190
		} else {
J
Jan Kara 已提交
2191
			aed = (struct allocExtDesc *)oepos.bh->b_data;
2192
			le32_add_cpu(&aed->lengthAllocDescs, -adsize);
2193
			if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) ||
M
Marcin Slusarz 已提交
2194
			    UDF_SB(inode->i_sb)->s_udfrev >= 0x0201)
M
Marcin Slusarz 已提交
2195 2196
				udf_update_tag(oepos.bh->b_data,
						epos.offset - adsize);
L
Linus Torvalds 已提交
2197
			else
M
Marcin Slusarz 已提交
2198 2199
				udf_update_tag(oepos.bh->b_data,
						sizeof(struct allocExtDesc));
J
Jan Kara 已提交
2200
			mark_buffer_dirty_inode(oepos.bh, inode);
L
Linus Torvalds 已提交
2201 2202
		}
	}
2203

J
Jan Kara 已提交
2204 2205
	brelse(epos.bh);
	brelse(oepos.bh);
2206

L
Linus Torvalds 已提交
2207 2208 2209
	return (elen >> 30);
}

M
Marcin Slusarz 已提交
2210
int8_t inode_bmap(struct inode *inode, sector_t block,
2211
		  struct extent_position *pos, struct kernel_lb_addr *eloc,
M
Marcin Slusarz 已提交
2212
		  uint32_t *elen, sector_t *offset)
L
Linus Torvalds 已提交
2213
{
M
Marcin Slusarz 已提交
2214
	unsigned char blocksize_bits = inode->i_sb->s_blocksize_bits;
2215
	loff_t lbcount = 0, bcount =
M
Marcin Slusarz 已提交
2216
	    (loff_t) block << blocksize_bits;
L
Linus Torvalds 已提交
2217
	int8_t etype;
2218
	struct udf_inode_info *iinfo;
L
Linus Torvalds 已提交
2219

2220
	iinfo = UDF_I(inode);
2221 2222 2223 2224 2225
	if (!udf_read_extent_cache(inode, bcount, &lbcount, pos)) {
		pos->offset = 0;
		pos->block = iinfo->i_location;
		pos->bh = NULL;
	}
L
Linus Torvalds 已提交
2226
	*elen = 0;
2227
	do {
M
Marcin Slusarz 已提交
2228 2229 2230
		etype = udf_next_aext(inode, pos, eloc, elen, 1);
		if (etype == -1) {
			*offset = (bcount - lbcount) >> blocksize_bits;
2231
			iinfo->i_lenExtents = lbcount;
L
Linus Torvalds 已提交
2232 2233 2234 2235
			return -1;
		}
		lbcount += *elen;
	} while (lbcount <= bcount);
2236 2237
	/* update extent cache */
	udf_update_extent_cache(inode, lbcount - *elen, pos, 1);
M
Marcin Slusarz 已提交
2238
	*offset = (bcount + *elen - lbcount) >> blocksize_bits;
L
Linus Torvalds 已提交
2239 2240 2241 2242

	return etype;
}

2243
long udf_block_map(struct inode *inode, sector_t block)
L
Linus Torvalds 已提交
2244
{
2245
	struct kernel_lb_addr eloc;
J
Jan Kara 已提交
2246
	uint32_t elen;
2247
	sector_t offset;
2248
	struct extent_position epos = {};
L
Linus Torvalds 已提交
2249 2250
	int ret;

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

M
Marcin Slusarz 已提交
2253 2254
	if (inode_bmap(inode, block, &epos, &eloc, &elen, &offset) ==
						(EXT_RECORDED_ALLOCATED >> 30))
2255
		ret = udf_get_lb_pblock(inode->i_sb, &eloc, offset);
L
Linus Torvalds 已提交
2256 2257 2258
	else
		ret = 0;

2259
	up_read(&UDF_I(inode)->i_data_sem);
J
Jan Kara 已提交
2260
	brelse(epos.bh);
L
Linus Torvalds 已提交
2261 2262 2263 2264 2265 2266

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