blob: dc2f946dfca958d5d20883978ffa71e16b841900 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * inode.c
3 *
4 * PURPOSE
5 * Inode handling routines for the OSTA-UDF(tm) filesystem.
6 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 * COPYRIGHT
8 * This file is distributed under the terms of the GNU General Public
9 * License (GPL). Copies of the GPL can be obtained from:
10 * ftp://prep.ai.mit.edu/pub/gnu/GPL
11 * Each contributing author retains all rights to their own work.
12 *
13 * (C) 1998 Dave Boynton
14 * (C) 1998-2004 Ben Fennema
15 * (C) 1999-2000 Stelias Computing Inc
16 *
17 * HISTORY
18 *
19 * 10/04/98 dgb Added rudimentary directory functions
20 * 10/07/98 Fully working udf_block_map! It works!
21 * 11/25/98 bmap altered to better support extents
Marcin Slusarz4b111112008-02-08 04:20:36 -080022 * 12/06/98 blf partition support in udf_iget, udf_block_map
23 * and udf_read_inode
Linus Torvalds1da177e2005-04-16 15:20:36 -070024 * 12/12/98 rewrote udf_block_map to handle next extents and descs across
25 * block boundaries (which is not actually allowed)
26 * 12/20/98 added support for strategy 4096
27 * 03/07/99 rewrote udf_block_map (again)
28 * New funcs, inode_bmap, udf_next_aext
29 * 04/19/99 Support for writing device EA's for major/minor #
30 */
31
32#include "udfdecl.h"
33#include <linux/mm.h>
34#include <linux/smp_lock.h>
35#include <linux/module.h>
36#include <linux/pagemap.h>
37#include <linux/buffer_head.h>
38#include <linux/writeback.h>
39#include <linux/slab.h>
40
41#include "udf_i.h"
42#include "udf_sb.h"
43
44MODULE_AUTHOR("Ben Fennema");
45MODULE_DESCRIPTION("Universal Disk Format Filesystem");
46MODULE_LICENSE("GPL");
47
48#define EXTENT_MERGE_SIZE 5
49
50static mode_t udf_convert_permissions(struct fileEntry *);
51static int udf_update_inode(struct inode *, int);
52static void udf_fill_inode(struct inode *, struct buffer_head *);
Cyrill Gorcunov647bd612007-07-15 23:39:47 -070053static int udf_alloc_i_data(struct inode *inode, size_t size);
Jan Kara60448b12007-05-08 00:35:13 -070054static struct buffer_head *inode_getblk(struct inode *, sector_t, int *,
Marcin Slusarz1ed16172008-02-08 04:20:48 -080055 sector_t *, int *);
Jan Karaff116fc2007-05-08 00:35:14 -070056static int8_t udf_insert_aext(struct inode *, struct extent_position,
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -070057 kernel_lb_addr, uint32_t);
Linus Torvalds1da177e2005-04-16 15:20:36 -070058static void udf_split_extents(struct inode *, int *, int, int,
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -070059 kernel_long_ad[EXTENT_MERGE_SIZE], int *);
Linus Torvalds1da177e2005-04-16 15:20:36 -070060static void udf_prealloc_extents(struct inode *, int, int,
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -070061 kernel_long_ad[EXTENT_MERGE_SIZE], int *);
Linus Torvalds1da177e2005-04-16 15:20:36 -070062static void udf_merge_extents(struct inode *,
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -070063 kernel_long_ad[EXTENT_MERGE_SIZE], int *);
Linus Torvalds1da177e2005-04-16 15:20:36 -070064static void udf_update_extents(struct inode *,
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -070065 kernel_long_ad[EXTENT_MERGE_SIZE], int, int,
66 struct extent_position *);
Linus Torvalds1da177e2005-04-16 15:20:36 -070067static int udf_get_block(struct inode *, sector_t, struct buffer_head *, int);
68
Christoph Hellwigb1e32122008-02-22 12:38:48 +010069
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -070070void udf_delete_inode(struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -070071{
Mark Fashehfef26652005-09-09 13:01:31 -070072 truncate_inode_pages(&inode->i_data, 0);
73
Linus Torvalds1da177e2005-04-16 15:20:36 -070074 if (is_bad_inode(inode))
75 goto no_delete;
76
77 inode->i_size = 0;
78 udf_truncate(inode);
79 lock_kernel();
80
81 udf_update_inode(inode, IS_SYNC(inode));
82 udf_free_inode(inode);
83
84 unlock_kernel();
85 return;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -070086
87no_delete:
Linus Torvalds1da177e2005-04-16 15:20:36 -070088 clear_inode(inode);
89}
90
Jan Kara74584ae2007-06-16 10:16:14 -070091/*
92 * If we are going to release inode from memory, we discard preallocation and
93 * truncate last inode extent to proper length. We could use drop_inode() but
94 * it's called under inode_lock and thus we cannot mark inode dirty there. We
95 * use clear_inode() but we have to make sure to write inode as it's not written
96 * automatically.
97 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070098void udf_clear_inode(struct inode *inode)
99{
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800100 struct udf_inode_info *iinfo;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101 if (!(inode->i_sb->s_flags & MS_RDONLY)) {
102 lock_kernel();
Jan Kara74584ae2007-06-16 10:16:14 -0700103 /* Discard preallocation for directories, symlinks, etc. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104 udf_discard_prealloc(inode);
Jan Kara74584ae2007-06-16 10:16:14 -0700105 udf_truncate_tail_extent(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106 unlock_kernel();
Mike Galbraith32a8f242008-02-08 04:20:49 -0800107 write_inode_now(inode, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108 }
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800109 iinfo = UDF_I(inode);
110 kfree(iinfo->i_ext.i_data);
111 iinfo->i_ext.i_data = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112}
113
114static int udf_writepage(struct page *page, struct writeback_control *wbc)
115{
116 return block_write_full_page(page, udf_get_block, wbc);
117}
118
119static int udf_readpage(struct file *file, struct page *page)
120{
121 return block_read_full_page(page, udf_get_block);
122}
123
Nick Pigginbe021ee2007-10-16 01:25:20 -0700124static int udf_write_begin(struct file *file, struct address_space *mapping,
125 loff_t pos, unsigned len, unsigned flags,
126 struct page **pagep, void **fsdata)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127{
Nick Pigginbe021ee2007-10-16 01:25:20 -0700128 *pagep = NULL;
129 return block_write_begin(file, mapping, pos, len, flags, pagep, fsdata,
130 udf_get_block);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131}
132
133static sector_t udf_bmap(struct address_space *mapping, sector_t block)
134{
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700135 return generic_block_bmap(mapping, block, udf_get_block);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136}
137
Christoph Hellwigf5e54d62006-06-28 04:26:44 -0700138const struct address_space_operations udf_aops = {
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700139 .readpage = udf_readpage,
140 .writepage = udf_writepage,
141 .sync_page = block_sync_page,
Nick Pigginbe021ee2007-10-16 01:25:20 -0700142 .write_begin = udf_write_begin,
143 .write_end = generic_write_end,
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700144 .bmap = udf_bmap,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145};
146
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700147void udf_expand_file_adinicb(struct inode *inode, int newsize, int *err)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148{
149 struct page *page;
150 char *kaddr;
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800151 struct udf_inode_info *iinfo = UDF_I(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152 struct writeback_control udf_wbc = {
153 .sync_mode = WB_SYNC_NONE,
154 .nr_to_write = 1,
155 };
156
157 /* from now on we have normal address_space methods */
158 inode->i_data.a_ops = &udf_aops;
159
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800160 if (!iinfo->i_lenAlloc) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161 if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_SHORT_AD))
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800162 iinfo->i_alloc_type = ICBTAG_FLAG_AD_SHORT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163 else
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800164 iinfo->i_alloc_type = ICBTAG_FLAG_AD_LONG;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165 mark_inode_dirty(inode);
166 return;
167 }
168
169 page = grab_cache_page(inode->i_mapping, 0);
Matt Mackallcd7619d2005-05-01 08:59:01 -0700170 BUG_ON(!PageLocked(page));
171
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700172 if (!PageUptodate(page)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173 kaddr = kmap(page);
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800174 memset(kaddr + iinfo->i_lenAlloc, 0x00,
175 PAGE_CACHE_SIZE - iinfo->i_lenAlloc);
176 memcpy(kaddr, iinfo->i_ext.i_data + iinfo->i_lenEAttr,
177 iinfo->i_lenAlloc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178 flush_dcache_page(page);
179 SetPageUptodate(page);
180 kunmap(page);
181 }
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800182 memset(iinfo->i_ext.i_data + iinfo->i_lenEAttr, 0x00,
183 iinfo->i_lenAlloc);
184 iinfo->i_lenAlloc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185 if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_SHORT_AD))
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800186 iinfo->i_alloc_type = ICBTAG_FLAG_AD_SHORT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187 else
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800188 iinfo->i_alloc_type = ICBTAG_FLAG_AD_LONG;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189
190 inode->i_data.a_ops->writepage(page, &udf_wbc);
191 page_cache_release(page);
192
193 mark_inode_dirty(inode);
194}
195
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700196struct buffer_head *udf_expand_dir_adinicb(struct inode *inode, int *block,
197 int *err)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198{
199 int newblock;
Jan Karaff116fc2007-05-08 00:35:14 -0700200 struct buffer_head *dbh = NULL;
201 kernel_lb_addr eloc;
202 uint32_t elen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203 uint8_t alloctype;
Jan Karaff116fc2007-05-08 00:35:14 -0700204 struct extent_position epos;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205
206 struct udf_fileident_bh sfibh, dfibh;
Jan Karaaf793292008-02-08 04:20:50 -0800207 loff_t f_pos = udf_ext0_offset(inode);
208 int size = udf_ext0_offset(inode) + inode->i_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209 struct fileIdentDesc cfi, *sfi, *dfi;
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800210 struct udf_inode_info *iinfo = UDF_I(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211
212 if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_SHORT_AD))
213 alloctype = ICBTAG_FLAG_AD_SHORT;
214 else
215 alloctype = ICBTAG_FLAG_AD_LONG;
216
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700217 if (!inode->i_size) {
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800218 iinfo->i_alloc_type = alloctype;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219 mark_inode_dirty(inode);
220 return NULL;
221 }
222
223 /* alloc block, and copy data to it */
224 *block = udf_new_block(inode->i_sb, inode,
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800225 iinfo->i_location.partitionReferenceNum,
226 iinfo->i_location.logicalBlockNum, err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227 if (!(*block))
228 return NULL;
229 newblock = udf_get_pblock(inode->i_sb, *block,
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800230 iinfo->i_location.partitionReferenceNum,
Marcin Slusarzc0b34432008-02-08 04:20:42 -0800231 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232 if (!newblock)
233 return NULL;
234 dbh = udf_tgetblk(inode->i_sb, newblock);
235 if (!dbh)
236 return NULL;
237 lock_buffer(dbh);
238 memset(dbh->b_data, 0x00, inode->i_sb->s_blocksize);
239 set_buffer_uptodate(dbh);
240 unlock_buffer(dbh);
241 mark_buffer_dirty_inode(dbh, inode);
242
Marcin Slusarz4b111112008-02-08 04:20:36 -0800243 sfibh.soffset = sfibh.eoffset =
Jan Karaaf793292008-02-08 04:20:50 -0800244 f_pos & (inode->i_sb->s_blocksize - 1);
Jan Karaff116fc2007-05-08 00:35:14 -0700245 sfibh.sbh = sfibh.ebh = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246 dfibh.soffset = dfibh.eoffset = 0;
247 dfibh.sbh = dfibh.ebh = dbh;
Jan Karaaf793292008-02-08 04:20:50 -0800248 while (f_pos < size) {
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800249 iinfo->i_alloc_type = ICBTAG_FLAG_AD_IN_ICB;
Marcin Slusarz4b111112008-02-08 04:20:36 -0800250 sfi = udf_fileident_read(inode, &f_pos, &sfibh, &cfi, NULL,
251 NULL, NULL, NULL);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700252 if (!sfi) {
Jan Kara3bf25cb2007-05-08 00:35:16 -0700253 brelse(dbh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254 return NULL;
255 }
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800256 iinfo->i_alloc_type = alloctype;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257 sfi->descTag.tagLocation = cpu_to_le32(*block);
258 dfibh.soffset = dfibh.eoffset;
259 dfibh.eoffset += (sfibh.eoffset - sfibh.soffset);
260 dfi = (struct fileIdentDesc *)(dbh->b_data + dfibh.soffset);
261 if (udf_write_fi(inode, sfi, dfi, &dfibh, sfi->impUse,
Marcin Slusarz4b111112008-02-08 04:20:36 -0800262 sfi->fileIdent +
263 le16_to_cpu(sfi->lengthOfImpUse))) {
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800264 iinfo->i_alloc_type = ICBTAG_FLAG_AD_IN_ICB;
Jan Kara3bf25cb2007-05-08 00:35:16 -0700265 brelse(dbh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266 return NULL;
267 }
268 }
269 mark_buffer_dirty_inode(dbh, inode);
270
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800271 memset(iinfo->i_ext.i_data + iinfo->i_lenEAttr, 0,
272 iinfo->i_lenAlloc);
273 iinfo->i_lenAlloc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274 eloc.logicalBlockNum = *block;
Marcin Slusarz4b111112008-02-08 04:20:36 -0800275 eloc.partitionReferenceNum =
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800276 iinfo->i_location.partitionReferenceNum;
Jan Kara05343c42008-02-08 04:20:51 -0800277 elen = inode->i_sb->s_blocksize;
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800278 iinfo->i_lenExtents = elen;
Jan Karaff116fc2007-05-08 00:35:14 -0700279 epos.bh = NULL;
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800280 epos.block = iinfo->i_location;
Jan Karaff116fc2007-05-08 00:35:14 -0700281 epos.offset = udf_file_entry_alloc_offset(inode);
282 udf_add_aext(inode, &epos, eloc, elen, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283 /* UniqueID stuff */
284
Jan Kara3bf25cb2007-05-08 00:35:16 -0700285 brelse(epos.bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286 mark_inode_dirty(inode);
287 return dbh;
288}
289
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700290static int udf_get_block(struct inode *inode, sector_t block,
291 struct buffer_head *bh_result, int create)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292{
293 int err, new;
294 struct buffer_head *bh;
Marcin Slusarz1ed16172008-02-08 04:20:48 -0800295 sector_t phys = 0;
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800296 struct udf_inode_info *iinfo;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700298 if (!create) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299 phys = udf_block_map(inode, block);
300 if (phys)
301 map_bh(bh_result, inode->i_sb, phys);
302 return 0;
303 }
304
305 err = -EIO;
306 new = 0;
307 bh = NULL;
308
309 lock_kernel();
310
311 if (block < 0)
312 goto abort_negative;
313
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800314 iinfo = UDF_I(inode);
315 if (block == iinfo->i_next_alloc_block + 1) {
316 iinfo->i_next_alloc_block++;
317 iinfo->i_next_alloc_goal++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318 }
319
320 err = 0;
321
322 bh = inode_getblk(inode, block, &err, &phys, &new);
Eric Sesterhenn2c2111c2006-04-02 13:40:13 +0200323 BUG_ON(bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324 if (err)
325 goto abort;
Eric Sesterhenn2c2111c2006-04-02 13:40:13 +0200326 BUG_ON(!phys);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327
328 if (new)
329 set_buffer_new(bh_result);
330 map_bh(bh_result, inode->i_sb, phys);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700331
332abort:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700333 unlock_kernel();
334 return err;
335
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700336abort_negative:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337 udf_warning(inode->i_sb, "udf_get_block", "block < 0");
338 goto abort;
339}
340
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700341static struct buffer_head *udf_getblk(struct inode *inode, long block,
342 int create, int *err)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343{
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700344 struct buffer_head *bh;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345 struct buffer_head dummy;
346
347 dummy.b_state = 0;
348 dummy.b_blocknr = -1000;
349 *err = udf_get_block(inode, block, &dummy, create);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700350 if (!*err && buffer_mapped(&dummy)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351 bh = sb_getblk(inode->i_sb, dummy.b_blocknr);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700352 if (buffer_new(&dummy)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353 lock_buffer(bh);
354 memset(bh->b_data, 0x00, inode->i_sb->s_blocksize);
355 set_buffer_uptodate(bh);
356 unlock_buffer(bh);
357 mark_buffer_dirty_inode(bh, inode);
358 }
359 return bh;
360 }
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700361
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362 return NULL;
363}
364
Jan Kara31170b62007-05-08 00:35:21 -0700365/* Extend the file by 'blocks' blocks, return the number of extents added */
366int udf_extend_file(struct inode *inode, struct extent_position *last_pos,
Marcin Slusarz4b111112008-02-08 04:20:36 -0800367 kernel_long_ad *last_ext, sector_t blocks)
Jan Kara31170b62007-05-08 00:35:21 -0700368{
369 sector_t add;
370 int count = 0, fake = !(last_ext->extLength & UDF_EXTENT_LENGTH_MASK);
371 struct super_block *sb = inode->i_sb;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700372 kernel_lb_addr prealloc_loc = {};
Jan Kara31170b62007-05-08 00:35:21 -0700373 int prealloc_len = 0;
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800374 struct udf_inode_info *iinfo;
Jan Kara31170b62007-05-08 00:35:21 -0700375
376 /* The previous extent is fake and we should not extend by anything
377 * - there's nothing to do... */
378 if (!blocks && fake)
379 return 0;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700380
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800381 iinfo = UDF_I(inode);
Jan Kara31170b62007-05-08 00:35:21 -0700382 /* Round the last extent up to a multiple of block size */
383 if (last_ext->extLength & (sb->s_blocksize - 1)) {
384 last_ext->extLength =
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700385 (last_ext->extLength & UDF_EXTENT_FLAG_MASK) |
386 (((last_ext->extLength & UDF_EXTENT_LENGTH_MASK) +
387 sb->s_blocksize - 1) & ~(sb->s_blocksize - 1));
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800388 iinfo->i_lenExtents =
389 (iinfo->i_lenExtents + sb->s_blocksize - 1) &
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700390 ~(sb->s_blocksize - 1);
Jan Kara31170b62007-05-08 00:35:21 -0700391 }
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700392
Jan Kara31170b62007-05-08 00:35:21 -0700393 /* Last extent are just preallocated blocks? */
Marcin Slusarz4b111112008-02-08 04:20:36 -0800394 if ((last_ext->extLength & UDF_EXTENT_FLAG_MASK) ==
395 EXT_NOT_RECORDED_ALLOCATED) {
Jan Kara31170b62007-05-08 00:35:21 -0700396 /* Save the extent so that we can reattach it to the end */
397 prealloc_loc = last_ext->extLocation;
398 prealloc_len = last_ext->extLength;
399 /* Mark the extent as a hole */
400 last_ext->extLength = EXT_NOT_RECORDED_NOT_ALLOCATED |
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700401 (last_ext->extLength & UDF_EXTENT_LENGTH_MASK);
Jan Kara31170b62007-05-08 00:35:21 -0700402 last_ext->extLocation.logicalBlockNum = 0;
Marcin Slusarz4b111112008-02-08 04:20:36 -0800403 last_ext->extLocation.partitionReferenceNum = 0;
Jan Kara31170b62007-05-08 00:35:21 -0700404 }
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700405
Jan Kara31170b62007-05-08 00:35:21 -0700406 /* Can we merge with the previous extent? */
Marcin Slusarz4b111112008-02-08 04:20:36 -0800407 if ((last_ext->extLength & UDF_EXTENT_FLAG_MASK) ==
408 EXT_NOT_RECORDED_NOT_ALLOCATED) {
409 add = ((1 << 30) - sb->s_blocksize -
410 (last_ext->extLength & UDF_EXTENT_LENGTH_MASK)) >>
411 sb->s_blocksize_bits;
Jan Kara31170b62007-05-08 00:35:21 -0700412 if (add > blocks)
413 add = blocks;
414 blocks -= add;
415 last_ext->extLength += add << sb->s_blocksize_bits;
416 }
417
418 if (fake) {
419 udf_add_aext(inode, last_pos, last_ext->extLocation,
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700420 last_ext->extLength, 1);
Jan Kara31170b62007-05-08 00:35:21 -0700421 count++;
Marcin Slusarz4b111112008-02-08 04:20:36 -0800422 } else
423 udf_write_aext(inode, last_pos, last_ext->extLocation,
424 last_ext->extLength, 1);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700425
Jan Kara31170b62007-05-08 00:35:21 -0700426 /* Managed to do everything necessary? */
427 if (!blocks)
428 goto out;
429
430 /* All further extents will be NOT_RECORDED_NOT_ALLOCATED */
431 last_ext->extLocation.logicalBlockNum = 0;
Marcin Slusarz4b111112008-02-08 04:20:36 -0800432 last_ext->extLocation.partitionReferenceNum = 0;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700433 add = (1 << (30-sb->s_blocksize_bits)) - 1;
Marcin Slusarz4b111112008-02-08 04:20:36 -0800434 last_ext->extLength = EXT_NOT_RECORDED_NOT_ALLOCATED |
435 (add << sb->s_blocksize_bits);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700436
Jan Kara31170b62007-05-08 00:35:21 -0700437 /* Create enough extents to cover the whole hole */
438 while (blocks > add) {
439 blocks -= add;
440 if (udf_add_aext(inode, last_pos, last_ext->extLocation,
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700441 last_ext->extLength, 1) == -1)
Jan Kara31170b62007-05-08 00:35:21 -0700442 return -1;
443 count++;
444 }
445 if (blocks) {
446 last_ext->extLength = EXT_NOT_RECORDED_NOT_ALLOCATED |
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700447 (blocks << sb->s_blocksize_bits);
Jan Kara31170b62007-05-08 00:35:21 -0700448 if (udf_add_aext(inode, last_pos, last_ext->extLocation,
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700449 last_ext->extLength, 1) == -1)
Jan Kara31170b62007-05-08 00:35:21 -0700450 return -1;
451 count++;
452 }
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700453
454out:
Jan Kara31170b62007-05-08 00:35:21 -0700455 /* Do we have some preallocated blocks saved? */
456 if (prealloc_len) {
Marcin Slusarz4b111112008-02-08 04:20:36 -0800457 if (udf_add_aext(inode, last_pos, prealloc_loc,
458 prealloc_len, 1) == -1)
Jan Kara31170b62007-05-08 00:35:21 -0700459 return -1;
460 last_ext->extLocation = prealloc_loc;
461 last_ext->extLength = prealloc_len;
462 count++;
463 }
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700464
Jan Kara31170b62007-05-08 00:35:21 -0700465 /* last_pos should point to the last written extent... */
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800466 if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
Jan Kara31170b62007-05-08 00:35:21 -0700467 last_pos->offset -= sizeof(short_ad);
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800468 else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
Jan Kara31170b62007-05-08 00:35:21 -0700469 last_pos->offset -= sizeof(long_ad);
470 else
471 return -1;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700472
Jan Kara31170b62007-05-08 00:35:21 -0700473 return count;
474}
475
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700476static struct buffer_head *inode_getblk(struct inode *inode, sector_t block,
Marcin Slusarz1ed16172008-02-08 04:20:48 -0800477 int *err, sector_t *phys, int *new)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478{
Jan Kara31170b62007-05-08 00:35:21 -0700479 static sector_t last_block;
Jan Karaff116fc2007-05-08 00:35:14 -0700480 struct buffer_head *result = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481 kernel_long_ad laarr[EXTENT_MERGE_SIZE];
Jan Karaff116fc2007-05-08 00:35:14 -0700482 struct extent_position prev_epos, cur_epos, next_epos;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483 int count = 0, startnum = 0, endnum = 0;
Jan Kara85d71242007-06-01 00:46:29 -0700484 uint32_t elen = 0, tmpelen;
485 kernel_lb_addr eloc, tmpeloc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486 int c = 1;
Jan Kara60448b12007-05-08 00:35:13 -0700487 loff_t lbcount = 0, b_off = 0;
488 uint32_t newblocknum, newblock;
489 sector_t offset = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490 int8_t etype;
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800491 struct udf_inode_info *iinfo = UDF_I(inode);
492 int goal = 0, pgoal = iinfo->i_location.logicalBlockNum;
Jan Kara31170b62007-05-08 00:35:21 -0700493 int lastblock = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494
Jan Karaff116fc2007-05-08 00:35:14 -0700495 prev_epos.offset = udf_file_entry_alloc_offset(inode);
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800496 prev_epos.block = iinfo->i_location;
Jan Karaff116fc2007-05-08 00:35:14 -0700497 prev_epos.bh = NULL;
498 cur_epos = next_epos = prev_epos;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700499 b_off = (loff_t)block << inode->i_sb->s_blocksize_bits;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500
501 /* find the extent which contains the block we are looking for.
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700502 alternate between laarr[0] and laarr[1] for locations of the
503 current extent, and the previous extent */
504 do {
505 if (prev_epos.bh != cur_epos.bh) {
Jan Kara3bf25cb2007-05-08 00:35:16 -0700506 brelse(prev_epos.bh);
507 get_bh(cur_epos.bh);
Jan Karaff116fc2007-05-08 00:35:14 -0700508 prev_epos.bh = cur_epos.bh;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509 }
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700510 if (cur_epos.bh != next_epos.bh) {
Jan Kara3bf25cb2007-05-08 00:35:16 -0700511 brelse(cur_epos.bh);
512 get_bh(next_epos.bh);
Jan Karaff116fc2007-05-08 00:35:14 -0700513 cur_epos.bh = next_epos.bh;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514 }
515
516 lbcount += elen;
517
Jan Karaff116fc2007-05-08 00:35:14 -0700518 prev_epos.block = cur_epos.block;
519 cur_epos.block = next_epos.block;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520
Jan Karaff116fc2007-05-08 00:35:14 -0700521 prev_epos.offset = cur_epos.offset;
522 cur_epos.offset = next_epos.offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523
Marcin Slusarz4b111112008-02-08 04:20:36 -0800524 etype = udf_next_aext(inode, &next_epos, &eloc, &elen, 1);
525 if (etype == -1)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526 break;
527
528 c = !c;
529
530 laarr[c].extLength = (etype << 30) | elen;
531 laarr[c].extLocation = eloc;
532
533 if (etype != (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30))
534 pgoal = eloc.logicalBlockNum +
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700535 ((elen + inode->i_sb->s_blocksize - 1) >>
536 inode->i_sb->s_blocksize_bits);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700538 count++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539 } while (lbcount + elen <= b_off);
540
541 b_off -= lbcount;
542 offset = b_off >> inode->i_sb->s_blocksize_bits;
Jan Kara85d71242007-06-01 00:46:29 -0700543 /*
544 * Move prev_epos and cur_epos into indirect extent if we are at
545 * the pointer to it
546 */
547 udf_next_aext(inode, &prev_epos, &tmpeloc, &tmpelen, 0);
548 udf_next_aext(inode, &cur_epos, &tmpeloc, &tmpelen, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549
550 /* if the extent is allocated and recorded, return the block
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700551 if the extent is not a multiple of the blocksize, round up */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700552
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700553 if (etype == (EXT_RECORDED_ALLOCATED >> 30)) {
554 if (elen & (inode->i_sb->s_blocksize - 1)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555 elen = EXT_RECORDED_ALLOCATED |
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700556 ((elen + inode->i_sb->s_blocksize - 1) &
557 ~(inode->i_sb->s_blocksize - 1));
Jan Karaff116fc2007-05-08 00:35:14 -0700558 etype = udf_write_aext(inode, &cur_epos, eloc, elen, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559 }
Jan Kara3bf25cb2007-05-08 00:35:16 -0700560 brelse(prev_epos.bh);
561 brelse(cur_epos.bh);
562 brelse(next_epos.bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563 newblock = udf_get_lb_pblock(inode->i_sb, eloc, offset);
564 *phys = newblock;
565 return NULL;
566 }
567
Jan Kara31170b62007-05-08 00:35:21 -0700568 last_block = block;
569 /* Are we beyond EOF? */
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700570 if (etype == -1) {
Jan Kara31170b62007-05-08 00:35:21 -0700571 int ret;
572
573 if (count) {
574 if (c)
575 laarr[0] = laarr[1];
576 startnum = 1;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700577 } else {
Jan Kara31170b62007-05-08 00:35:21 -0700578 /* Create a fake extent when there's not one */
Marcin Slusarz4b111112008-02-08 04:20:36 -0800579 memset(&laarr[0].extLocation, 0x00,
580 sizeof(kernel_lb_addr));
Jan Kara31170b62007-05-08 00:35:21 -0700581 laarr[0].extLength = EXT_NOT_RECORDED_NOT_ALLOCATED;
Marcin Slusarz4b111112008-02-08 04:20:36 -0800582 /* Will udf_extend_file() create real extent from
583 a fake one? */
Jan Kara31170b62007-05-08 00:35:21 -0700584 startnum = (offset > 0);
585 }
586 /* Create extents for the hole between EOF and offset */
587 ret = udf_extend_file(inode, &prev_epos, laarr, offset);
588 if (ret == -1) {
589 brelse(prev_epos.bh);
590 brelse(cur_epos.bh);
591 brelse(next_epos.bh);
592 /* We don't really know the error here so we just make
593 * something up */
594 *err = -ENOSPC;
595 return NULL;
596 }
597 c = 0;
598 offset = 0;
599 count += ret;
600 /* We are not covered by a preallocated extent? */
Marcin Slusarz4b111112008-02-08 04:20:36 -0800601 if ((laarr[0].extLength & UDF_EXTENT_FLAG_MASK) !=
602 EXT_NOT_RECORDED_ALLOCATED) {
Jan Kara31170b62007-05-08 00:35:21 -0700603 /* Is there any real extent? - otherwise we overwrite
604 * the fake one... */
605 if (count)
606 c = !c;
607 laarr[c].extLength = EXT_NOT_RECORDED_NOT_ALLOCATED |
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700608 inode->i_sb->s_blocksize;
Marcin Slusarz4b111112008-02-08 04:20:36 -0800609 memset(&laarr[c].extLocation, 0x00,
610 sizeof(kernel_lb_addr));
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700611 count++;
612 endnum++;
Jan Kara31170b62007-05-08 00:35:21 -0700613 }
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700614 endnum = c + 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700615 lastblock = 1;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700616 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617 endnum = startnum = ((count > 2) ? 2 : count);
618
Marcin Slusarz4b111112008-02-08 04:20:36 -0800619 /* if the current extent is in position 0,
620 swap it with the previous */
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700621 if (!c && count != 1) {
Jan Kara31170b62007-05-08 00:35:21 -0700622 laarr[2] = laarr[0];
623 laarr[0] = laarr[1];
624 laarr[1] = laarr[2];
625 c = 1;
626 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627
Marcin Slusarz4b111112008-02-08 04:20:36 -0800628 /* if the current block is located in an extent,
629 read the next extent */
630 etype = udf_next_aext(inode, &next_epos, &eloc, &elen, 0);
631 if (etype != -1) {
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700632 laarr[c + 1].extLength = (etype << 30) | elen;
633 laarr[c + 1].extLocation = eloc;
634 count++;
635 startnum++;
636 endnum++;
Marcin Slusarz4b111112008-02-08 04:20:36 -0800637 } else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638 lastblock = 1;
639 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640
641 /* if the current extent is not recorded but allocated, get the
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700642 * block in the extent corresponding to the requested block */
Marcin Slusarz4b111112008-02-08 04:20:36 -0800643 if ((laarr[c].extLength >> 30) == (EXT_NOT_RECORDED_ALLOCATED >> 30))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700644 newblocknum = laarr[c].extLocation.logicalBlockNum + offset;
Marcin Slusarz4b111112008-02-08 04:20:36 -0800645 else { /* otherwise, allocate a new block */
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800646 if (iinfo->i_next_alloc_block == block)
647 goal = iinfo->i_next_alloc_goal;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700648
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700649 if (!goal) {
Marcin Slusarz4b111112008-02-08 04:20:36 -0800650 if (!(goal = pgoal)) /* XXX: what was intended here? */
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800651 goal = iinfo->i_location.logicalBlockNum + 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652 }
653
Marcin Slusarz4b111112008-02-08 04:20:36 -0800654 newblocknum = udf_new_block(inode->i_sb, inode,
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800655 iinfo->i_location.partitionReferenceNum,
Marcin Slusarz4b111112008-02-08 04:20:36 -0800656 goal, err);
657 if (!newblocknum) {
Jan Kara3bf25cb2007-05-08 00:35:16 -0700658 brelse(prev_epos.bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700659 *err = -ENOSPC;
660 return NULL;
661 }
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800662 iinfo->i_lenExtents += inode->i_sb->s_blocksize;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663 }
664
Marcin Slusarz4b111112008-02-08 04:20:36 -0800665 /* if the extent the requsted block is located in contains multiple
666 * blocks, split the extent into at most three extents. blocks prior
667 * to requested block, requested block, and blocks after requested
668 * block */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669 udf_split_extents(inode, &c, offset, newblocknum, laarr, &endnum);
670
671#ifdef UDF_PREALLOCATE
672 /* preallocate blocks */
673 udf_prealloc_extents(inode, c, lastblock, laarr, &endnum);
674#endif
675
676 /* merge any continuous blocks in laarr */
677 udf_merge_extents(inode, laarr, &endnum);
678
679 /* write back the new extents, inserting new extents if the new number
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700680 * of extents is greater than the old number, and deleting extents if
681 * the new number of extents is less than the old number */
Jan Karaff116fc2007-05-08 00:35:14 -0700682 udf_update_extents(inode, laarr, startnum, endnum, &prev_epos);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683
Jan Kara3bf25cb2007-05-08 00:35:16 -0700684 brelse(prev_epos.bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685
Marcin Slusarz4b111112008-02-08 04:20:36 -0800686 newblock = udf_get_pblock(inode->i_sb, newblocknum,
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800687 iinfo->i_location.partitionReferenceNum, 0);
Marcin Slusarz4b111112008-02-08 04:20:36 -0800688 if (!newblock)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700690 *phys = newblock;
691 *err = 0;
692 *new = 1;
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -0800693 iinfo->i_next_alloc_block = block;
694 iinfo->i_next_alloc_goal = newblocknum;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695 inode->i_ctime = current_fs_time(inode->i_sb);
696
697 if (IS_SYNC(inode))
698 udf_sync_inode(inode);
699 else
700 mark_inode_dirty(inode);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700701
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702 return result;
703}
704
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700705static void udf_split_extents(struct inode *inode, int *c, int offset,
706 int newblocknum,
707 kernel_long_ad laarr[EXTENT_MERGE_SIZE],
708 int *endnum)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709{
Marcin Slusarz4b111112008-02-08 04:20:36 -0800710 unsigned long blocksize = inode->i_sb->s_blocksize;
711 unsigned char blocksize_bits = inode->i_sb->s_blocksize_bits;
712
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713 if ((laarr[*c].extLength >> 30) == (EXT_NOT_RECORDED_ALLOCATED >> 30) ||
Marcin Slusarz4b111112008-02-08 04:20:36 -0800714 (laarr[*c].extLength >> 30) ==
715 (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716 int curr = *c;
717 int blen = ((laarr[curr].extLength & UDF_EXTENT_LENGTH_MASK) +
Marcin Slusarz4b111112008-02-08 04:20:36 -0800718 blocksize - 1) >> blocksize_bits;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719 int8_t etype = (laarr[curr].extLength >> 30);
720
Marcin Slusarz4b111112008-02-08 04:20:36 -0800721 if (blen == 1)
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700722 ;
Marcin Slusarz4b111112008-02-08 04:20:36 -0800723 else if (!offset || blen == offset + 1) {
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700724 laarr[curr + 2] = laarr[curr + 1];
725 laarr[curr + 1] = laarr[curr];
726 } else {
727 laarr[curr + 3] = laarr[curr + 1];
728 laarr[curr + 2] = laarr[curr + 1] = laarr[curr];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700729 }
730
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700731 if (offset) {
732 if (etype == (EXT_NOT_RECORDED_ALLOCATED >> 30)) {
Marcin Slusarz4b111112008-02-08 04:20:36 -0800733 udf_free_blocks(inode->i_sb, inode,
734 laarr[curr].extLocation,
735 0, offset);
736 laarr[curr].extLength =
737 EXT_NOT_RECORDED_NOT_ALLOCATED |
738 (offset << blocksize_bits);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739 laarr[curr].extLocation.logicalBlockNum = 0;
Marcin Slusarz4b111112008-02-08 04:20:36 -0800740 laarr[curr].extLocation.
741 partitionReferenceNum = 0;
742 } else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743 laarr[curr].extLength = (etype << 30) |
Marcin Slusarz4b111112008-02-08 04:20:36 -0800744 (offset << blocksize_bits);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700745 curr++;
746 (*c)++;
747 (*endnum)++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748 }
Cyrill Gorcunov647bd612007-07-15 23:39:47 -0700749
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750 laarr[curr].extLocation.logicalBlockNum = newblocknum;
751 if (etype == (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30))
752 laarr[curr].extLocation.partitionReferenceNum =
Marcin Slusarzc0b34432008-02-08 04:20:42 -0800753 UDF_I(inode)->i_location.partitionReferenceNum;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754 laarr[curr].extLength = EXT_RECORDED_ALLOCATED |
Marcin Slusarz4b111112008-02-08 04:20:36 -0800755 blocksize;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700756 curr++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700757
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700758 if (blen != offset + 1) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759 if (etype == (EXT_NOT_RECORDED_ALLOCATED >> 30))
Marcin Slusarz4b111112008-02-08 04:20:36 -0800760 laarr[curr].extLocation.logicalBlockNum +=
761 offset + 1;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700762 laarr[curr].extLength = (etype << 30) |
Marcin Slusarz4b111112008-02-08 04:20:36 -0800763 ((blen - (offset + 1)) << blocksize_bits);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700764 curr++;
765 (*endnum)++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766 }
767 }
768}
769
770static void udf_prealloc_extents(struct inode *inode, int c, int lastblock,
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700771 kernel_long_ad laarr[EXTENT_MERGE_SIZE],
772 int *endnum)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700773{
774 int start, length = 0, currlength = 0, i;
775
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700776 if (*endnum >= (c + 1)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700777 if (!lastblock)
778 return;
779 else
780 start = c;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700781 } else {
Marcin Slusarz4b111112008-02-08 04:20:36 -0800782 if ((laarr[c + 1].extLength >> 30) ==
783 (EXT_NOT_RECORDED_ALLOCATED >> 30)) {
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700784 start = c + 1;
Marcin Slusarz4b111112008-02-08 04:20:36 -0800785 length = currlength =
786 (((laarr[c + 1].extLength &
787 UDF_EXTENT_LENGTH_MASK) +
788 inode->i_sb->s_blocksize - 1) >>
789 inode->i_sb->s_blocksize_bits);
790 } else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700791 start = c;
792 }
793
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700794 for (i = start + 1; i <= *endnum; i++) {
795 if (i == *endnum) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700796 if (lastblock)
797 length += UDF_DEFAULT_PREALLOC_BLOCKS;
Marcin Slusarz4b111112008-02-08 04:20:36 -0800798 } else if ((laarr[i].extLength >> 30) ==
799 (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30)) {
800 length += (((laarr[i].extLength &
801 UDF_EXTENT_LENGTH_MASK) +
802 inode->i_sb->s_blocksize - 1) >>
803 inode->i_sb->s_blocksize_bits);
804 } else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700805 break;
806 }
807
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700808 if (length) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700809 int next = laarr[start].extLocation.logicalBlockNum +
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700810 (((laarr[start].extLength & UDF_EXTENT_LENGTH_MASK) +
Marcin Slusarz4b111112008-02-08 04:20:36 -0800811 inode->i_sb->s_blocksize - 1) >>
812 inode->i_sb->s_blocksize_bits);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813 int numalloc = udf_prealloc_blocks(inode->i_sb, inode,
Marcin Slusarz4b111112008-02-08 04:20:36 -0800814 laarr[start].extLocation.partitionReferenceNum,
815 next, (UDF_DEFAULT_PREALLOC_BLOCKS > length ?
816 length : UDF_DEFAULT_PREALLOC_BLOCKS) -
817 currlength);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700818 if (numalloc) {
Marcin Slusarz4b111112008-02-08 04:20:36 -0800819 if (start == (c + 1))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700820 laarr[start].extLength +=
Marcin Slusarz4b111112008-02-08 04:20:36 -0800821 (numalloc <<
822 inode->i_sb->s_blocksize_bits);
823 else {
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700824 memmove(&laarr[c + 2], &laarr[c + 1],
825 sizeof(long_ad) * (*endnum - (c + 1)));
826 (*endnum)++;
827 laarr[c + 1].extLocation.logicalBlockNum = next;
828 laarr[c + 1].extLocation.partitionReferenceNum =
Marcin Slusarz4b111112008-02-08 04:20:36 -0800829 laarr[c].extLocation.
830 partitionReferenceNum;
831 laarr[c + 1].extLength =
832 EXT_NOT_RECORDED_ALLOCATED |
833 (numalloc <<
834 inode->i_sb->s_blocksize_bits);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700835 start = c + 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700836 }
837
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700838 for (i = start + 1; numalloc && i < *endnum; i++) {
Marcin Slusarz4b111112008-02-08 04:20:36 -0800839 int elen = ((laarr[i].extLength &
840 UDF_EXTENT_LENGTH_MASK) +
841 inode->i_sb->s_blocksize - 1) >>
842 inode->i_sb->s_blocksize_bits;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700844 if (elen > numalloc) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700845 laarr[i].extLength -=
Marcin Slusarz4b111112008-02-08 04:20:36 -0800846 (numalloc <<
847 inode->i_sb->s_blocksize_bits);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848 numalloc = 0;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700849 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850 numalloc -= elen;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700851 if (*endnum > (i + 1))
Marcin Slusarz4b111112008-02-08 04:20:36 -0800852 memmove(&laarr[i],
853 &laarr[i + 1],
854 sizeof(long_ad) *
855 (*endnum - (i + 1)));
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700856 i--;
857 (*endnum)--;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700858 }
859 }
Marcin Slusarzc0b34432008-02-08 04:20:42 -0800860 UDF_I(inode)->i_lenExtents +=
Marcin Slusarz4b111112008-02-08 04:20:36 -0800861 numalloc << inode->i_sb->s_blocksize_bits;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700862 }
863 }
864}
865
866static void udf_merge_extents(struct inode *inode,
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700867 kernel_long_ad laarr[EXTENT_MERGE_SIZE],
868 int *endnum)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869{
870 int i;
Marcin Slusarz4b111112008-02-08 04:20:36 -0800871 unsigned long blocksize = inode->i_sb->s_blocksize;
872 unsigned char blocksize_bits = inode->i_sb->s_blocksize_bits;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700873
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700874 for (i = 0; i < (*endnum - 1); i++) {
Marcin Slusarz4b111112008-02-08 04:20:36 -0800875 kernel_long_ad *li /*l[i]*/ = &laarr[i];
876 kernel_long_ad *lip1 /*l[i plus 1]*/ = &laarr[i + 1];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700877
Marcin Slusarz4b111112008-02-08 04:20:36 -0800878 if (((li->extLength >> 30) == (lip1->extLength >> 30)) &&
879 (((li->extLength >> 30) ==
880 (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30)) ||
881 ((lip1->extLocation.logicalBlockNum -
882 li->extLocation.logicalBlockNum) ==
883 (((li->extLength & UDF_EXTENT_LENGTH_MASK) +
884 blocksize - 1) >> blocksize_bits)))) {
885
886 if (((li->extLength & UDF_EXTENT_LENGTH_MASK) +
887 (lip1->extLength & UDF_EXTENT_LENGTH_MASK) +
888 blocksize - 1) & ~UDF_EXTENT_LENGTH_MASK) {
889 lip1->extLength = (lip1->extLength -
890 (li->extLength &
891 UDF_EXTENT_LENGTH_MASK) +
892 UDF_EXTENT_LENGTH_MASK) &
893 ~(blocksize - 1);
894 li->extLength = (li->extLength &
895 UDF_EXTENT_FLAG_MASK) +
896 (UDF_EXTENT_LENGTH_MASK + 1) -
897 blocksize;
898 lip1->extLocation.logicalBlockNum =
899 li->extLocation.logicalBlockNum +
900 ((li->extLength &
901 UDF_EXTENT_LENGTH_MASK) >>
902 blocksize_bits);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700903 } else {
Marcin Slusarz4b111112008-02-08 04:20:36 -0800904 li->extLength = lip1->extLength +
905 (((li->extLength &
906 UDF_EXTENT_LENGTH_MASK) +
907 blocksize - 1) & ~(blocksize - 1));
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700908 if (*endnum > (i + 2))
909 memmove(&laarr[i + 1], &laarr[i + 2],
Marcin Slusarz4b111112008-02-08 04:20:36 -0800910 sizeof(long_ad) *
911 (*endnum - (i + 2)));
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700912 i--;
913 (*endnum)--;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700914 }
Marcin Slusarz4b111112008-02-08 04:20:36 -0800915 } else if (((li->extLength >> 30) ==
916 (EXT_NOT_RECORDED_ALLOCATED >> 30)) &&
917 ((lip1->extLength >> 30) ==
918 (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30))) {
919 udf_free_blocks(inode->i_sb, inode, li->extLocation, 0,
920 ((li->extLength &
921 UDF_EXTENT_LENGTH_MASK) +
922 blocksize - 1) >> blocksize_bits);
923 li->extLocation.logicalBlockNum = 0;
924 li->extLocation.partitionReferenceNum = 0;
925
926 if (((li->extLength & UDF_EXTENT_LENGTH_MASK) +
927 (lip1->extLength & UDF_EXTENT_LENGTH_MASK) +
928 blocksize - 1) & ~UDF_EXTENT_LENGTH_MASK) {
929 lip1->extLength = (lip1->extLength -
930 (li->extLength &
931 UDF_EXTENT_LENGTH_MASK) +
932 UDF_EXTENT_LENGTH_MASK) &
933 ~(blocksize - 1);
934 li->extLength = (li->extLength &
935 UDF_EXTENT_FLAG_MASK) +
936 (UDF_EXTENT_LENGTH_MASK + 1) -
937 blocksize;
938 } else {
939 li->extLength = lip1->extLength +
940 (((li->extLength &
941 UDF_EXTENT_LENGTH_MASK) +
942 blocksize - 1) & ~(blocksize - 1));
943 if (*endnum > (i + 2))
944 memmove(&laarr[i + 1], &laarr[i + 2],
945 sizeof(long_ad) *
946 (*endnum - (i + 2)));
947 i--;
948 (*endnum)--;
949 }
950 } else if ((li->extLength >> 30) ==
951 (EXT_NOT_RECORDED_ALLOCATED >> 30)) {
952 udf_free_blocks(inode->i_sb, inode,
953 li->extLocation, 0,
954 ((li->extLength &
955 UDF_EXTENT_LENGTH_MASK) +
956 blocksize - 1) >> blocksize_bits);
957 li->extLocation.logicalBlockNum = 0;
958 li->extLocation.partitionReferenceNum = 0;
959 li->extLength = (li->extLength &
960 UDF_EXTENT_LENGTH_MASK) |
961 EXT_NOT_RECORDED_NOT_ALLOCATED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700962 }
963 }
964}
965
966static void udf_update_extents(struct inode *inode,
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700967 kernel_long_ad laarr[EXTENT_MERGE_SIZE],
968 int startnum, int endnum,
969 struct extent_position *epos)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700970{
971 int start = 0, i;
972 kernel_lb_addr tmploc;
973 uint32_t tmplen;
974
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700975 if (startnum > endnum) {
976 for (i = 0; i < (startnum - endnum); i++)
Jan Karaff116fc2007-05-08 00:35:14 -0700977 udf_delete_aext(inode, *epos, laarr[i].extLocation,
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700978 laarr[i].extLength);
979 } else if (startnum < endnum) {
980 for (i = 0; i < (endnum - startnum); i++) {
Jan Karaff116fc2007-05-08 00:35:14 -0700981 udf_insert_aext(inode, *epos, laarr[i].extLocation,
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700982 laarr[i].extLength);
Jan Karaff116fc2007-05-08 00:35:14 -0700983 udf_next_aext(inode, epos, &laarr[i].extLocation,
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700984 &laarr[i].extLength, 1);
985 start++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700986 }
987 }
988
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700989 for (i = start; i < endnum; i++) {
Jan Karaff116fc2007-05-08 00:35:14 -0700990 udf_next_aext(inode, epos, &tmploc, &tmplen, 0);
991 udf_write_aext(inode, epos, laarr[i].extLocation,
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700992 laarr[i].extLength, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700993 }
994}
995
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700996struct buffer_head *udf_bread(struct inode *inode, int block,
997 int create, int *err)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700998{
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700999 struct buffer_head *bh = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001000
1001 bh = udf_getblk(inode, block, create, err);
1002 if (!bh)
1003 return NULL;
1004
1005 if (buffer_uptodate(bh))
1006 return bh;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001007
Linus Torvalds1da177e2005-04-16 15:20:36 -07001008 ll_rw_block(READ, 1, &bh);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001009
Linus Torvalds1da177e2005-04-16 15:20:36 -07001010 wait_on_buffer(bh);
1011 if (buffer_uptodate(bh))
1012 return bh;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001013
Linus Torvalds1da177e2005-04-16 15:20:36 -07001014 brelse(bh);
1015 *err = -EIO;
1016 return NULL;
1017}
1018
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001019void udf_truncate(struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001020{
1021 int offset;
1022 int err;
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001023 struct udf_inode_info *iinfo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001024
1025 if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001026 S_ISLNK(inode->i_mode)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001027 return;
1028 if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
1029 return;
1030
1031 lock_kernel();
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001032 iinfo = UDF_I(inode);
1033 if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {
Marcin Slusarz4b111112008-02-08 04:20:36 -08001034 if (inode->i_sb->s_blocksize <
1035 (udf_file_entry_alloc_offset(inode) +
1036 inode->i_size)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001037 udf_expand_file_adinicb(inode, inode->i_size, &err);
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001038 if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {
1039 inode->i_size = iinfo->i_lenAlloc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001040 unlock_kernel();
1041 return;
Marcin Slusarz4b111112008-02-08 04:20:36 -08001042 } else
Linus Torvalds1da177e2005-04-16 15:20:36 -07001043 udf_truncate_extents(inode);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001044 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001045 offset = inode->i_size & (inode->i_sb->s_blocksize - 1);
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001046 memset(iinfo->i_ext.i_data + iinfo->i_lenEAttr + offset,
Marcin Slusarzc0b34432008-02-08 04:20:42 -08001047 0x00, inode->i_sb->s_blocksize -
Marcin Slusarz4b111112008-02-08 04:20:36 -08001048 offset - udf_file_entry_alloc_offset(inode));
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001049 iinfo->i_lenAlloc = inode->i_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001050 }
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001051 } else {
Marcin Slusarz4b111112008-02-08 04:20:36 -08001052 block_truncate_page(inode->i_mapping, inode->i_size,
1053 udf_get_block);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001054 udf_truncate_extents(inode);
Cyrill Gorcunov647bd612007-07-15 23:39:47 -07001055 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001056
1057 inode->i_mtime = inode->i_ctime = current_fs_time(inode->i_sb);
1058 if (IS_SYNC(inode))
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001059 udf_sync_inode(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001060 else
1061 mark_inode_dirty(inode);
1062 unlock_kernel();
1063}
1064
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001065static void __udf_read_inode(struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001066{
1067 struct buffer_head *bh = NULL;
1068 struct fileEntry *fe;
1069 uint16_t ident;
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001070 struct udf_inode_info *iinfo = UDF_I(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001071
1072 /*
1073 * Set defaults, but the inode is still incomplete!
1074 * Note: get_new_inode() sets the following on a new inode:
1075 * i_sb = sb
1076 * i_no = ino
1077 * i_flags = sb->s_flags
1078 * i_state = 0
1079 * clean_inode(): zero fills and sets
1080 * i_count = 1
1081 * i_nlink = 1
1082 * i_op = NULL;
1083 */
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001084 bh = udf_read_ptagged(inode->i_sb, iinfo->i_location, 0, &ident);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001085 if (!bh) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001086 printk(KERN_ERR "udf: udf_read_inode(ino %ld) failed !bh\n",
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001087 inode->i_ino);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001088 make_bad_inode(inode);
1089 return;
1090 }
1091
1092 if (ident != TAG_IDENT_FE && ident != TAG_IDENT_EFE &&
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001093 ident != TAG_IDENT_USE) {
Marcin Slusarz4b111112008-02-08 04:20:36 -08001094 printk(KERN_ERR "udf: udf_read_inode(ino %ld) "
1095 "failed ident=%d\n", inode->i_ino, ident);
Jan Kara3bf25cb2007-05-08 00:35:16 -07001096 brelse(bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001097 make_bad_inode(inode);
1098 return;
1099 }
1100
1101 fe = (struct fileEntry *)bh->b_data;
1102
Marcin Slusarz5e0f0012008-02-08 04:20:41 -08001103 if (fe->icbTag.strategyType == cpu_to_le16(4096)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001104 struct buffer_head *ibh = NULL, *nbh = NULL;
1105 struct indirectEntry *ie;
1106
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001107 ibh = udf_read_ptagged(inode->i_sb, iinfo->i_location, 1,
Marcin Slusarz4b111112008-02-08 04:20:36 -08001108 &ident);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001109 if (ident == TAG_IDENT_IE) {
1110 if (ibh) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001111 kernel_lb_addr loc;
1112 ie = (struct indirectEntry *)ibh->b_data;
Cyrill Gorcunov647bd612007-07-15 23:39:47 -07001113
Linus Torvalds1da177e2005-04-16 15:20:36 -07001114 loc = lelb_to_cpu(ie->indirectICB.extLocation);
Cyrill Gorcunov647bd612007-07-15 23:39:47 -07001115
1116 if (ie->indirectICB.extLength &&
Marcin Slusarz4b111112008-02-08 04:20:36 -08001117 (nbh = udf_read_ptagged(inode->i_sb, loc, 0,
1118 &ident))) {
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001119 if (ident == TAG_IDENT_FE ||
1120 ident == TAG_IDENT_EFE) {
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001121 memcpy(&iinfo->i_location,
Marcin Slusarz4b111112008-02-08 04:20:36 -08001122 &loc,
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001123 sizeof(kernel_lb_addr));
Jan Kara3bf25cb2007-05-08 00:35:16 -07001124 brelse(bh);
1125 brelse(ibh);
1126 brelse(nbh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001127 __udf_read_inode(inode);
1128 return;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001129 } else {
Jan Kara3bf25cb2007-05-08 00:35:16 -07001130 brelse(nbh);
1131 brelse(ibh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001132 }
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001133 } else {
Jan Kara3bf25cb2007-05-08 00:35:16 -07001134 brelse(ibh);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001135 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001136 }
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001137 } else {
Jan Kara3bf25cb2007-05-08 00:35:16 -07001138 brelse(ibh);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001139 }
Marcin Slusarz5e0f0012008-02-08 04:20:41 -08001140 } else if (fe->icbTag.strategyType != cpu_to_le16(4)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001141 printk(KERN_ERR "udf: unsupported strategy type: %d\n",
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001142 le16_to_cpu(fe->icbTag.strategyType));
Jan Kara3bf25cb2007-05-08 00:35:16 -07001143 brelse(bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001144 make_bad_inode(inode);
1145 return;
1146 }
1147 udf_fill_inode(inode, bh);
Jan Kara31170b62007-05-08 00:35:21 -07001148
Jan Kara3bf25cb2007-05-08 00:35:16 -07001149 brelse(bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001150}
1151
1152static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
1153{
1154 struct fileEntry *fe;
1155 struct extendedFileEntry *efe;
1156 time_t convtime;
1157 long convtime_usec;
1158 int offset;
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001159 struct udf_sb_info *sbi = UDF_SB(inode->i_sb);
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001160 struct udf_inode_info *iinfo = UDF_I(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001161
1162 fe = (struct fileEntry *)bh->b_data;
1163 efe = (struct extendedFileEntry *)bh->b_data;
1164
Marcin Slusarz5e0f0012008-02-08 04:20:41 -08001165 if (fe->icbTag.strategyType == cpu_to_le16(4))
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001166 iinfo->i_strat4096 = 0;
Marcin Slusarz5e0f0012008-02-08 04:20:41 -08001167 else /* if (fe->icbTag.strategyType == cpu_to_le16(4096)) */
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001168 iinfo->i_strat4096 = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001169
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001170 iinfo->i_alloc_type = le16_to_cpu(fe->icbTag.flags) &
Marcin Slusarz4b111112008-02-08 04:20:36 -08001171 ICBTAG_FLAG_AD_MASK;
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001172 iinfo->i_unique = 0;
1173 iinfo->i_lenEAttr = 0;
1174 iinfo->i_lenExtents = 0;
1175 iinfo->i_lenAlloc = 0;
1176 iinfo->i_next_alloc_block = 0;
1177 iinfo->i_next_alloc_goal = 0;
Marcin Slusarz5e0f0012008-02-08 04:20:41 -08001178 if (fe->descTag.tagIdent == cpu_to_le16(TAG_IDENT_EFE)) {
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001179 iinfo->i_efe = 1;
1180 iinfo->i_use = 0;
Marcin Slusarz4b111112008-02-08 04:20:36 -08001181 if (udf_alloc_i_data(inode, inode->i_sb->s_blocksize -
1182 sizeof(struct extendedFileEntry))) {
Cyrill Gorcunov647bd612007-07-15 23:39:47 -07001183 make_bad_inode(inode);
1184 return;
1185 }
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001186 memcpy(iinfo->i_ext.i_data,
Marcin Slusarz4b111112008-02-08 04:20:36 -08001187 bh->b_data + sizeof(struct extendedFileEntry),
1188 inode->i_sb->s_blocksize -
1189 sizeof(struct extendedFileEntry));
Marcin Slusarz5e0f0012008-02-08 04:20:41 -08001190 } else if (fe->descTag.tagIdent == cpu_to_le16(TAG_IDENT_FE)) {
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001191 iinfo->i_efe = 0;
1192 iinfo->i_use = 0;
Marcin Slusarz4b111112008-02-08 04:20:36 -08001193 if (udf_alloc_i_data(inode, inode->i_sb->s_blocksize -
1194 sizeof(struct fileEntry))) {
Cyrill Gorcunov647bd612007-07-15 23:39:47 -07001195 make_bad_inode(inode);
1196 return;
1197 }
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001198 memcpy(iinfo->i_ext.i_data,
Marcin Slusarzc0b34432008-02-08 04:20:42 -08001199 bh->b_data + sizeof(struct fileEntry),
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001200 inode->i_sb->s_blocksize - sizeof(struct fileEntry));
Marcin Slusarz5e0f0012008-02-08 04:20:41 -08001201 } else if (fe->descTag.tagIdent == cpu_to_le16(TAG_IDENT_USE)) {
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001202 iinfo->i_efe = 0;
1203 iinfo->i_use = 1;
1204 iinfo->i_lenAlloc = le32_to_cpu(
Marcin Slusarz4b111112008-02-08 04:20:36 -08001205 ((struct unallocSpaceEntry *)bh->b_data)->
1206 lengthAllocDescs);
1207 if (udf_alloc_i_data(inode, inode->i_sb->s_blocksize -
1208 sizeof(struct unallocSpaceEntry))) {
Cyrill Gorcunov647bd612007-07-15 23:39:47 -07001209 make_bad_inode(inode);
1210 return;
1211 }
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001212 memcpy(iinfo->i_ext.i_data,
Marcin Slusarz4b111112008-02-08 04:20:36 -08001213 bh->b_data + sizeof(struct unallocSpaceEntry),
1214 inode->i_sb->s_blocksize -
1215 sizeof(struct unallocSpaceEntry));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001216 return;
1217 }
1218
1219 inode->i_uid = le32_to_cpu(fe->uid);
Cyrill Gorcunovca76d2d2007-07-31 00:39:40 -07001220 if (inode->i_uid == -1 ||
1221 UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_UID_IGNORE) ||
1222 UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_UID_SET))
Phillip Susi4d6660e2006-03-07 21:55:24 -08001223 inode->i_uid = UDF_SB(inode->i_sb)->s_uid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001224
1225 inode->i_gid = le32_to_cpu(fe->gid);
Cyrill Gorcunovca76d2d2007-07-31 00:39:40 -07001226 if (inode->i_gid == -1 ||
1227 UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_GID_IGNORE) ||
1228 UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_GID_SET))
Phillip Susi4d6660e2006-03-07 21:55:24 -08001229 inode->i_gid = UDF_SB(inode->i_sb)->s_gid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001230
1231 inode->i_nlink = le16_to_cpu(fe->fileLinkCount);
1232 if (!inode->i_nlink)
1233 inode->i_nlink = 1;
Cyrill Gorcunov647bd612007-07-15 23:39:47 -07001234
Linus Torvalds1da177e2005-04-16 15:20:36 -07001235 inode->i_size = le64_to_cpu(fe->informationLength);
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001236 iinfo->i_lenExtents = inode->i_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001237
1238 inode->i_mode = udf_convert_permissions(fe);
1239 inode->i_mode &= ~UDF_SB(inode->i_sb)->s_umask;
1240
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001241 if (iinfo->i_efe == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001242 inode->i_blocks = le64_to_cpu(fe->logicalBlocksRecorded) <<
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001243 (inode->i_sb->s_blocksize_bits - 9);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001244
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001245 if (udf_stamp_to_time(&convtime, &convtime_usec,
1246 lets_to_cpu(fe->accessTime))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001247 inode->i_atime.tv_sec = convtime;
1248 inode->i_atime.tv_nsec = convtime_usec * 1000;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001249 } else {
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001250 inode->i_atime = sbi->s_record_time;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001251 }
1252
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001253 if (udf_stamp_to_time(&convtime, &convtime_usec,
1254 lets_to_cpu(fe->modificationTime))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001255 inode->i_mtime.tv_sec = convtime;
1256 inode->i_mtime.tv_nsec = convtime_usec * 1000;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001257 } else {
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001258 inode->i_mtime = sbi->s_record_time;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001259 }
1260
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001261 if (udf_stamp_to_time(&convtime, &convtime_usec,
1262 lets_to_cpu(fe->attrTime))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001263 inode->i_ctime.tv_sec = convtime;
1264 inode->i_ctime.tv_nsec = convtime_usec * 1000;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001265 } else {
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001266 inode->i_ctime = sbi->s_record_time;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001267 }
1268
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001269 iinfo->i_unique = le64_to_cpu(fe->uniqueID);
1270 iinfo->i_lenEAttr = le32_to_cpu(fe->lengthExtendedAttr);
1271 iinfo->i_lenAlloc = le32_to_cpu(fe->lengthAllocDescs);
1272 offset = sizeof(struct fileEntry) + iinfo->i_lenEAttr;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001273 } else {
Cyrill Gorcunov647bd612007-07-15 23:39:47 -07001274 inode->i_blocks = le64_to_cpu(efe->logicalBlocksRecorded) <<
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001275 (inode->i_sb->s_blocksize_bits - 9);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001276
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001277 if (udf_stamp_to_time(&convtime, &convtime_usec,
1278 lets_to_cpu(efe->accessTime))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001279 inode->i_atime.tv_sec = convtime;
1280 inode->i_atime.tv_nsec = convtime_usec * 1000;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001281 } else {
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001282 inode->i_atime = sbi->s_record_time;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001283 }
1284
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001285 if (udf_stamp_to_time(&convtime, &convtime_usec,
1286 lets_to_cpu(efe->modificationTime))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001287 inode->i_mtime.tv_sec = convtime;
1288 inode->i_mtime.tv_nsec = convtime_usec * 1000;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001289 } else {
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001290 inode->i_mtime = sbi->s_record_time;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001291 }
1292
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001293 if (udf_stamp_to_time(&convtime, &convtime_usec,
1294 lets_to_cpu(efe->createTime))) {
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001295 iinfo->i_crtime.tv_sec = convtime;
1296 iinfo->i_crtime.tv_nsec = convtime_usec * 1000;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001297 } else {
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001298 iinfo->i_crtime = sbi->s_record_time;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001299 }
1300
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001301 if (udf_stamp_to_time(&convtime, &convtime_usec,
1302 lets_to_cpu(efe->attrTime))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001303 inode->i_ctime.tv_sec = convtime;
1304 inode->i_ctime.tv_nsec = convtime_usec * 1000;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001305 } else {
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001306 inode->i_ctime = sbi->s_record_time;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001307 }
1308
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001309 iinfo->i_unique = le64_to_cpu(efe->uniqueID);
1310 iinfo->i_lenEAttr = le32_to_cpu(efe->lengthExtendedAttr);
1311 iinfo->i_lenAlloc = le32_to_cpu(efe->lengthAllocDescs);
Marcin Slusarz4b111112008-02-08 04:20:36 -08001312 offset = sizeof(struct extendedFileEntry) +
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001313 iinfo->i_lenEAttr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001314 }
1315
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001316 switch (fe->icbTag.fileType) {
1317 case ICBTAG_FILE_TYPE_DIRECTORY:
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001318 inode->i_op = &udf_dir_inode_operations;
1319 inode->i_fop = &udf_dir_operations;
1320 inode->i_mode |= S_IFDIR;
1321 inc_nlink(inode);
1322 break;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001323 case ICBTAG_FILE_TYPE_REALTIME:
1324 case ICBTAG_FILE_TYPE_REGULAR:
1325 case ICBTAG_FILE_TYPE_UNDEF:
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001326 if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001327 inode->i_data.a_ops = &udf_adinicb_aops;
1328 else
1329 inode->i_data.a_ops = &udf_aops;
1330 inode->i_op = &udf_file_inode_operations;
1331 inode->i_fop = &udf_file_operations;
1332 inode->i_mode |= S_IFREG;
1333 break;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001334 case ICBTAG_FILE_TYPE_BLOCK:
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001335 inode->i_mode |= S_IFBLK;
1336 break;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001337 case ICBTAG_FILE_TYPE_CHAR:
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001338 inode->i_mode |= S_IFCHR;
1339 break;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001340 case ICBTAG_FILE_TYPE_FIFO:
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001341 init_special_inode(inode, inode->i_mode | S_IFIFO, 0);
1342 break;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001343 case ICBTAG_FILE_TYPE_SOCKET:
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001344 init_special_inode(inode, inode->i_mode | S_IFSOCK, 0);
1345 break;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001346 case ICBTAG_FILE_TYPE_SYMLINK:
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001347 inode->i_data.a_ops = &udf_symlink_aops;
1348 inode->i_op = &page_symlink_inode_operations;
1349 inode->i_mode = S_IFLNK | S_IRWXUGO;
1350 break;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001351 default:
Marcin Slusarz4b111112008-02-08 04:20:36 -08001352 printk(KERN_ERR "udf: udf_fill_inode(ino %ld) failed unknown "
1353 "file type=%d\n", inode->i_ino,
1354 fe->icbTag.fileType);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001355 make_bad_inode(inode);
1356 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001357 }
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001358 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) {
Marcin Slusarz4b111112008-02-08 04:20:36 -08001359 struct deviceSpec *dsea =
1360 (struct deviceSpec *)udf_get_extendedattr(inode, 12, 1);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001361 if (dsea) {
1362 init_special_inode(inode, inode->i_mode,
Marcin Slusarz4b111112008-02-08 04:20:36 -08001363 MKDEV(le32_to_cpu(dsea->majorDeviceIdent),
1364 le32_to_cpu(dsea->minorDeviceIdent)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001365 /* Developer ID ??? */
Marcin Slusarz4b111112008-02-08 04:20:36 -08001366 } else
Linus Torvalds1da177e2005-04-16 15:20:36 -07001367 make_bad_inode(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001368 }
1369}
1370
Cyrill Gorcunov647bd612007-07-15 23:39:47 -07001371static int udf_alloc_i_data(struct inode *inode, size_t size)
1372{
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001373 struct udf_inode_info *iinfo = UDF_I(inode);
1374 iinfo->i_ext.i_data = kmalloc(size, GFP_KERNEL);
Cyrill Gorcunov647bd612007-07-15 23:39:47 -07001375
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001376 if (!iinfo->i_ext.i_data) {
Marcin Slusarz4b111112008-02-08 04:20:36 -08001377 printk(KERN_ERR "udf:udf_alloc_i_data (ino %ld) "
1378 "no free memory\n", inode->i_ino);
Cyrill Gorcunov647bd612007-07-15 23:39:47 -07001379 return -ENOMEM;
1380 }
1381
1382 return 0;
1383}
1384
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001385static mode_t udf_convert_permissions(struct fileEntry *fe)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001386{
1387 mode_t mode;
1388 uint32_t permissions;
1389 uint32_t flags;
1390
1391 permissions = le32_to_cpu(fe->permissions);
1392 flags = le16_to_cpu(fe->icbTag.flags);
1393
Marcin Slusarz4b111112008-02-08 04:20:36 -08001394 mode = ((permissions) & S_IRWXO) |
1395 ((permissions >> 2) & S_IRWXG) |
1396 ((permissions >> 4) & S_IRWXU) |
1397 ((flags & ICBTAG_FLAG_SETUID) ? S_ISUID : 0) |
1398 ((flags & ICBTAG_FLAG_SETGID) ? S_ISGID : 0) |
1399 ((flags & ICBTAG_FLAG_STICKY) ? S_ISVTX : 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001400
1401 return mode;
1402}
1403
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001404int udf_write_inode(struct inode *inode, int sync)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001405{
1406 int ret;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001407
Linus Torvalds1da177e2005-04-16 15:20:36 -07001408 lock_kernel();
1409 ret = udf_update_inode(inode, sync);
1410 unlock_kernel();
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001411
Linus Torvalds1da177e2005-04-16 15:20:36 -07001412 return ret;
1413}
1414
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001415int udf_sync_inode(struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001416{
1417 return udf_update_inode(inode, 1);
1418}
1419
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001420static int udf_update_inode(struct inode *inode, int do_sync)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001421{
1422 struct buffer_head *bh = NULL;
1423 struct fileEntry *fe;
1424 struct extendedFileEntry *efe;
1425 uint32_t udfperms;
1426 uint16_t icbflags;
1427 uint16_t crclen;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001428 kernel_timestamp cpu_time;
1429 int err = 0;
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001430 struct udf_sb_info *sbi = UDF_SB(inode->i_sb);
Marcin Slusarz4b111112008-02-08 04:20:36 -08001431 unsigned char blocksize_bits = inode->i_sb->s_blocksize_bits;
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001432 struct udf_inode_info *iinfo = UDF_I(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001433
Marcin Slusarz4b111112008-02-08 04:20:36 -08001434 bh = udf_tread(inode->i_sb,
1435 udf_get_lb_pblock(inode->i_sb,
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001436 iinfo->i_location, 0));
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001437 if (!bh) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001438 udf_debug("bread failure\n");
1439 return -EIO;
1440 }
1441
1442 memset(bh->b_data, 0x00, inode->i_sb->s_blocksize);
1443
1444 fe = (struct fileEntry *)bh->b_data;
1445 efe = (struct extendedFileEntry *)bh->b_data;
1446
Marcin Slusarz5e0f0012008-02-08 04:20:41 -08001447 if (fe->descTag.tagIdent == cpu_to_le16(TAG_IDENT_USE)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001448 struct unallocSpaceEntry *use =
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001449 (struct unallocSpaceEntry *)bh->b_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001450
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001451 use->lengthAllocDescs = cpu_to_le32(iinfo->i_lenAlloc);
Marcin Slusarz4b111112008-02-08 04:20:36 -08001452 memcpy(bh->b_data + sizeof(struct unallocSpaceEntry),
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001453 iinfo->i_ext.i_data, inode->i_sb->s_blocksize -
Marcin Slusarz4b111112008-02-08 04:20:36 -08001454 sizeof(struct unallocSpaceEntry));
1455 crclen = sizeof(struct unallocSpaceEntry) +
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001456 iinfo->i_lenAlloc - sizeof(tag);
Marcin Slusarz4b111112008-02-08 04:20:36 -08001457 use->descTag.tagLocation = cpu_to_le32(
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001458 iinfo->i_location.
Marcin Slusarz4b111112008-02-08 04:20:36 -08001459 logicalBlockNum);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001460 use->descTag.descCRCLength = cpu_to_le16(crclen);
Marcin Slusarz4b111112008-02-08 04:20:36 -08001461 use->descTag.descCRC = cpu_to_le16(udf_crc((char *)use +
1462 sizeof(tag), crclen,
1463 0));
Marcin Slusarz3f2587b2008-02-08 04:20:39 -08001464 use->descTag.tagChecksum = udf_tag_checksum(&use->descTag);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001465
1466 mark_buffer_dirty(bh);
Jan Kara3bf25cb2007-05-08 00:35:16 -07001467 brelse(bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001468 return err;
1469 }
1470
Phillip Susi4d6660e2006-03-07 21:55:24 -08001471 if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_UID_FORGET))
1472 fe->uid = cpu_to_le32(-1);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001473 else
1474 fe->uid = cpu_to_le32(inode->i_uid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001475
Phillip Susi4d6660e2006-03-07 21:55:24 -08001476 if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_GID_FORGET))
1477 fe->gid = cpu_to_le32(-1);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001478 else
1479 fe->gid = cpu_to_le32(inode->i_gid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001480
Marcin Slusarz4b111112008-02-08 04:20:36 -08001481 udfperms = ((inode->i_mode & S_IRWXO)) |
1482 ((inode->i_mode & S_IRWXG) << 2) |
1483 ((inode->i_mode & S_IRWXU) << 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001484
Marcin Slusarz4b111112008-02-08 04:20:36 -08001485 udfperms |= (le32_to_cpu(fe->permissions) &
1486 (FE_PERM_O_DELETE | FE_PERM_O_CHATTR |
1487 FE_PERM_G_DELETE | FE_PERM_G_CHATTR |
1488 FE_PERM_U_DELETE | FE_PERM_U_CHATTR));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001489 fe->permissions = cpu_to_le32(udfperms);
1490
1491 if (S_ISDIR(inode->i_mode))
1492 fe->fileLinkCount = cpu_to_le16(inode->i_nlink - 1);
1493 else
1494 fe->fileLinkCount = cpu_to_le16(inode->i_nlink);
1495
1496 fe->informationLength = cpu_to_le64(inode->i_size);
1497
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001498 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001499 regid *eid;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001500 struct deviceSpec *dsea =
1501 (struct deviceSpec *)udf_get_extendedattr(inode, 12, 1);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001502 if (!dsea) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001503 dsea = (struct deviceSpec *)
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001504 udf_add_extendedattr(inode,
1505 sizeof(struct deviceSpec) +
1506 sizeof(regid), 12, 0x3);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001507 dsea->attrType = cpu_to_le32(12);
1508 dsea->attrSubtype = 1;
Marcin Slusarz4b111112008-02-08 04:20:36 -08001509 dsea->attrLength = cpu_to_le32(
1510 sizeof(struct deviceSpec) +
1511 sizeof(regid));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001512 dsea->impUseLength = cpu_to_le32(sizeof(regid));
1513 }
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001514 eid = (regid *)dsea->impUse;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001515 memset(eid, 0, sizeof(regid));
1516 strcpy(eid->ident, UDF_ID_DEVELOPER);
1517 eid->identSuffix[0] = UDF_OS_CLASS_UNIX;
1518 eid->identSuffix[1] = UDF_OS_ID_LINUX;
1519 dsea->majorDeviceIdent = cpu_to_le32(imajor(inode));
1520 dsea->minorDeviceIdent = cpu_to_le32(iminor(inode));
1521 }
1522
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001523 if (iinfo->i_efe == 0) {
Marcin Slusarzc0b34432008-02-08 04:20:42 -08001524 memcpy(bh->b_data + sizeof(struct fileEntry),
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001525 iinfo->i_ext.i_data,
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001526 inode->i_sb->s_blocksize - sizeof(struct fileEntry));
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001527 fe->logicalBlocksRecorded = cpu_to_le64(
Marcin Slusarz4b111112008-02-08 04:20:36 -08001528 (inode->i_blocks + (1 << (blocksize_bits - 9)) - 1) >>
1529 (blocksize_bits - 9));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001530
1531 if (udf_time_to_stamp(&cpu_time, inode->i_atime))
1532 fe->accessTime = cpu_to_lets(cpu_time);
1533 if (udf_time_to_stamp(&cpu_time, inode->i_mtime))
1534 fe->modificationTime = cpu_to_lets(cpu_time);
1535 if (udf_time_to_stamp(&cpu_time, inode->i_ctime))
1536 fe->attrTime = cpu_to_lets(cpu_time);
1537 memset(&(fe->impIdent), 0, sizeof(regid));
1538 strcpy(fe->impIdent.ident, UDF_ID_DEVELOPER);
1539 fe->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX;
1540 fe->impIdent.identSuffix[1] = UDF_OS_ID_LINUX;
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001541 fe->uniqueID = cpu_to_le64(iinfo->i_unique);
1542 fe->lengthExtendedAttr = cpu_to_le32(iinfo->i_lenEAttr);
1543 fe->lengthAllocDescs = cpu_to_le32(iinfo->i_lenAlloc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001544 fe->descTag.tagIdent = cpu_to_le16(TAG_IDENT_FE);
1545 crclen = sizeof(struct fileEntry);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001546 } else {
Marcin Slusarz4b111112008-02-08 04:20:36 -08001547 memcpy(bh->b_data + sizeof(struct extendedFileEntry),
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001548 iinfo->i_ext.i_data,
Marcin Slusarz4b111112008-02-08 04:20:36 -08001549 inode->i_sb->s_blocksize -
1550 sizeof(struct extendedFileEntry));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001551 efe->objectSize = cpu_to_le64(inode->i_size);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001552 efe->logicalBlocksRecorded = cpu_to_le64(
Marcin Slusarz4b111112008-02-08 04:20:36 -08001553 (inode->i_blocks + (1 << (blocksize_bits - 9)) - 1) >>
1554 (blocksize_bits - 9));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001555
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001556 if (iinfo->i_crtime.tv_sec > inode->i_atime.tv_sec ||
1557 (iinfo->i_crtime.tv_sec == inode->i_atime.tv_sec &&
1558 iinfo->i_crtime.tv_nsec > inode->i_atime.tv_nsec))
1559 iinfo->i_crtime = inode->i_atime;
Marcin Slusarz4b111112008-02-08 04:20:36 -08001560
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001561 if (iinfo->i_crtime.tv_sec > inode->i_mtime.tv_sec ||
1562 (iinfo->i_crtime.tv_sec == inode->i_mtime.tv_sec &&
1563 iinfo->i_crtime.tv_nsec > inode->i_mtime.tv_nsec))
1564 iinfo->i_crtime = inode->i_mtime;
Marcin Slusarz4b111112008-02-08 04:20:36 -08001565
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001566 if (iinfo->i_crtime.tv_sec > inode->i_ctime.tv_sec ||
1567 (iinfo->i_crtime.tv_sec == inode->i_ctime.tv_sec &&
1568 iinfo->i_crtime.tv_nsec > inode->i_ctime.tv_nsec))
1569 iinfo->i_crtime = inode->i_ctime;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001570
1571 if (udf_time_to_stamp(&cpu_time, inode->i_atime))
1572 efe->accessTime = cpu_to_lets(cpu_time);
1573 if (udf_time_to_stamp(&cpu_time, inode->i_mtime))
1574 efe->modificationTime = cpu_to_lets(cpu_time);
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001575 if (udf_time_to_stamp(&cpu_time, iinfo->i_crtime))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001576 efe->createTime = cpu_to_lets(cpu_time);
1577 if (udf_time_to_stamp(&cpu_time, inode->i_ctime))
1578 efe->attrTime = cpu_to_lets(cpu_time);
1579
1580 memset(&(efe->impIdent), 0, sizeof(regid));
1581 strcpy(efe->impIdent.ident, UDF_ID_DEVELOPER);
1582 efe->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX;
1583 efe->impIdent.identSuffix[1] = UDF_OS_ID_LINUX;
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001584 efe->uniqueID = cpu_to_le64(iinfo->i_unique);
1585 efe->lengthExtendedAttr = cpu_to_le32(iinfo->i_lenEAttr);
1586 efe->lengthAllocDescs = cpu_to_le32(iinfo->i_lenAlloc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001587 efe->descTag.tagIdent = cpu_to_le16(TAG_IDENT_EFE);
1588 crclen = sizeof(struct extendedFileEntry);
1589 }
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001590 if (iinfo->i_strat4096) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001591 fe->icbTag.strategyType = cpu_to_le16(4096);
1592 fe->icbTag.strategyParameter = cpu_to_le16(1);
1593 fe->icbTag.numEntries = cpu_to_le16(2);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001594 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001595 fe->icbTag.strategyType = cpu_to_le16(4);
1596 fe->icbTag.numEntries = cpu_to_le16(1);
1597 }
1598
1599 if (S_ISDIR(inode->i_mode))
1600 fe->icbTag.fileType = ICBTAG_FILE_TYPE_DIRECTORY;
1601 else if (S_ISREG(inode->i_mode))
1602 fe->icbTag.fileType = ICBTAG_FILE_TYPE_REGULAR;
1603 else if (S_ISLNK(inode->i_mode))
1604 fe->icbTag.fileType = ICBTAG_FILE_TYPE_SYMLINK;
1605 else if (S_ISBLK(inode->i_mode))
1606 fe->icbTag.fileType = ICBTAG_FILE_TYPE_BLOCK;
1607 else if (S_ISCHR(inode->i_mode))
1608 fe->icbTag.fileType = ICBTAG_FILE_TYPE_CHAR;
1609 else if (S_ISFIFO(inode->i_mode))
1610 fe->icbTag.fileType = ICBTAG_FILE_TYPE_FIFO;
1611 else if (S_ISSOCK(inode->i_mode))
1612 fe->icbTag.fileType = ICBTAG_FILE_TYPE_SOCKET;
1613
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001614 icbflags = iinfo->i_alloc_type |
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001615 ((inode->i_mode & S_ISUID) ? ICBTAG_FLAG_SETUID : 0) |
1616 ((inode->i_mode & S_ISGID) ? ICBTAG_FLAG_SETGID : 0) |
1617 ((inode->i_mode & S_ISVTX) ? ICBTAG_FLAG_STICKY : 0) |
1618 (le16_to_cpu(fe->icbTag.flags) &
1619 ~(ICBTAG_FLAG_AD_MASK | ICBTAG_FLAG_SETUID |
1620 ICBTAG_FLAG_SETGID | ICBTAG_FLAG_STICKY));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001621
1622 fe->icbTag.flags = cpu_to_le16(icbflags);
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001623 if (sbi->s_udfrev >= 0x0200)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001624 fe->descTag.descVersion = cpu_to_le16(3);
1625 else
1626 fe->descTag.descVersion = cpu_to_le16(2);
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001627 fe->descTag.tagSerialNum = cpu_to_le16(sbi->s_serial_number);
Marcin Slusarz4b111112008-02-08 04:20:36 -08001628 fe->descTag.tagLocation = cpu_to_le32(
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001629 iinfo->i_location.logicalBlockNum);
1630 crclen += iinfo->i_lenEAttr + iinfo->i_lenAlloc -
Marcin Slusarzc0b34432008-02-08 04:20:42 -08001631 sizeof(tag);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001632 fe->descTag.descCRCLength = cpu_to_le16(crclen);
Marcin Slusarz4b111112008-02-08 04:20:36 -08001633 fe->descTag.descCRC = cpu_to_le16(udf_crc((char *)fe + sizeof(tag),
1634 crclen, 0));
Marcin Slusarz3f2587b2008-02-08 04:20:39 -08001635 fe->descTag.tagChecksum = udf_tag_checksum(&fe->descTag);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001636
1637 /* write the data blocks */
1638 mark_buffer_dirty(bh);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001639 if (do_sync) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001640 sync_dirty_buffer(bh);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001641 if (buffer_req(bh) && !buffer_uptodate(bh)) {
Marcin Slusarz4b111112008-02-08 04:20:36 -08001642 printk(KERN_WARNING "IO error syncing udf inode "
1643 "[%s:%08lx]\n", inode->i_sb->s_id,
1644 inode->i_ino);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001645 err = -EIO;
1646 }
1647 }
Jan Kara3bf25cb2007-05-08 00:35:16 -07001648 brelse(bh);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001649
Linus Torvalds1da177e2005-04-16 15:20:36 -07001650 return err;
1651}
1652
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001653struct inode *udf_iget(struct super_block *sb, kernel_lb_addr ino)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001654{
1655 unsigned long block = udf_get_lb_pblock(sb, ino, 0);
1656 struct inode *inode = iget_locked(sb, block);
1657
1658 if (!inode)
1659 return NULL;
1660
1661 if (inode->i_state & I_NEW) {
Marcin Slusarzc0b34432008-02-08 04:20:42 -08001662 memcpy(&UDF_I(inode)->i_location, &ino, sizeof(kernel_lb_addr));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001663 __udf_read_inode(inode);
1664 unlock_new_inode(inode);
1665 }
1666
1667 if (is_bad_inode(inode))
1668 goto out_iput;
1669
Marcin Slusarz4b111112008-02-08 04:20:36 -08001670 if (ino.logicalBlockNum >= UDF_SB(sb)->
1671 s_partmaps[ino.partitionReferenceNum].s_partition_len) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001672 udf_debug("block=%d, partition=%d out of range\n",
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001673 ino.logicalBlockNum, ino.partitionReferenceNum);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001674 make_bad_inode(inode);
1675 goto out_iput;
1676 }
1677
1678 return inode;
1679
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001680 out_iput:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001681 iput(inode);
1682 return NULL;
1683}
1684
Marcin Slusarz4b111112008-02-08 04:20:36 -08001685int8_t udf_add_aext(struct inode *inode, struct extent_position *epos,
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001686 kernel_lb_addr eloc, uint32_t elen, int inc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001687{
1688 int adsize;
1689 short_ad *sad = NULL;
1690 long_ad *lad = NULL;
1691 struct allocExtDesc *aed;
1692 int8_t etype;
1693 uint8_t *ptr;
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001694 struct udf_inode_info *iinfo = UDF_I(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001695
Jan Karaff116fc2007-05-08 00:35:14 -07001696 if (!epos->bh)
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001697 ptr = iinfo->i_ext.i_data + epos->offset -
Marcin Slusarz4b111112008-02-08 04:20:36 -08001698 udf_file_entry_alloc_offset(inode) +
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001699 iinfo->i_lenEAttr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001700 else
Jan Karaff116fc2007-05-08 00:35:14 -07001701 ptr = epos->bh->b_data + epos->offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001702
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001703 if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001704 adsize = sizeof(short_ad);
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001705 else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001706 adsize = sizeof(long_ad);
1707 else
1708 return -1;
1709
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001710 if (epos->offset + (2 * adsize) > inode->i_sb->s_blocksize) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001711 char *sptr, *dptr;
1712 struct buffer_head *nbh;
1713 int err, loffset;
Jan Karaff116fc2007-05-08 00:35:14 -07001714 kernel_lb_addr obloc = epos->block;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001715
Marcin Slusarz4b111112008-02-08 04:20:36 -08001716 epos->block.logicalBlockNum = udf_new_block(inode->i_sb, NULL,
1717 obloc.partitionReferenceNum,
1718 obloc.logicalBlockNum, &err);
1719 if (!epos->block.logicalBlockNum)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001720 return -1;
Marcin Slusarz4b111112008-02-08 04:20:36 -08001721 nbh = udf_tgetblk(inode->i_sb, udf_get_lb_pblock(inode->i_sb,
1722 epos->block,
1723 0));
1724 if (!nbh)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001725 return -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001726 lock_buffer(nbh);
1727 memset(nbh->b_data, 0x00, inode->i_sb->s_blocksize);
1728 set_buffer_uptodate(nbh);
1729 unlock_buffer(nbh);
1730 mark_buffer_dirty_inode(nbh, inode);
1731
1732 aed = (struct allocExtDesc *)(nbh->b_data);
1733 if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT))
Marcin Slusarz4b111112008-02-08 04:20:36 -08001734 aed->previousAllocExtLocation =
1735 cpu_to_le32(obloc.logicalBlockNum);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001736 if (epos->offset + adsize > inode->i_sb->s_blocksize) {
Jan Karaff116fc2007-05-08 00:35:14 -07001737 loffset = epos->offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001738 aed->lengthAllocDescs = cpu_to_le32(adsize);
1739 sptr = ptr - adsize;
1740 dptr = nbh->b_data + sizeof(struct allocExtDesc);
1741 memcpy(dptr, sptr, adsize);
Jan Karaff116fc2007-05-08 00:35:14 -07001742 epos->offset = sizeof(struct allocExtDesc) + adsize;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001743 } else {
Jan Karaff116fc2007-05-08 00:35:14 -07001744 loffset = epos->offset + adsize;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001745 aed->lengthAllocDescs = cpu_to_le32(0);
1746 sptr = ptr;
Jan Karaff116fc2007-05-08 00:35:14 -07001747 epos->offset = sizeof(struct allocExtDesc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001748
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001749 if (epos->bh) {
Jan Karaff116fc2007-05-08 00:35:14 -07001750 aed = (struct allocExtDesc *)epos->bh->b_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001751 aed->lengthAllocDescs =
Marcin Slusarz4b111112008-02-08 04:20:36 -08001752 cpu_to_le32(le32_to_cpu(
1753 aed->lengthAllocDescs) + adsize);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001754 } else {
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001755 iinfo->i_lenAlloc += adsize;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001756 mark_inode_dirty(inode);
1757 }
1758 }
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001759 if (UDF_SB(inode->i_sb)->s_udfrev >= 0x0200)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001760 udf_new_tag(nbh->b_data, TAG_IDENT_AED, 3, 1,
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001761 epos->block.logicalBlockNum, sizeof(tag));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001762 else
1763 udf_new_tag(nbh->b_data, TAG_IDENT_AED, 2, 1,
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001764 epos->block.logicalBlockNum, sizeof(tag));
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001765 switch (iinfo->i_alloc_type) {
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001766 case ICBTAG_FLAG_AD_SHORT:
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001767 sad = (short_ad *)sptr;
1768 sad->extLength = cpu_to_le32(EXT_NEXT_EXTENT_ALLOCDECS |
1769 inode->i_sb->s_blocksize);
Marcin Slusarz4b111112008-02-08 04:20:36 -08001770 sad->extPosition =
1771 cpu_to_le32(epos->block.logicalBlockNum);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001772 break;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001773 case ICBTAG_FLAG_AD_LONG:
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001774 lad = (long_ad *)sptr;
1775 lad->extLength = cpu_to_le32(EXT_NEXT_EXTENT_ALLOCDECS |
1776 inode->i_sb->s_blocksize);
1777 lad->extLocation = cpu_to_lelb(epos->block);
1778 memset(lad->impUse, 0x00, sizeof(lad->impUse));
1779 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001780 }
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001781 if (epos->bh) {
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001782 if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) ||
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001783 UDF_SB(inode->i_sb)->s_udfrev >= 0x0201)
Jan Karaff116fc2007-05-08 00:35:14 -07001784 udf_update_tag(epos->bh->b_data, loffset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001785 else
Marcin Slusarz4b111112008-02-08 04:20:36 -08001786 udf_update_tag(epos->bh->b_data,
1787 sizeof(struct allocExtDesc));
Jan Karaff116fc2007-05-08 00:35:14 -07001788 mark_buffer_dirty_inode(epos->bh, inode);
Jan Kara3bf25cb2007-05-08 00:35:16 -07001789 brelse(epos->bh);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001790 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001791 mark_inode_dirty(inode);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001792 }
Jan Karaff116fc2007-05-08 00:35:14 -07001793 epos->bh = nbh;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001794 }
1795
Jan Karaff116fc2007-05-08 00:35:14 -07001796 etype = udf_write_aext(inode, epos, eloc, elen, inc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001797
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001798 if (!epos->bh) {
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001799 iinfo->i_lenAlloc += adsize;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001800 mark_inode_dirty(inode);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001801 } else {
Jan Karaff116fc2007-05-08 00:35:14 -07001802 aed = (struct allocExtDesc *)epos->bh->b_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001803 aed->lengthAllocDescs =
Marcin Slusarz4b111112008-02-08 04:20:36 -08001804 cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) +
1805 adsize);
1806 if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) ||
1807 UDF_SB(inode->i_sb)->s_udfrev >= 0x0201)
1808 udf_update_tag(epos->bh->b_data,
1809 epos->offset + (inc ? 0 : adsize));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001810 else
Marcin Slusarz4b111112008-02-08 04:20:36 -08001811 udf_update_tag(epos->bh->b_data,
1812 sizeof(struct allocExtDesc));
Jan Karaff116fc2007-05-08 00:35:14 -07001813 mark_buffer_dirty_inode(epos->bh, inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001814 }
1815
1816 return etype;
1817}
1818
Marcin Slusarz4b111112008-02-08 04:20:36 -08001819int8_t udf_write_aext(struct inode *inode, struct extent_position *epos,
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001820 kernel_lb_addr eloc, uint32_t elen, int inc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001821{
1822 int adsize;
1823 uint8_t *ptr;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001824 short_ad *sad;
1825 long_ad *lad;
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001826 struct udf_inode_info *iinfo = UDF_I(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001827
Jan Karaff116fc2007-05-08 00:35:14 -07001828 if (!epos->bh)
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001829 ptr = iinfo->i_ext.i_data + epos->offset -
Marcin Slusarz4b111112008-02-08 04:20:36 -08001830 udf_file_entry_alloc_offset(inode) +
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001831 iinfo->i_lenEAttr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001832 else
Jan Karaff116fc2007-05-08 00:35:14 -07001833 ptr = epos->bh->b_data + epos->offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001834
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001835 switch (iinfo->i_alloc_type) {
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001836 case ICBTAG_FLAG_AD_SHORT:
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001837 sad = (short_ad *)ptr;
1838 sad->extLength = cpu_to_le32(elen);
1839 sad->extPosition = cpu_to_le32(eloc.logicalBlockNum);
1840 adsize = sizeof(short_ad);
1841 break;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001842 case ICBTAG_FLAG_AD_LONG:
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001843 lad = (long_ad *)ptr;
1844 lad->extLength = cpu_to_le32(elen);
1845 lad->extLocation = cpu_to_lelb(eloc);
1846 memset(lad->impUse, 0x00, sizeof(lad->impUse));
1847 adsize = sizeof(long_ad);
1848 break;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001849 default:
1850 return -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001851 }
1852
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001853 if (epos->bh) {
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001854 if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) ||
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001855 UDF_SB(inode->i_sb)->s_udfrev >= 0x0201) {
Marcin Slusarz4b111112008-02-08 04:20:36 -08001856 struct allocExtDesc *aed =
1857 (struct allocExtDesc *)epos->bh->b_data;
Jan Karaff116fc2007-05-08 00:35:14 -07001858 udf_update_tag(epos->bh->b_data,
Marcin Slusarz4b111112008-02-08 04:20:36 -08001859 le32_to_cpu(aed->lengthAllocDescs) +
1860 sizeof(struct allocExtDesc));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001861 }
Jan Karaff116fc2007-05-08 00:35:14 -07001862 mark_buffer_dirty_inode(epos->bh, inode);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001863 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001864 mark_inode_dirty(inode);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001865 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001866
1867 if (inc)
Jan Karaff116fc2007-05-08 00:35:14 -07001868 epos->offset += adsize;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001869
Linus Torvalds1da177e2005-04-16 15:20:36 -07001870 return (elen >> 30);
1871}
1872
Marcin Slusarz4b111112008-02-08 04:20:36 -08001873int8_t udf_next_aext(struct inode *inode, struct extent_position *epos,
1874 kernel_lb_addr *eloc, uint32_t *elen, int inc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001875{
1876 int8_t etype;
1877
Jan Karaff116fc2007-05-08 00:35:14 -07001878 while ((etype = udf_current_aext(inode, epos, eloc, elen, inc)) ==
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001879 (EXT_NEXT_EXTENT_ALLOCDECS >> 30)) {
Marcin Slusarz4b111112008-02-08 04:20:36 -08001880 int block;
Jan Karaff116fc2007-05-08 00:35:14 -07001881 epos->block = *eloc;
1882 epos->offset = sizeof(struct allocExtDesc);
Jan Kara3bf25cb2007-05-08 00:35:16 -07001883 brelse(epos->bh);
Marcin Slusarz4b111112008-02-08 04:20:36 -08001884 block = udf_get_lb_pblock(inode->i_sb, epos->block, 0);
1885 epos->bh = udf_tread(inode->i_sb, block);
1886 if (!epos->bh) {
1887 udf_debug("reading block %d failed!\n", block);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001888 return -1;
1889 }
1890 }
1891
1892 return etype;
1893}
1894
Marcin Slusarz4b111112008-02-08 04:20:36 -08001895int8_t udf_current_aext(struct inode *inode, struct extent_position *epos,
1896 kernel_lb_addr *eloc, uint32_t *elen, int inc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001897{
1898 int alen;
1899 int8_t etype;
1900 uint8_t *ptr;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001901 short_ad *sad;
1902 long_ad *lad;
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001903 struct udf_inode_info *iinfo = UDF_I(inode);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001904
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001905 if (!epos->bh) {
Jan Karaff116fc2007-05-08 00:35:14 -07001906 if (!epos->offset)
1907 epos->offset = udf_file_entry_alloc_offset(inode);
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001908 ptr = iinfo->i_ext.i_data + epos->offset -
Marcin Slusarz4b111112008-02-08 04:20:36 -08001909 udf_file_entry_alloc_offset(inode) +
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001910 iinfo->i_lenEAttr;
Marcin Slusarz4b111112008-02-08 04:20:36 -08001911 alen = udf_file_entry_alloc_offset(inode) +
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001912 iinfo->i_lenAlloc;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001913 } else {
Jan Karaff116fc2007-05-08 00:35:14 -07001914 if (!epos->offset)
1915 epos->offset = sizeof(struct allocExtDesc);
1916 ptr = epos->bh->b_data + epos->offset;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001917 alen = sizeof(struct allocExtDesc) +
Marcin Slusarz4b111112008-02-08 04:20:36 -08001918 le32_to_cpu(((struct allocExtDesc *)epos->bh->b_data)->
1919 lengthAllocDescs);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001920 }
1921
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001922 switch (iinfo->i_alloc_type) {
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001923 case ICBTAG_FLAG_AD_SHORT:
Marcin Slusarz4b111112008-02-08 04:20:36 -08001924 sad = udf_get_fileshortad(ptr, alen, &epos->offset, inc);
1925 if (!sad)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001926 return -1;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001927 etype = le32_to_cpu(sad->extLength) >> 30;
1928 eloc->logicalBlockNum = le32_to_cpu(sad->extPosition);
Marcin Slusarz4b111112008-02-08 04:20:36 -08001929 eloc->partitionReferenceNum =
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001930 iinfo->i_location.partitionReferenceNum;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001931 *elen = le32_to_cpu(sad->extLength) & UDF_EXTENT_LENGTH_MASK;
1932 break;
1933 case ICBTAG_FLAG_AD_LONG:
Marcin Slusarz4b111112008-02-08 04:20:36 -08001934 lad = udf_get_filelongad(ptr, alen, &epos->offset, inc);
1935 if (!lad)
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001936 return -1;
1937 etype = le32_to_cpu(lad->extLength) >> 30;
1938 *eloc = lelb_to_cpu(lad->extLocation);
1939 *elen = le32_to_cpu(lad->extLength) & UDF_EXTENT_LENGTH_MASK;
1940 break;
1941 default:
Marcin Slusarz4b111112008-02-08 04:20:36 -08001942 udf_debug("alloc_type = %d unsupported\n",
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001943 iinfo->i_alloc_type);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001944 return -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001945 }
1946
1947 return etype;
1948}
1949
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001950static int8_t udf_insert_aext(struct inode *inode, struct extent_position epos,
1951 kernel_lb_addr neloc, uint32_t nelen)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001952{
1953 kernel_lb_addr oeloc;
1954 uint32_t oelen;
1955 int8_t etype;
1956
Jan Karaff116fc2007-05-08 00:35:14 -07001957 if (epos.bh)
Jan Kara3bf25cb2007-05-08 00:35:16 -07001958 get_bh(epos.bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001959
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001960 while ((etype = udf_next_aext(inode, &epos, &oeloc, &oelen, 0)) != -1) {
Jan Karaff116fc2007-05-08 00:35:14 -07001961 udf_write_aext(inode, &epos, neloc, nelen, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001962 neloc = oeloc;
1963 nelen = (etype << 30) | oelen;
1964 }
Jan Karaff116fc2007-05-08 00:35:14 -07001965 udf_add_aext(inode, &epos, neloc, nelen, 1);
Jan Kara3bf25cb2007-05-08 00:35:16 -07001966 brelse(epos.bh);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001967
Linus Torvalds1da177e2005-04-16 15:20:36 -07001968 return (nelen >> 30);
1969}
1970
Marcin Slusarz4b111112008-02-08 04:20:36 -08001971int8_t udf_delete_aext(struct inode *inode, struct extent_position epos,
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001972 kernel_lb_addr eloc, uint32_t elen)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001973{
Jan Karaff116fc2007-05-08 00:35:14 -07001974 struct extent_position oepos;
1975 int adsize;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001976 int8_t etype;
1977 struct allocExtDesc *aed;
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001978 struct udf_inode_info *iinfo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001979
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001980 if (epos.bh) {
Jan Kara3bf25cb2007-05-08 00:35:16 -07001981 get_bh(epos.bh);
1982 get_bh(epos.bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001983 }
1984
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001985 iinfo = UDF_I(inode);
1986 if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001987 adsize = sizeof(short_ad);
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08001988 else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001989 adsize = sizeof(long_ad);
1990 else
1991 adsize = 0;
1992
Jan Karaff116fc2007-05-08 00:35:14 -07001993 oepos = epos;
1994 if (udf_next_aext(inode, &epos, &eloc, &elen, 1) == -1)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001995 return -1;
1996
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001997 while ((etype = udf_next_aext(inode, &epos, &eloc, &elen, 1)) != -1) {
Jan Karaff116fc2007-05-08 00:35:14 -07001998 udf_write_aext(inode, &oepos, eloc, (etype << 30) | elen, 1);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001999 if (oepos.bh != epos.bh) {
Jan Karaff116fc2007-05-08 00:35:14 -07002000 oepos.block = epos.block;
Jan Kara3bf25cb2007-05-08 00:35:16 -07002001 brelse(oepos.bh);
2002 get_bh(epos.bh);
Jan Karaff116fc2007-05-08 00:35:14 -07002003 oepos.bh = epos.bh;
2004 oepos.offset = epos.offset - adsize;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002005 }
2006 }
2007 memset(&eloc, 0x00, sizeof(kernel_lb_addr));
2008 elen = 0;
2009
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07002010 if (epos.bh != oepos.bh) {
Jan Karaff116fc2007-05-08 00:35:14 -07002011 udf_free_blocks(inode->i_sb, inode, epos.block, 0, 1);
2012 udf_write_aext(inode, &oepos, eloc, elen, 1);
2013 udf_write_aext(inode, &oepos, eloc, elen, 1);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07002014 if (!oepos.bh) {
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08002015 iinfo->i_lenAlloc -= (adsize * 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002016 mark_inode_dirty(inode);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07002017 } else {
Jan Karaff116fc2007-05-08 00:35:14 -07002018 aed = (struct allocExtDesc *)oepos.bh->b_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002019 aed->lengthAllocDescs =
Marcin Slusarz4b111112008-02-08 04:20:36 -08002020 cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) -
2021 (2 * adsize));
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07002022 if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) ||
Marcin Slusarz6c79e982008-02-08 04:20:30 -08002023 UDF_SB(inode->i_sb)->s_udfrev >= 0x0201)
Marcin Slusarz4b111112008-02-08 04:20:36 -08002024 udf_update_tag(oepos.bh->b_data,
2025 oepos.offset - (2 * adsize));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002026 else
Marcin Slusarz4b111112008-02-08 04:20:36 -08002027 udf_update_tag(oepos.bh->b_data,
2028 sizeof(struct allocExtDesc));
Jan Karaff116fc2007-05-08 00:35:14 -07002029 mark_buffer_dirty_inode(oepos.bh, inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002030 }
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07002031 } else {
Jan Karaff116fc2007-05-08 00:35:14 -07002032 udf_write_aext(inode, &oepos, eloc, elen, 1);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07002033 if (!oepos.bh) {
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08002034 iinfo->i_lenAlloc -= adsize;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002035 mark_inode_dirty(inode);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07002036 } else {
Jan Karaff116fc2007-05-08 00:35:14 -07002037 aed = (struct allocExtDesc *)oepos.bh->b_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002038 aed->lengthAllocDescs =
Marcin Slusarz4b111112008-02-08 04:20:36 -08002039 cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) -
2040 adsize);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07002041 if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) ||
Marcin Slusarz6c79e982008-02-08 04:20:30 -08002042 UDF_SB(inode->i_sb)->s_udfrev >= 0x0201)
Marcin Slusarz4b111112008-02-08 04:20:36 -08002043 udf_update_tag(oepos.bh->b_data,
2044 epos.offset - adsize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002045 else
Marcin Slusarz4b111112008-02-08 04:20:36 -08002046 udf_update_tag(oepos.bh->b_data,
2047 sizeof(struct allocExtDesc));
Jan Karaff116fc2007-05-08 00:35:14 -07002048 mark_buffer_dirty_inode(oepos.bh, inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002049 }
2050 }
Cyrill Gorcunov647bd612007-07-15 23:39:47 -07002051
Jan Kara3bf25cb2007-05-08 00:35:16 -07002052 brelse(epos.bh);
2053 brelse(oepos.bh);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07002054
Linus Torvalds1da177e2005-04-16 15:20:36 -07002055 return (elen >> 30);
2056}
2057
Marcin Slusarz4b111112008-02-08 04:20:36 -08002058int8_t inode_bmap(struct inode *inode, sector_t block,
2059 struct extent_position *pos, kernel_lb_addr *eloc,
2060 uint32_t *elen, sector_t *offset)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002061{
Marcin Slusarz4b111112008-02-08 04:20:36 -08002062 unsigned char blocksize_bits = inode->i_sb->s_blocksize_bits;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07002063 loff_t lbcount = 0, bcount =
Marcin Slusarz4b111112008-02-08 04:20:36 -08002064 (loff_t) block << blocksize_bits;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002065 int8_t etype;
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08002066 struct udf_inode_info *iinfo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002067
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07002068 if (block < 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002069 printk(KERN_ERR "udf: inode_bmap: block < 0\n");
2070 return -1;
2071 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002072
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08002073 iinfo = UDF_I(inode);
Jan Karaff116fc2007-05-08 00:35:14 -07002074 pos->offset = 0;
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08002075 pos->block = iinfo->i_location;
Jan Karaff116fc2007-05-08 00:35:14 -07002076 pos->bh = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002077 *elen = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002078
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07002079 do {
Marcin Slusarz4b111112008-02-08 04:20:36 -08002080 etype = udf_next_aext(inode, pos, eloc, elen, 1);
2081 if (etype == -1) {
2082 *offset = (bcount - lbcount) >> blocksize_bits;
Marcin Slusarz48d6d8f2008-02-08 04:20:44 -08002083 iinfo->i_lenExtents = lbcount;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002084 return -1;
2085 }
2086 lbcount += *elen;
2087 } while (lbcount <= bcount);
2088
Marcin Slusarz4b111112008-02-08 04:20:36 -08002089 *offset = (bcount + *elen - lbcount) >> blocksize_bits;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002090
2091 return etype;
2092}
2093
Jan Kara60448b12007-05-08 00:35:13 -07002094long udf_block_map(struct inode *inode, sector_t block)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002095{
Jan Karaff116fc2007-05-08 00:35:14 -07002096 kernel_lb_addr eloc;
2097 uint32_t elen;
Jan Kara60448b12007-05-08 00:35:13 -07002098 sector_t offset;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07002099 struct extent_position epos = {};
Linus Torvalds1da177e2005-04-16 15:20:36 -07002100 int ret;
2101
2102 lock_kernel();
2103
Marcin Slusarz4b111112008-02-08 04:20:36 -08002104 if (inode_bmap(inode, block, &epos, &eloc, &elen, &offset) ==
2105 (EXT_RECORDED_ALLOCATED >> 30))
Jan Kara60448b12007-05-08 00:35:13 -07002106 ret = udf_get_lb_pblock(inode->i_sb, eloc, offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002107 else
2108 ret = 0;
2109
2110 unlock_kernel();
Jan Kara3bf25cb2007-05-08 00:35:16 -07002111 brelse(epos.bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002112
2113 if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_VARCONV))
2114 return udf_fixed_to_variable(ret);
2115 else
2116 return ret;
2117}