?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
sysfs: reimplement symlink using sysfs_dirent tree
[linux-2.6/mini2440.git] / fs / udf / inode.c
blobbf7de0bdbab3b6554cbf7ba3eb20dc8ad92a7183
1 /*
2 * inode.c
3 *
4 * PURPOSE
5 * Inode handling routines for the OSTA-UDF(tm) filesystem.
6 *
7 * 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
22 * 12/06/98 blf partition support in udf_iget, udf_block_map and udf_read_inode
23 * 12/12/98 rewrote udf_block_map to handle next extents and descs across
24 * block boundaries (which is not actually allowed)
25 * 12/20/98 added support for strategy 4096
26 * 03/07/99 rewrote udf_block_map (again)
27 * New funcs, inode_bmap, udf_next_aext
28 * 04/19/99 Support for writing device EA's for major/minor #
29 */
30
31 #include "udfdecl.h"
32 #include <linux/mm.h>
33 #include <linux/smp_lock.h>
34 #include <linux/module.h>
35 #include <linux/pagemap.h>
36 #include <linux/buffer_head.h>
37 #include <linux/writeback.h>
38 #include <linux/slab.h>
39
40 #include "udf_i.h"
41 #include "udf_sb.h"
42
43 MODULE_AUTHOR("Ben Fennema");
44 MODULE_DESCRIPTION("Universal Disk Format Filesystem");
45 MODULE_LICENSE("GPL");
46
47 #define EXTENT_MERGE_SIZE 5
48
49 static mode_t udf_convert_permissions(struct fileEntry *);
50 static int udf_update_inode(struct inode *, int);
51 static void udf_fill_inode(struct inode *, struct buffer_head *);
52 static struct buffer_head *inode_getblk(struct inode *, sector_t, int *,
53 long *, int *);
54 static int8_t udf_insert_aext(struct inode *, struct extent_position,
55 kernel_lb_addr, uint32_t);
56 static void udf_split_extents(struct inode *, int *, int, int,
57 kernel_long_ad [EXTENT_MERGE_SIZE], int *);
58 static void udf_prealloc_extents(struct inode *, int, int,
59 kernel_long_ad [EXTENT_MERGE_SIZE], int *);
60 static void udf_merge_extents(struct inode *,
61 kernel_long_ad [EXTENT_MERGE_SIZE], int *);
62 static void udf_update_extents(struct inode *,
63 kernel_long_ad [EXTENT_MERGE_SIZE], int, int,
64 struct extent_position *);
65 static int udf_get_block(struct inode *, sector_t, struct buffer_head *, int);
66
67 /*
68 * udf_delete_inode
69 *
70 * PURPOSE
71 * Clean-up before the specified inode is destroyed.
72 *
73 * DESCRIPTION
74 * This routine is called when the kernel destroys an inode structure
75 * ie. when iput() finds i_count == 0.
76 *
77 * HISTORY
78 * July 1, 1997 - Andrew E. Mileski
79 * Written, tested, and released.
80 *
81 * Called at the last iput() if i_nlink is zero.
82 */
83 void udf_delete_inode(struct inode * inode)
84 {
85 truncate_inode_pages(&inode->i_data, 0);
86
87 if (is_bad_inode(inode))
88 goto no_delete;
89
90 inode->i_size = 0;
91 udf_truncate(inode);
92 lock_kernel();
93
94 udf_update_inode(inode, IS_SYNC(inode));
95 udf_free_inode(inode);
96
97 unlock_kernel();
98 return;
99 no_delete:
100 clear_inode(inode);
101 }
102
103 /*
104 * If we are going to release inode from memory, we discard preallocation and
105 * truncate last inode extent to proper length. We could use drop_inode() but
106 * it's called under inode_lock and thus we cannot mark inode dirty there. We
107 * use clear_inode() but we have to make sure to write inode as it's not written
108 * automatically.
109 */
110 void udf_clear_inode(struct inode *inode)
111 {
112 if (!(inode->i_sb->s_flags & MS_RDONLY)) {
113 lock_kernel();
114 /* Discard preallocation for directories, symlinks, etc. */
115 udf_discard_prealloc(inode);
116 udf_truncate_tail_extent(inode);
117 unlock_kernel();
118 write_inode_now(inode, 1);
119 }
120 kfree(UDF_I_DATA(inode));
121 UDF_I_DATA(inode) = NULL;
122 }
123
124 static int udf_writepage(struct page *page, struct writeback_control *wbc)
125 {
126 return block_write_full_page(page, udf_get_block, wbc);
127 }
128
129 static int udf_readpage(struct file *file, struct page *page)
130 {
131 return block_read_full_page(page, udf_get_block);
132 }
133
134 static int udf_prepare_write(struct file *file, struct page *page, unsigned from, unsigned to)
135 {
136 return block_prepare_write(page, from, to, udf_get_block);
137 }
138
139 static sector_t udf_bmap(struct address_space *mapping, sector_t block)
140 {
141 return generic_block_bmap(mapping,block,udf_get_block);
142 }
143
144 const struct address_space_operations udf_aops = {
145 .readpage = udf_readpage,
146 .writepage = udf_writepage,
147 .sync_page = block_sync_page,
148 .prepare_write = udf_prepare_write,
149 .commit_write = generic_commit_write,
150 .bmap = udf_bmap,
151 };
152
153 void udf_expand_file_adinicb(struct inode * inode, int newsize, int * err)
154 {
155 struct page *page;
156 char *kaddr;
157 struct writeback_control udf_wbc = {
158 .sync_mode = WB_SYNC_NONE,
159 .nr_to_write = 1,
160 };
161
162 /* from now on we have normal address_space methods */
163 inode->i_data.a_ops = &udf_aops;
164
165 if (!UDF_I_LENALLOC(inode))
166 {
167 if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_SHORT_AD))
168 UDF_I_ALLOCTYPE(inode) = ICBTAG_FLAG_AD_SHORT;
169 else
170 UDF_I_ALLOCTYPE(inode) = ICBTAG_FLAG_AD_LONG;
171 mark_inode_dirty(inode);
172 return;
173 }
174
175 page = grab_cache_page(inode->i_mapping, 0);
176 BUG_ON(!PageLocked(page));
177
178 if (!PageUptodate(page))
179 {
180 kaddr = kmap(page);
181 memset(kaddr + UDF_I_LENALLOC(inode), 0x00,
182 PAGE_CACHE_SIZE - UDF_I_LENALLOC(inode));
183 memcpy(kaddr, UDF_I_DATA(inode) + UDF_I_LENEATTR(inode),
184 UDF_I_LENALLOC(inode));
185 flush_dcache_page(page);
186 SetPageUptodate(page);
187 kunmap(page);
188 }
189 memset(UDF_I_DATA(inode) + UDF_I_LENEATTR(inode), 0x00,
190 UDF_I_LENALLOC(inode));
191 UDF_I_LENALLOC(inode) = 0;
192 if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_SHORT_AD))
193 UDF_I_ALLOCTYPE(inode) = ICBTAG_FLAG_AD_SHORT;
194 else
195 UDF_I_ALLOCTYPE(inode) = ICBTAG_FLAG_AD_LONG;
196
197 inode->i_data.a_ops->writepage(page, &udf_wbc);
198 page_cache_release(page);
199
200 mark_inode_dirty(inode);
201 }
202
203 struct buffer_head * udf_expand_dir_adinicb(struct inode *inode, int *block, int *err)
204 {
205 int newblock;
206 struct buffer_head *dbh = NULL;
207 kernel_lb_addr eloc;
208 uint32_t elen;
209 uint8_t alloctype;
210 struct extent_position epos;
211
212 struct udf_fileident_bh sfibh, dfibh;
213 loff_t f_pos = udf_ext0_offset(inode) >> 2;
214 int size = (udf_ext0_offset(inode) + inode->i_size) >> 2;
215 struct fileIdentDesc cfi, *sfi, *dfi;
216
217 if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_SHORT_AD))
218 alloctype = ICBTAG_FLAG_AD_SHORT;
219 else
220 alloctype = ICBTAG_FLAG_AD_LONG;
221
222 if (!inode->i_size)
223 {
224 UDF_I_ALLOCTYPE(inode) = alloctype;
225 mark_inode_dirty(inode);
226 return NULL;
227 }
228
229 /* alloc block, and copy data to it */
230 *block = udf_new_block(inode->i_sb, inode,
231 UDF_I_LOCATION(inode).partitionReferenceNum,
232 UDF_I_LOCATION(inode).logicalBlockNum, err);
233
234 if (!(*block))
235 return NULL;
236 newblock = udf_get_pblock(inode->i_sb, *block,
237 UDF_I_LOCATION(inode).partitionReferenceNum, 0);
238 if (!newblock)
239 return NULL;
240 dbh = udf_tgetblk(inode->i_sb, newblock);
241 if (!dbh)
242 return NULL;
243 lock_buffer(dbh);
244 memset(dbh->b_data, 0x00, inode->i_sb->s_blocksize);
245 set_buffer_uptodate(dbh);
246 unlock_buffer(dbh);
247 mark_buffer_dirty_inode(dbh, inode);
248
249 sfibh.soffset = sfibh.eoffset = (f_pos & ((inode->i_sb->s_blocksize - 1) >> 2)) << 2;
250 sfibh.sbh = sfibh.ebh = NULL;
251 dfibh.soffset = dfibh.eoffset = 0;
252 dfibh.sbh = dfibh.ebh = dbh;
253 while ( (f_pos < size) )
254 {
255 UDF_I_ALLOCTYPE(inode) = ICBTAG_FLAG_AD_IN_ICB;
256 sfi = udf_fileident_read(inode, &f_pos, &sfibh, &cfi, NULL, NULL, NULL, NULL);
257 if (!sfi)
258 {
259 brelse(dbh);
260 return NULL;
261 }
262 UDF_I_ALLOCTYPE(inode) = alloctype;
263 sfi->descTag.tagLocation = cpu_to_le32(*block);
264 dfibh.soffset = dfibh.eoffset;
265 dfibh.eoffset += (sfibh.eoffset - sfibh.soffset);
266 dfi = (struct fileIdentDesc *)(dbh->b_data + dfibh.soffset);
267 if (udf_write_fi(inode, sfi, dfi, &dfibh, sfi->impUse,
268 sfi->fileIdent + le16_to_cpu(sfi->lengthOfImpUse)))
269 {
270 UDF_I_ALLOCTYPE(inode) = ICBTAG_FLAG_AD_IN_ICB;
271 brelse(dbh);
272 return NULL;
273 }
274 }
275 mark_buffer_dirty_inode(dbh, inode);
276
277 memset(UDF_I_DATA(inode) + UDF_I_LENEATTR(inode), 0, UDF_I_LENALLOC(inode));
278 UDF_I_LENALLOC(inode) = 0;
279 eloc.logicalBlockNum = *block;
280 eloc.partitionReferenceNum = UDF_I_LOCATION(inode).partitionReferenceNum;
281 elen = inode->i_size;
282 UDF_I_LENEXTENTS(inode) = elen;
283 epos.bh = NULL;
284 epos.block = UDF_I_LOCATION(inode);
285 epos.offset = udf_file_entry_alloc_offset(inode);
286 udf_add_aext(inode, &epos, eloc, elen, 0);
287 /* UniqueID stuff */
288
289 brelse(epos.bh);
290 mark_inode_dirty(inode);
291 return dbh;
292 }
293
294 static int udf_get_block(struct inode *inode, sector_t block, struct buffer_head *bh_result, int create)
295 {
296 int err, new;
297 struct buffer_head *bh;
298 unsigned long phys;
299
300 if (!create)
301 {
302 phys = udf_block_map(inode, block);
303 if (phys)
304 map_bh(bh_result, inode->i_sb, phys);
305 return 0;
306 }
307
308 err = -EIO;
309 new = 0;
310 bh = NULL;
311
312 lock_kernel();
313
314 if (block < 0)
315 goto abort_negative;
316
317 if (block == UDF_I_NEXT_ALLOC_BLOCK(inode) + 1)
318 {
319 UDF_I_NEXT_ALLOC_BLOCK(inode) ++;
320 UDF_I_NEXT_ALLOC_GOAL(inode) ++;
321 }
322
323 err = 0;
324
325 bh = inode_getblk(inode, block, &err, &phys, &new);
326 BUG_ON(bh);
327 if (err)
328 goto abort;
329 BUG_ON(!phys);
330
331 if (new)
332 set_buffer_new(bh_result);
333 map_bh(bh_result, inode->i_sb, phys);
334 abort:
335 unlock_kernel();
336 return err;
337
338 abort_negative:
339 udf_warning(inode->i_sb, "udf_get_block", "block < 0");
340 goto abort;
341 }
342
343 static struct buffer_head *
344 udf_getblk(struct inode *inode, long block, int create, int *err)
345 {
346 struct buffer_head dummy;
347
348 dummy.b_state = 0;
349 dummy.b_blocknr = -1000;
350 *err = udf_get_block(inode, block, &dummy, create);
351 if (!*err && buffer_mapped(&dummy))
352 {
353 struct buffer_head *bh;
354 bh = sb_getblk(inode->i_sb, dummy.b_blocknr);
355 if (buffer_new(&dummy))
356 {
357 lock_buffer(bh);
358 memset(bh->b_data, 0x00, inode->i_sb->s_blocksize);
359 set_buffer_uptodate(bh);
360 unlock_buffer(bh);
361 mark_buffer_dirty_inode(bh, inode);
362 }
363 return bh;
364 }
365 return NULL;
366 }
367
368 /* Extend the file by 'blocks' blocks, return the number of extents added */
369 int udf_extend_file(struct inode *inode, struct extent_position *last_pos,
370 kernel_long_ad *last_ext, sector_t blocks)
371 {
372 sector_t add;
373 int count = 0, fake = !(last_ext->extLength & UDF_EXTENT_LENGTH_MASK);
374 struct super_block *sb = inode->i_sb;
375 kernel_lb_addr prealloc_loc = {0, 0};
376 int prealloc_len = 0;
377
378 /* The previous extent is fake and we should not extend by anything
379 * - there's nothing to do... */
380 if (!blocks && fake)
381 return 0;
382 /* Round the last extent up to a multiple of block size */
383 if (last_ext->extLength & (sb->s_blocksize - 1)) {
384 last_ext->extLength =
385 (last_ext->extLength & UDF_EXTENT_FLAG_MASK) |
386 (((last_ext->extLength & UDF_EXTENT_LENGTH_MASK) +
387 sb->s_blocksize - 1) & ~(sb->s_blocksize - 1));
388 UDF_I_LENEXTENTS(inode) =
389 (UDF_I_LENEXTENTS(inode) + sb->s_blocksize - 1) &
390 ~(sb->s_blocksize - 1);
391 }
392 /* Last extent are just preallocated blocks? */
393 if ((last_ext->extLength & UDF_EXTENT_FLAG_MASK) == EXT_NOT_RECORDED_ALLOCATED) {
394 /* Save the extent so that we can reattach it to the end */
395 prealloc_loc = last_ext->extLocation;
396 prealloc_len = last_ext->extLength;
397 /* Mark the extent as a hole */
398 last_ext->extLength = EXT_NOT_RECORDED_NOT_ALLOCATED |
399 (last_ext->extLength & UDF_EXTENT_LENGTH_MASK);
400 last_ext->extLocation.logicalBlockNum = 0;
401 last_ext->extLocation.partitionReferenceNum = 0;
402 }
403 /* Can we merge with the previous extent? */
404 if ((last_ext->extLength & UDF_EXTENT_FLAG_MASK) == EXT_NOT_RECORDED_NOT_ALLOCATED) {
405 add = ((1<<30) - sb->s_blocksize - (last_ext->extLength &
406 UDF_EXTENT_LENGTH_MASK)) >> sb->s_blocksize_bits;
407 if (add > blocks)
408 add = blocks;
409 blocks -= add;
410 last_ext->extLength += add << sb->s_blocksize_bits;
411 }
412
413 if (fake) {
414 udf_add_aext(inode, last_pos, last_ext->extLocation,
415 last_ext->extLength, 1);
416 count++;
417 }
418 else
419 udf_write_aext(inode, last_pos, last_ext->extLocation, last_ext->extLength, 1);
420 /* Managed to do everything necessary? */
421 if (!blocks)
422 goto out;
423
424 /* All further extents will be NOT_RECORDED_NOT_ALLOCATED */
425 last_ext->extLocation.logicalBlockNum = 0;
426 last_ext->extLocation.partitionReferenceNum = 0;
427 add = (1 << (30-sb->s_blocksize_bits)) - 1;
428 last_ext->extLength = EXT_NOT_RECORDED_NOT_ALLOCATED | (add << sb->s_blocksize_bits);
429 /* Create enough extents to cover the whole hole */
430 while (blocks > add) {
431 blocks -= add;
432 if (udf_add_aext(inode, last_pos, last_ext->extLocation,
433 last_ext->extLength, 1) == -1)
434 return -1;
435 count++;
436 }
437 if (blocks) {
438 last_ext->extLength = EXT_NOT_RECORDED_NOT_ALLOCATED |
439 (blocks << sb->s_blocksize_bits);
440 if (udf_add_aext(inode, last_pos, last_ext->extLocation,
441 last_ext->extLength, 1) == -1)
442 return -1;
443 count++;
444 }
445 out:
446 /* Do we have some preallocated blocks saved? */
447 if (prealloc_len) {
448 if (udf_add_aext(inode, last_pos, prealloc_loc, prealloc_len, 1) == -1)
449 return -1;
450 last_ext->extLocation = prealloc_loc;
451 last_ext->extLength = prealloc_len;
452 count++;
453 }
454 /* last_pos should point to the last written extent... */
455 if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_SHORT)
456 last_pos->offset -= sizeof(short_ad);
457 else if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_LONG)
458 last_pos->offset -= sizeof(long_ad);
459 else
460 return -1;
461 return count;
462 }
463
464 static struct buffer_head * inode_getblk(struct inode * inode, sector_t block,
465 int *err, long *phys, int *new)
466 {
467 static sector_t last_block;
468 struct buffer_head *result = NULL;
469 kernel_long_ad laarr[EXTENT_MERGE_SIZE];
470 struct extent_position prev_epos, cur_epos, next_epos;
471 int count = 0, startnum = 0, endnum = 0;
472 uint32_t elen = 0, tmpelen;
473 kernel_lb_addr eloc, tmpeloc;
474 int c = 1;
475 loff_t lbcount = 0, b_off = 0;
476 uint32_t newblocknum, newblock;
477 sector_t offset = 0;
478 int8_t etype;
479 int goal = 0, pgoal = UDF_I_LOCATION(inode).logicalBlockNum;
480 int lastblock = 0;
481
482 prev_epos.offset = udf_file_entry_alloc_offset(inode);
483 prev_epos.block = UDF_I_LOCATION(inode);
484 prev_epos.bh = NULL;
485 cur_epos = next_epos = prev_epos;
486 b_off = (loff_t)block << inode->i_sb->s_blocksize_bits;
487
488 /* find the extent which contains the block we are looking for.
489 alternate between laarr[0] and laarr[1] for locations of the
490 current extent, and the previous extent */
491 do
492 {
493 if (prev_epos.bh != cur_epos.bh)
494 {
495 brelse(prev_epos.bh);
496 get_bh(cur_epos.bh);
497 prev_epos.bh = cur_epos.bh;
498 }
499 if (cur_epos.bh != next_epos.bh)
500 {
501 brelse(cur_epos.bh);
502 get_bh(next_epos.bh);
503 cur_epos.bh = next_epos.bh;
504 }
505
506 lbcount += elen;
507
508 prev_epos.block = cur_epos.block;
509 cur_epos.block = next_epos.block;
510
511 prev_epos.offset = cur_epos.offset;
512 cur_epos.offset = next_epos.offset;
513
514 if ((etype = udf_next_aext(inode, &next_epos, &eloc, &elen, 1)) == -1)
515 break;
516
517 c = !c;
518
519 laarr[c].extLength = (etype << 30) | elen;
520 laarr[c].extLocation = eloc;
521
522 if (etype != (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30))
523 pgoal = eloc.logicalBlockNum +
524 ((elen + inode->i_sb->s_blocksize - 1) >>
525 inode->i_sb->s_blocksize_bits);
526
527 count ++;
528 } while (lbcount + elen <= b_off);
529
530 b_off -= lbcount;
531 offset = b_off >> inode->i_sb->s_blocksize_bits;
532 /*
533 * Move prev_epos and cur_epos into indirect extent if we are at
534 * the pointer to it
535 */
536 udf_next_aext(inode, &prev_epos, &tmpeloc, &tmpelen, 0);
537 udf_next_aext(inode, &cur_epos, &tmpeloc, &tmpelen, 0);
538
539 /* if the extent is allocated and recorded, return the block
540 if the extent is not a multiple of the blocksize, round up */
541
542 if (etype == (EXT_RECORDED_ALLOCATED >> 30))
543 {
544 if (elen & (inode->i_sb->s_blocksize - 1))
545 {
546 elen = EXT_RECORDED_ALLOCATED |
547 ((elen + inode->i_sb->s_blocksize - 1) &
548 ~(inode->i_sb->s_blocksize - 1));
549 etype = udf_write_aext(inode, &cur_epos, eloc, elen, 1);
550 }
551 brelse(prev_epos.bh);
552 brelse(cur_epos.bh);
553 brelse(next_epos.bh);
554 newblock = udf_get_lb_pblock(inode->i_sb, eloc, offset);
555 *phys = newblock;
556 return NULL;
557 }
558
559 last_block = block;
560 /* Are we beyond EOF? */
561 if (etype == -1)
562 {
563 int ret;
564
565 if (count) {
566 if (c)
567 laarr[0] = laarr[1];
568 startnum = 1;
569 }
570 else {
571 /* Create a fake extent when there's not one */
572 memset(&laarr[0].extLocation, 0x00, sizeof(kernel_lb_addr));
573 laarr[0].extLength = EXT_NOT_RECORDED_NOT_ALLOCATED;
574 /* Will udf_extend_file() create real extent from a fake one? */
575 startnum = (offset > 0);
576 }
577 /* Create extents for the hole between EOF and offset */
578 ret = udf_extend_file(inode, &prev_epos, laarr, offset);
579 if (ret == -1) {
580 brelse(prev_epos.bh);
581 brelse(cur_epos.bh);
582 brelse(next_epos.bh);
583 /* We don't really know the error here so we just make
584 * something up */
585 *err = -ENOSPC;
586 return NULL;
587 }
588 c = 0;
589 offset = 0;
590 count += ret;
591 /* We are not covered by a preallocated extent? */
592 if ((laarr[0].extLength & UDF_EXTENT_FLAG_MASK) != EXT_NOT_RECORDED_ALLOCATED) {
593 /* Is there any real extent? - otherwise we overwrite
594 * the fake one... */
595 if (count)
596 c = !c;
597 laarr[c].extLength = EXT_NOT_RECORDED_NOT_ALLOCATED |
598 inode->i_sb->s_blocksize;
599 memset(&laarr[c].extLocation, 0x00, sizeof(kernel_lb_addr));
600 count ++;
601 endnum ++;
602 }
603 endnum = c+1;
604 lastblock = 1;
605 }
606 else {
607 endnum = startnum = ((count > 2) ? 2 : count);
608
609 /* if the current extent is in position 0, swap it with the previous */
610 if (!c && count != 1)
611 {
612 laarr[2] = laarr[0];
613 laarr[0] = laarr[1];
614 laarr[1] = laarr[2];
615 c = 1;
616 }
617
618 /* if the current block is located in an extent, read the next extent */
619 if ((etype = udf_next_aext(inode, &next_epos, &eloc, &elen, 0)) != -1)
620 {
621 laarr[c+1].extLength = (etype << 30) | elen;
622 laarr[c+1].extLocation = eloc;
623 count ++;
624 startnum ++;
625 endnum ++;
626 }
627 else {
628 lastblock = 1;
629 }
630 }
631
632 /* if the current extent is not recorded but allocated, get the
633 block in the extent corresponding to the requested block */
634 if ((laarr[c].extLength >> 30) == (EXT_NOT_RECORDED_ALLOCATED >> 30))
635 newblocknum = laarr[c].extLocation.logicalBlockNum + offset;
636 else /* otherwise, allocate a new block */
637 {
638 if (UDF_I_NEXT_ALLOC_BLOCK(inode) == block)
639 goal = UDF_I_NEXT_ALLOC_GOAL(inode);
640
641 if (!goal)
642 {
643 if (!(goal = pgoal))
644 goal = UDF_I_LOCATION(inode).logicalBlockNum + 1;
645 }
646
647 if (!(newblocknum = udf_new_block(inode->i_sb, inode,
648 UDF_I_LOCATION(inode).partitionReferenceNum, goal, err)))
649 {
650 brelse(prev_epos.bh);
651 *err = -ENOSPC;
652 return NULL;
653 }
654 UDF_I_LENEXTENTS(inode) += inode->i_sb->s_blocksize;
655 }
656
657 /* if the extent the requsted block is located in contains multiple blocks,
658 split the extent into at most three extents. blocks prior to requested
659 block, requested block, and blocks after requested block */
660 udf_split_extents(inode, &c, offset, newblocknum, laarr, &endnum);
661
662 #ifdef UDF_PREALLOCATE
663 /* preallocate blocks */
664 udf_prealloc_extents(inode, c, lastblock, laarr, &endnum);
665 #endif
666
667 /* merge any continuous blocks in laarr */
668 udf_merge_extents(inode, laarr, &endnum);
669
670 /* write back the new extents, inserting new extents if the new number
671 of extents is greater than the old number, and deleting extents if
672 the new number of extents is less than the old number */
673 udf_update_extents(inode, laarr, startnum, endnum, &prev_epos);
674
675 brelse(prev_epos.bh);
676
677 if (!(newblock = udf_get_pblock(inode->i_sb, newblocknum,
678 UDF_I_LOCATION(inode).partitionReferenceNum, 0)))
679 {
680 return NULL;
681 }
682 *phys = newblock;
683 *err = 0;
684 *new = 1;
685 UDF_I_NEXT_ALLOC_BLOCK(inode) = block;
686 UDF_I_NEXT_ALLOC_GOAL(inode) = newblocknum;
687 inode->i_ctime = current_fs_time(inode->i_sb);
688
689 if (IS_SYNC(inode))
690 udf_sync_inode(inode);
691 else
692 mark_inode_dirty(inode);
693 return result;
694 }
695
696 static void udf_split_extents(struct inode *inode, int *c, int offset, int newblocknum,
697 kernel_long_ad laarr[EXTENT_MERGE_SIZE], int *endnum)
698 {
699 if ((laarr[*c].extLength >> 30) == (EXT_NOT_RECORDED_ALLOCATED >> 30) ||
700 (laarr[*c].extLength >> 30) == (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30))
701 {
702 int curr = *c;
703 int blen = ((laarr[curr].extLength & UDF_EXTENT_LENGTH_MASK) +
704 inode->i_sb->s_blocksize - 1) >> inode->i_sb->s_blocksize_bits;
705 int8_t etype = (laarr[curr].extLength >> 30);
706
707 if (blen == 1)
708 ;
709 else if (!offset || blen == offset + 1)
710 {
711 laarr[curr+2] = laarr[curr+1];
712 laarr[curr+1] = laarr[curr];
713 }
714 else
715 {
716 laarr[curr+3] = laarr[curr+1];
717 laarr[curr+2] = laarr[curr+1] = laarr[curr];
718 }
719
720 if (offset)
721 {
722 if (etype == (EXT_NOT_RECORDED_ALLOCATED >> 30))
723 {
724 udf_free_blocks(inode->i_sb, inode, laarr[curr].extLocation, 0, offset);
725 laarr[curr].extLength = EXT_NOT_RECORDED_NOT_ALLOCATED |
726 (offset << inode->i_sb->s_blocksize_bits);
727 laarr[curr].extLocation.logicalBlockNum = 0;
728 laarr[curr].extLocation.partitionReferenceNum = 0;
729 }
730 else
731 laarr[curr].extLength = (etype << 30) |
732 (offset << inode->i_sb->s_blocksize_bits);
733 curr ++;
734 (*c) ++;
735 (*endnum) ++;
736 }
737
738 laarr[curr].extLocation.logicalBlockNum = newblocknum;
739 if (etype == (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30))
740 laarr[curr].extLocation.partitionReferenceNum =
741 UDF_I_LOCATION(inode).partitionReferenceNum;
742 laarr[curr].extLength = EXT_RECORDED_ALLOCATED |
743 inode->i_sb->s_blocksize;
744 curr ++;
745
746 if (blen != offset + 1)
747 {
748 if (etype == (EXT_NOT_RECORDED_ALLOCATED >> 30))
749 laarr[curr].extLocation.logicalBlockNum += (offset + 1);
750 laarr[curr].extLength = (etype << 30) |
751 ((blen - (offset + 1)) << inode->i_sb->s_blocksize_bits);
752 curr ++;
753 (*endnum) ++;
754 }
755 }
756 }
757
758 static void udf_prealloc_extents(struct inode *inode, int c, int lastblock,
759 kernel_long_ad laarr[EXTENT_MERGE_SIZE], int *endnum)
760 {
761 int start, length = 0, currlength = 0, i;
762
763 if (*endnum >= (c+1))
764 {
765 if (!lastblock)
766 return;
767 else
768 start = c;
769 }
770 else
771 {
772 if ((laarr[c+1].extLength >> 30) == (EXT_NOT_RECORDED_ALLOCATED >> 30))
773 {
774 start = c+1;
775 length = currlength = (((laarr[c+1].extLength & UDF_EXTENT_LENGTH_MASK) +
776 inode->i_sb->s_blocksize - 1) >> inode->i_sb->s_blocksize_bits);
777 }
778 else
779 start = c;
780 }
781
782 for (i=start+1; i<=*endnum; i++)
783 {
784 if (i == *endnum)
785 {
786 if (lastblock)
787 length += UDF_DEFAULT_PREALLOC_BLOCKS;
788 }
789 else if ((laarr[i].extLength >> 30) == (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30))
790 length += (((laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) +
791 inode->i_sb->s_blocksize - 1) >> inode->i_sb->s_blocksize_bits);
792 else
793 break;
794 }
795
796 if (length)
797 {
798 int next = laarr[start].extLocation.logicalBlockNum +
799 (((laarr[start].extLength & UDF_EXTENT_LENGTH_MASK) +
800 inode->i_sb->s_blocksize - 1) >> inode->i_sb->s_blocksize_bits);
801 int numalloc = udf_prealloc_blocks(inode->i_sb, inode,
802 laarr[start].extLocation.partitionReferenceNum,
803 next, (UDF_DEFAULT_PREALLOC_BLOCKS > length ? length :
804 UDF_DEFAULT_PREALLOC_BLOCKS) - currlength);
805
806 if (numalloc)
807 {
808 if (start == (c+1))
809 laarr[start].extLength +=
810 (numalloc << inode->i_sb->s_blocksize_bits);
811 else
812 {
813 memmove(&laarr[c+2], &laarr[c+1],
814 sizeof(long_ad) * (*endnum - (c+1)));
815 (*endnum) ++;
816 laarr[c+1].extLocation.logicalBlockNum = next;
817 laarr[c+1].extLocation.partitionReferenceNum =
818 laarr[c].extLocation.partitionReferenceNum;
819 laarr[c+1].extLength = EXT_NOT_RECORDED_ALLOCATED |
820 (numalloc << inode->i_sb->s_blocksize_bits);
821 start = c+1;
822 }
823
824 for (i=start+1; numalloc && i<*endnum; i++)
825 {
826 int elen = ((laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) +
827 inode->i_sb->s_blocksize - 1) >> inode->i_sb->s_blocksize_bits;
828
829 if (elen > numalloc)
830 {
831 laarr[i].extLength -=
832 (numalloc << inode->i_sb->s_blocksize_bits);
833 numalloc = 0;
834 }
835 else
836 {
837 numalloc -= elen;
838 if (*endnum > (i+1))
839 memmove(&laarr[i], &laarr[i+1],
840 sizeof(long_ad) * (*endnum - (i+1)));
841 i --;
842 (*endnum) --;
843 }
844 }
845 UDF_I_LENEXTENTS(inode) += numalloc << inode->i_sb->s_blocksize_bits;
846 }
847 }
848 }
849
850 static void udf_merge_extents(struct inode *inode,
851 kernel_long_ad laarr[EXTENT_MERGE_SIZE], int *endnum)
852 {
853 int i;
854
855 for (i=0; i<(*endnum-1); i++)
856 {
857 if ((laarr[i].extLength >> 30) == (laarr[i+1].extLength >> 30))
858 {
859 if (((laarr[i].extLength >> 30) == (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30)) ||
860 ((laarr[i+1].extLocation.logicalBlockNum - laarr[i].extLocation.logicalBlockNum) ==
861 (((laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) +
862 inode->i_sb->s_blocksize - 1) >> inode->i_sb->s_blocksize_bits)))
863 {
864 if (((laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) +
865 (laarr[i+1].extLength & UDF_EXTENT_LENGTH_MASK) +
866 inode->i_sb->s_blocksize - 1) & ~UDF_EXTENT_LENGTH_MASK)
867 {
868 laarr[i+1].extLength = (laarr[i+1].extLength -
869 (laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) +
870 UDF_EXTENT_LENGTH_MASK) & ~(inode->i_sb->s_blocksize-1);
871 laarr[i].extLength = (laarr[i].extLength & UDF_EXTENT_FLAG_MASK) +
872 (UDF_EXTENT_LENGTH_MASK + 1) - inode->i_sb->s_blocksize;
873 laarr[i+1].extLocation.logicalBlockNum =
874 laarr[i].extLocation.logicalBlockNum +
875 ((laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) >>
876 inode->i_sb->s_blocksize_bits);
877 }
878 else
879 {
880 laarr[i].extLength = laarr[i+1].extLength +
881 (((laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) +
882 inode->i_sb->s_blocksize - 1) & ~(inode->i_sb->s_blocksize-1));
883 if (*endnum > (i+2))
884 memmove(&laarr[i+1], &laarr[i+2],
885 sizeof(long_ad) * (*endnum - (i+2)));
886 i --;
887 (*endnum) --;
888 }
889 }
890 }
891 else if (((laarr[i].extLength >> 30) == (EXT_NOT_RECORDED_ALLOCATED >> 30)) &&
892 ((laarr[i+1].extLength >> 30) == (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30)))
893 {
894 udf_free_blocks(inode->i_sb, inode, laarr[i].extLocation, 0,
895 ((laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) +
896 inode->i_sb->s_blocksize - 1) >> inode->i_sb->s_blocksize_bits);
897 laarr[i].extLocation.logicalBlockNum = 0;
898 laarr[i].extLocation.partitionReferenceNum = 0;
899
900 if (((laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) +
901 (laarr[i+1].extLength & UDF_EXTENT_LENGTH_MASK) +
902 inode->i_sb->s_blocksize - 1) & ~UDF_EXTENT_LENGTH_MASK)
903 {
904 laarr[i+1].extLength = (laarr[i+1].extLength -
905 (laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) +
906 UDF_EXTENT_LENGTH_MASK) & ~(inode->i_sb->s_blocksize-1);
907 laarr[i].extLength = (laarr[i].extLength & UDF_EXTENT_FLAG_MASK) +
908 (UDF_EXTENT_LENGTH_MASK + 1) - inode->i_sb->s_blocksize;
909 }
910 else
911 {
912 laarr[i].extLength = laarr[i+1].extLength +
913 (((laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) +
914 inode->i_sb->s_blocksize - 1) & ~(inode->i_sb->s_blocksize-1));
915 if (*endnum > (i+2))
916 memmove(&laarr[i+1], &laarr[i+2],
917 sizeof(long_ad) * (*endnum - (i+2)));
918 i --;
919 (*endnum) --;
920 }
921 }
922 else if ((laarr[i].extLength >> 30) == (EXT_NOT_RECORDED_ALLOCATED >> 30))
923 {
924 udf_free_blocks(inode->i_sb, inode, laarr[i].extLocation, 0,
925 ((laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) +
926 inode->i_sb->s_blocksize - 1) >> inode->i_sb->s_blocksize_bits);
927 laarr[i].extLocation.logicalBlockNum = 0;
928 laarr[i].extLocation.partitionReferenceNum = 0;
929 laarr[i].extLength = (laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) |
930 EXT_NOT_RECORDED_NOT_ALLOCATED;
931 }
932 }
933 }
934
935 static void udf_update_extents(struct inode *inode,
936 kernel_long_ad laarr[EXTENT_MERGE_SIZE], int startnum, int endnum,
937 struct extent_position *epos)
938 {
939 int start = 0, i;
940 kernel_lb_addr tmploc;
941 uint32_t tmplen;
942
943 if (startnum > endnum)
944 {
945 for (i=0; i<(startnum-endnum); i++)
946 udf_delete_aext(inode, *epos, laarr[i].extLocation,
947 laarr[i].extLength);
948 }
949 else if (startnum < endnum)
950 {
951 for (i=0; i<(endnum-startnum); i++)
952 {
953 udf_insert_aext(inode, *epos, laarr[i].extLocation,
954 laarr[i].extLength);
955 udf_next_aext(inode, epos, &laarr[i].extLocation,
956 &laarr[i].extLength, 1);
957 start ++;
958 }
959 }
960
961 for (i=start; i<endnum; i++)
962 {
963 udf_next_aext(inode, epos, &tmploc, &tmplen, 0);
964 udf_write_aext(inode, epos, laarr[i].extLocation,
965 laarr[i].extLength, 1);
966 }
967 }
968
969 struct buffer_head * udf_bread(struct inode * inode, int block,
970 int create, int * err)
971 {
972 struct buffer_head * bh = NULL;
973
974 bh = udf_getblk(inode, block, create, err);
975 if (!bh)
976 return NULL;
977
978 if (buffer_uptodate(bh))
979 return bh;
980 ll_rw_block(READ, 1, &bh);
981 wait_on_buffer(bh);
982 if (buffer_uptodate(bh))
983 return bh;
984 brelse(bh);
985 *err = -EIO;
986 return NULL;
987 }
988
989 void udf_truncate(struct inode * inode)
990 {
991 int offset;
992 int err;
993
994 if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
995 S_ISLNK(inode->i_mode)))
996 return;
997 if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
998 return;
999
1000 lock_kernel();
1001 if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB)
1002 {
1003 if (inode->i_sb->s_blocksize < (udf_file_entry_alloc_offset(inode) +
1004 inode->i_size))
1005 {
1006 udf_expand_file_adinicb(inode, inode->i_size, &err);
1007 if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB)
1008 {
1009 inode->i_size = UDF_I_LENALLOC(inode);
1010 unlock_kernel();
1011 return;
1012 }
1013 else
1014 udf_truncate_extents(inode);
1015 }
1016 else
1017 {
1018 offset = inode->i_size & (inode->i_sb->s_blocksize - 1);
1019 memset(UDF_I_DATA(inode) + UDF_I_LENEATTR(inode) + offset, 0x00, inode->i_sb->s_blocksize - offset - udf_file_entry_alloc_offset(inode));
1020 UDF_I_LENALLOC(inode) = inode->i_size;
1021 }
1022 }
1023 else
1024 {
1025 block_truncate_page(inode->i_mapping, inode->i_size, udf_get_block);
1026 udf_truncate_extents(inode);
1027 }
1028
1029 inode->i_mtime = inode->i_ctime = current_fs_time(inode->i_sb);
1030 if (IS_SYNC(inode))
1031 udf_sync_inode (inode);
1032 else
1033 mark_inode_dirty(inode);
1034 unlock_kernel();
1035 }
1036
1037 static void
1038 __udf_read_inode(struct inode *inode)
1039 {
1040 struct buffer_head *bh = NULL;
1041 struct fileEntry *fe;
1042 uint16_t ident;
1043
1044 /*
1045 * Set defaults, but the inode is still incomplete!
1046 * Note: get_new_inode() sets the following on a new inode:
1047 * i_sb = sb
1048 * i_no = ino
1049 * i_flags = sb->s_flags
1050 * i_state = 0
1051 * clean_inode(): zero fills and sets
1052 * i_count = 1
1053 * i_nlink = 1
1054 * i_op = NULL;
1055 */
1056 bh = udf_read_ptagged(inode->i_sb, UDF_I_LOCATION(inode), 0, &ident);
1057
1058 if (!bh)
1059 {
1060 printk(KERN_ERR "udf: udf_read_inode(ino %ld) failed !bh\n",
1061 inode->i_ino);
1062 make_bad_inode(inode);
1063 return;
1064 }
1065
1066 if (ident != TAG_IDENT_FE && ident != TAG_IDENT_EFE &&
1067 ident != TAG_IDENT_USE)
1068 {
1069 printk(KERN_ERR "udf: udf_read_inode(ino %ld) failed ident=%d\n",
1070 inode->i_ino, ident);
1071 brelse(bh);
1072 make_bad_inode(inode);
1073 return;
1074 }
1075
1076 fe = (struct fileEntry *)bh->b_data;
1077
1078 if (le16_to_cpu(fe->icbTag.strategyType) == 4096)
1079 {
1080 struct buffer_head *ibh = NULL, *nbh = NULL;
1081 struct indirectEntry *ie;
1082
1083 ibh = udf_read_ptagged(inode->i_sb, UDF_I_LOCATION(inode), 1, &ident);
1084 if (ident == TAG_IDENT_IE)
1085 {
1086 if (ibh)
1087 {
1088 kernel_lb_addr loc;
1089 ie = (struct indirectEntry *)ibh->b_data;
1090
1091 loc = lelb_to_cpu(ie->indirectICB.extLocation);
1092
1093 if (ie->indirectICB.extLength &&
1094 (nbh = udf_read_ptagged(inode->i_sb, loc, 0, &ident)))
1095 {
1096 if (ident == TAG_IDENT_FE ||
1097 ident == TAG_IDENT_EFE)
1098 {
1099 memcpy(&UDF_I_LOCATION(inode), &loc, sizeof(kernel_lb_addr));
1100 brelse(bh);
1101 brelse(ibh);
1102 brelse(nbh);
1103 __udf_read_inode(inode);
1104 return;
1105 }
1106 else
1107 {
1108 brelse(nbh);
1109 brelse(ibh);
1110 }
1111 }
1112 else
1113 brelse(ibh);
1114 }
1115 }
1116 else
1117 brelse(ibh);
1118 }
1119 else if (le16_to_cpu(fe->icbTag.strategyType) != 4)
1120 {
1121 printk(KERN_ERR "udf: unsupported strategy type: %d\n",
1122 le16_to_cpu(fe->icbTag.strategyType));
1123 brelse(bh);
1124 make_bad_inode(inode);
1125 return;
1126 }
1127 udf_fill_inode(inode, bh);
1128
1129 brelse(bh);
1130 }
1131
1132 static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
1133 {
1134 struct fileEntry *fe;
1135 struct extendedFileEntry *efe;
1136 time_t convtime;
1137 long convtime_usec;
1138 int offset;
1139
1140 fe = (struct fileEntry *)bh->b_data;
1141 efe = (struct extendedFileEntry *)bh->b_data;
1142
1143 if (le16_to_cpu(fe->icbTag.strategyType) == 4)
1144 UDF_I_STRAT4096(inode) = 0;
1145 else /* if (le16_to_cpu(fe->icbTag.strategyType) == 4096) */
1146 UDF_I_STRAT4096(inode) = 1;
1147
1148 UDF_I_ALLOCTYPE(inode) = le16_to_cpu(fe->icbTag.flags) & ICBTAG_FLAG_AD_MASK;
1149 UDF_I_UNIQUE(inode) = 0;
1150 UDF_I_LENEATTR(inode) = 0;
1151 UDF_I_LENEXTENTS(inode) = 0;
1152 UDF_I_LENALLOC(inode) = 0;
1153 UDF_I_NEXT_ALLOC_BLOCK(inode) = 0;
1154 UDF_I_NEXT_ALLOC_GOAL(inode) = 0;
1155 if (le16_to_cpu(fe->descTag.tagIdent) == TAG_IDENT_EFE)
1156 {
1157 UDF_I_EFE(inode) = 1;
1158 UDF_I_USE(inode) = 0;
1159 UDF_I_DATA(inode) = kmalloc(inode->i_sb->s_blocksize - sizeof(struct extendedFileEntry), GFP_KERNEL);
1160 memcpy(UDF_I_DATA(inode), bh->b_data + sizeof(struct extendedFileEntry), inode->i_sb->s_blocksize - sizeof(struct extendedFileEntry));
1161 }
1162 else if (le16_to_cpu(fe->descTag.tagIdent) == TAG_IDENT_FE)
1163 {
1164 UDF_I_EFE(inode) = 0;
1165 UDF_I_USE(inode) = 0;
1166 UDF_I_DATA(inode) = kmalloc(inode->i_sb->s_blocksize - sizeof(struct fileEntry), GFP_KERNEL);
1167 memcpy(UDF_I_DATA(inode), bh->b_data + sizeof(struct fileEntry), inode->i_sb->s_blocksize - sizeof(struct fileEntry));
1168 }
1169 else if (le16_to_cpu(fe->descTag.tagIdent) == TAG_IDENT_USE)
1170 {
1171 UDF_I_EFE(inode) = 0;
1172 UDF_I_USE(inode) = 1;
1173 UDF_I_LENALLOC(inode) =
1174 le32_to_cpu(
1175 ((struct unallocSpaceEntry *)bh->b_data)->lengthAllocDescs);
1176 UDF_I_DATA(inode) = kmalloc(inode->i_sb->s_blocksize - sizeof(struct unallocSpaceEntry), GFP_KERNEL);
1177 memcpy(UDF_I_DATA(inode), bh->b_data + sizeof(struct unallocSpaceEntry), inode->i_sb->s_blocksize - sizeof(struct unallocSpaceEntry));
1178 return;
1179 }
1180
1181 inode->i_uid = le32_to_cpu(fe->uid);
1182 if (inode->i_uid == -1 || UDF_QUERY_FLAG(inode->i_sb,
1183 UDF_FLAG_UID_IGNORE))
1184 inode->i_uid = UDF_SB(inode->i_sb)->s_uid;
1185
1186 inode->i_gid = le32_to_cpu(fe->gid);
1187 if (inode->i_gid == -1 || UDF_QUERY_FLAG(inode->i_sb,
1188 UDF_FLAG_GID_IGNORE))
1189 inode->i_gid = UDF_SB(inode->i_sb)->s_gid;
1190
1191 inode->i_nlink = le16_to_cpu(fe->fileLinkCount);
1192 if (!inode->i_nlink)
1193 inode->i_nlink = 1;
1194
1195 inode->i_size = le64_to_cpu(fe->informationLength);
1196 UDF_I_LENEXTENTS(inode) = inode->i_size;
1197
1198 inode->i_mode = udf_convert_permissions(fe);
1199 inode->i_mode &= ~UDF_SB(inode->i_sb)->s_umask;
1200
1201 if (UDF_I_EFE(inode) == 0)
1202 {
1203 inode->i_blocks = le64_to_cpu(fe->logicalBlocksRecorded) <<
1204 (inode->i_sb->s_blocksize_bits - 9);
1205
1206 if ( udf_stamp_to_time(&convtime, &convtime_usec,
1207 lets_to_cpu(fe->accessTime)) )
1208 {
1209 inode->i_atime.tv_sec = convtime;
1210 inode->i_atime.tv_nsec = convtime_usec * 1000;
1211 }
1212 else
1213 {
1214 inode->i_atime = UDF_SB_RECORDTIME(inode->i_sb);
1215 }
1216
1217 if ( udf_stamp_to_time(&convtime, &convtime_usec,
1218 lets_to_cpu(fe->modificationTime)) )
1219 {
1220 inode->i_mtime.tv_sec = convtime;
1221 inode->i_mtime.tv_nsec = convtime_usec * 1000;
1222 }
1223 else
1224 {
1225 inode->i_mtime = UDF_SB_RECORDTIME(inode->i_sb);
1226 }
1227
1228 if ( udf_stamp_to_time(&convtime, &convtime_usec,
1229 lets_to_cpu(fe->attrTime)) )
1230 {
1231 inode->i_ctime.tv_sec = convtime;
1232 inode->i_ctime.tv_nsec = convtime_usec * 1000;
1233 }
1234 else
1235 {
1236 inode->i_ctime = UDF_SB_RECORDTIME(inode->i_sb);
1237 }
1238
1239 UDF_I_UNIQUE(inode) = le64_to_cpu(fe->uniqueID);
1240 UDF_I_LENEATTR(inode) = le32_to_cpu(fe->lengthExtendedAttr);
1241 UDF_I_LENALLOC(inode) = le32_to_cpu(fe->lengthAllocDescs);
1242 offset = sizeof(struct fileEntry) + UDF_I_LENEATTR(inode);
1243 }
1244 else
1245 {
1246 inode->i_blocks = le64_to_cpu(efe->logicalBlocksRecorded) <<
1247 (inode->i_sb->s_blocksize_bits - 9);
1248
1249 if ( udf_stamp_to_time(&convtime, &convtime_usec,
1250 lets_to_cpu(efe->accessTime)) )
1251 {
1252 inode->i_atime.tv_sec = convtime;
1253 inode->i_atime.tv_nsec = convtime_usec * 1000;
1254 }
1255 else
1256 {
1257 inode->i_atime = UDF_SB_RECORDTIME(inode->i_sb);
1258 }
1259
1260 if ( udf_stamp_to_time(&convtime, &convtime_usec,
1261 lets_to_cpu(efe->modificationTime)) )
1262 {
1263 inode->i_mtime.tv_sec = convtime;
1264 inode->i_mtime.tv_nsec = convtime_usec * 1000;
1265 }
1266 else
1267 {
1268 inode->i_mtime = UDF_SB_RECORDTIME(inode->i_sb);
1269 }
1270
1271 if ( udf_stamp_to_time(&convtime, &convtime_usec,
1272 lets_to_cpu(efe->createTime)) )
1273 {
1274 UDF_I_CRTIME(inode).tv_sec = convtime;
1275 UDF_I_CRTIME(inode).tv_nsec = convtime_usec * 1000;
1276 }
1277 else
1278 {
1279 UDF_I_CRTIME(inode) = UDF_SB_RECORDTIME(inode->i_sb);
1280 }
1281
1282 if ( udf_stamp_to_time(&convtime, &convtime_usec,
1283 lets_to_cpu(efe->attrTime)) )
1284 {
1285 inode->i_ctime.tv_sec = convtime;
1286 inode->i_ctime.tv_nsec = convtime_usec * 1000;
1287 }
1288 else
1289 {
1290 inode->i_ctime = UDF_SB_RECORDTIME(inode->i_sb);
1291 }
1292
1293 UDF_I_UNIQUE(inode) = le64_to_cpu(efe->uniqueID);
1294 UDF_I_LENEATTR(inode) = le32_to_cpu(efe->lengthExtendedAttr);
1295 UDF_I_LENALLOC(inode) = le32_to_cpu(efe->lengthAllocDescs);
1296 offset = sizeof(struct extendedFileEntry) + UDF_I_LENEATTR(inode);
1297 }
1298
1299 switch (fe->icbTag.fileType)
1300 {
1301 case ICBTAG_FILE_TYPE_DIRECTORY:
1302 {
1303 inode->i_op = &udf_dir_inode_operations;
1304 inode->i_fop = &udf_dir_operations;
1305 inode->i_mode |= S_IFDIR;
1306 inc_nlink(inode);
1307 break;
1308 }
1309 case ICBTAG_FILE_TYPE_REALTIME:
1310 case ICBTAG_FILE_TYPE_REGULAR:
1311 case ICBTAG_FILE_TYPE_UNDEF:
1312 {
1313 if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB)
1314 inode->i_data.a_ops = &udf_adinicb_aops;
1315 else
1316 inode->i_data.a_ops = &udf_aops;
1317 inode->i_op = &udf_file_inode_operations;
1318 inode->i_fop = &udf_file_operations;
1319 inode->i_mode |= S_IFREG;
1320 break;
1321 }
1322 case ICBTAG_FILE_TYPE_BLOCK:
1323 {
1324 inode->i_mode |= S_IFBLK;
1325 break;
1326 }
1327 case ICBTAG_FILE_TYPE_CHAR:
1328 {
1329 inode->i_mode |= S_IFCHR;
1330 break;
1331 }
1332 case ICBTAG_FILE_TYPE_FIFO:
1333 {
1334 init_special_inode(inode, inode->i_mode | S_IFIFO, 0);
1335 break;
1336 }
1337 case ICBTAG_FILE_TYPE_SOCKET:
1338 {
1339 init_special_inode(inode, inode->i_mode | S_IFSOCK, 0);
1340 break;
1341 }
1342 case ICBTAG_FILE_TYPE_SYMLINK:
1343 {
1344 inode->i_data.a_ops = &udf_symlink_aops;
1345 inode->i_op = &page_symlink_inode_operations;
1346 inode->i_mode = S_IFLNK|S_IRWXUGO;
1347 break;
1348 }
1349 default:
1350 {
1351 printk(KERN_ERR "udf: udf_fill_inode(ino %ld) failed unknown file type=%d\n",
1352 inode->i_ino, fe->icbTag.fileType);
1353 make_bad_inode(inode);
1354 return;
1355 }
1356 }
1357 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
1358 {
1359 struct deviceSpec *dsea =
1360 (struct deviceSpec *)
1361 udf_get_extendedattr(inode, 12, 1);
1362
1363 if (dsea)
1364 {
1365 init_special_inode(inode, inode->i_mode, MKDEV(
1366 le32_to_cpu(dsea->majorDeviceIdent),
1367 le32_to_cpu(dsea->minorDeviceIdent)));
1368 /* Developer ID ??? */
1369 }
1370 else
1371 {
1372 make_bad_inode(inode);
1373 }
1374 }
1375 }
1376
1377 static mode_t
1378 udf_convert_permissions(struct fileEntry *fe)
1379 {
1380 mode_t mode;
1381 uint32_t permissions;
1382 uint32_t flags;
1383
1384 permissions = le32_to_cpu(fe->permissions);
1385 flags = le16_to_cpu(fe->icbTag.flags);
1386
1387 mode = (( permissions ) & S_IRWXO) |
1388 (( permissions >> 2 ) & S_IRWXG) |
1389 (( permissions >> 4 ) & S_IRWXU) |
1390 (( flags & ICBTAG_FLAG_SETUID) ? S_ISUID : 0) |
1391 (( flags & ICBTAG_FLAG_SETGID) ? S_ISGID : 0) |
1392 (( flags & ICBTAG_FLAG_STICKY) ? S_ISVTX : 0);
1393
1394 return mode;
1395 }
1396
1397 /*
1398 * udf_write_inode
1399 *
1400 * PURPOSE
1401 * Write out the specified inode.
1402 *
1403 * DESCRIPTION
1404 * This routine is called whenever an inode is synced.
1405 * Currently this routine is just a placeholder.
1406 *
1407 * HISTORY
1408 * July 1, 1997 - Andrew E. Mileski
1409 * Written, tested, and released.
1410 */
1411
1412 int udf_write_inode(struct inode * inode, int sync)
1413 {
1414 int ret;
1415 lock_kernel();
1416 ret = udf_update_inode(inode, sync);
1417 unlock_kernel();
1418 return ret;
1419 }
1420
1421 int udf_sync_inode(struct inode * inode)
1422 {
1423 return udf_update_inode(inode, 1);
1424 }
1425
1426 static int
1427 udf_update_inode(struct inode *inode, int do_sync)
1428 {
1429 struct buffer_head *bh = NULL;
1430 struct fileEntry *fe;
1431 struct extendedFileEntry *efe;
1432 uint32_t udfperms;
1433 uint16_t icbflags;
1434 uint16_t crclen;
1435 int i;
1436 kernel_timestamp cpu_time;
1437 int err = 0;
1438
1439 bh = udf_tread(inode->i_sb,
1440 udf_get_lb_pblock(inode->i_sb, UDF_I_LOCATION(inode), 0));
1441
1442 if (!bh)
1443 {
1444 udf_debug("bread failure\n");
1445 return -EIO;
1446 }
1447
1448 memset(bh->b_data, 0x00, inode->i_sb->s_blocksize);
1449
1450 fe = (struct fileEntry *)bh->b_data;
1451 efe = (struct extendedFileEntry *)bh->b_data;
1452
1453 if (le16_to_cpu(fe->descTag.tagIdent) == TAG_IDENT_USE)
1454 {
1455 struct unallocSpaceEntry *use =
1456 (struct unallocSpaceEntry *)bh->b_data;
1457
1458 use->lengthAllocDescs = cpu_to_le32(UDF_I_LENALLOC(inode));
1459 memcpy(bh->b_data + sizeof(struct unallocSpaceEntry), UDF_I_DATA(inode), inode->i_sb->s_blocksize - sizeof(struct unallocSpaceEntry));
1460 crclen = sizeof(struct unallocSpaceEntry) + UDF_I_LENALLOC(inode) -
1461 sizeof(tag);
1462 use->descTag.tagLocation = cpu_to_le32(UDF_I_LOCATION(inode).logicalBlockNum);
1463 use->descTag.descCRCLength = cpu_to_le16(crclen);
1464 use->descTag.descCRC = cpu_to_le16(udf_crc((char *)use + sizeof(tag), crclen, 0));
1465
1466 use->descTag.tagChecksum = 0;
1467 for (i=0; i<16; i++)
1468 if (i != 4)
1469 use->descTag.tagChecksum += ((uint8_t *)&(use->descTag))[i];
1470
1471 mark_buffer_dirty(bh);
1472 brelse(bh);
1473 return err;
1474 }
1475
1476 if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_UID_FORGET))
1477 fe->uid = cpu_to_le32(-1);
1478 else fe->uid = cpu_to_le32(inode->i_uid);
1479
1480 if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_GID_FORGET))
1481 fe->gid = cpu_to_le32(-1);
1482 else fe->gid = cpu_to_le32(inode->i_gid);
1483
1484 udfperms = ((inode->i_mode & S_IRWXO) ) |
1485 ((inode->i_mode & S_IRWXG) << 2) |
1486 ((inode->i_mode & S_IRWXU) << 4);
1487
1488 udfperms |= (le32_to_cpu(fe->permissions) &
1489 (FE_PERM_O_DELETE | FE_PERM_O_CHATTR |
1490 FE_PERM_G_DELETE | FE_PERM_G_CHATTR |
1491 FE_PERM_U_DELETE | FE_PERM_U_CHATTR));
1492 fe->permissions = cpu_to_le32(udfperms);
1493
1494 if (S_ISDIR(inode->i_mode))
1495 fe->fileLinkCount = cpu_to_le16(inode->i_nlink - 1);
1496 else
1497 fe->fileLinkCount = cpu_to_le16(inode->i_nlink);
1498
1499 fe->informationLength = cpu_to_le64(inode->i_size);
1500
1501 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
1502 {
1503 regid *eid;
1504 struct deviceSpec *dsea =
1505 (struct deviceSpec *)
1506 udf_get_extendedattr(inode, 12, 1);
1507
1508 if (!dsea)
1509 {
1510 dsea = (struct deviceSpec *)
1511 udf_add_extendedattr(inode,
1512 sizeof(struct deviceSpec) +
1513 sizeof(regid), 12, 0x3);
1514 dsea->attrType = cpu_to_le32(12);
1515 dsea->attrSubtype = 1;
1516 dsea->attrLength = cpu_to_le32(sizeof(struct deviceSpec) +
1517 sizeof(regid));
1518 dsea->impUseLength = cpu_to_le32(sizeof(regid));
1519 }
1520 eid = (regid *)dsea->impUse;
1521 memset(eid, 0, sizeof(regid));
1522 strcpy(eid->ident, UDF_ID_DEVELOPER);
1523 eid->identSuffix[0] = UDF_OS_CLASS_UNIX;
1524 eid->identSuffix[1] = UDF_OS_ID_LINUX;
1525 dsea->majorDeviceIdent = cpu_to_le32(imajor(inode));
1526 dsea->minorDeviceIdent = cpu_to_le32(iminor(inode));
1527 }
1528
1529 if (UDF_I_EFE(inode) == 0)
1530 {
1531 memcpy(bh->b_data + sizeof(struct fileEntry), UDF_I_DATA(inode), inode->i_sb->s_blocksize - sizeof(struct fileEntry));
1532 fe->logicalBlocksRecorded = cpu_to_le64(
1533 (inode->i_blocks + (1 << (inode->i_sb->s_blocksize_bits - 9)) - 1) >>
1534 (inode->i_sb->s_blocksize_bits - 9));
1535
1536 if (udf_time_to_stamp(&cpu_time, inode->i_atime))
1537 fe->accessTime = cpu_to_lets(cpu_time);
1538 if (udf_time_to_stamp(&cpu_time, inode->i_mtime))
1539 fe->modificationTime = cpu_to_lets(cpu_time);
1540 if (udf_time_to_stamp(&cpu_time, inode->i_ctime))
1541 fe->attrTime = cpu_to_lets(cpu_time);
1542 memset(&(fe->impIdent), 0, sizeof(regid));
1543 strcpy(fe->impIdent.ident, UDF_ID_DEVELOPER);
1544 fe->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX;
1545 fe->impIdent.identSuffix[1] = UDF_OS_ID_LINUX;
1546 fe->uniqueID = cpu_to_le64(UDF_I_UNIQUE(inode));
1547 fe->lengthExtendedAttr = cpu_to_le32(UDF_I_LENEATTR(inode));
1548 fe->lengthAllocDescs = cpu_to_le32(UDF_I_LENALLOC(inode));
1549 fe->descTag.tagIdent = cpu_to_le16(TAG_IDENT_FE);
1550 crclen = sizeof(struct fileEntry);
1551 }
1552 else
1553 {
1554 memcpy(bh->b_data + sizeof(struct extendedFileEntry), UDF_I_DATA(inode), inode->i_sb->s_blocksize - sizeof(struct extendedFileEntry));
1555 efe->objectSize = cpu_to_le64(inode->i_size);
1556 efe->logicalBlocksRecorded = cpu_to_le64(
1557 (inode->i_blocks + (1 << (inode->i_sb->s_blocksize_bits - 9)) - 1) >>
1558 (inode->i_sb->s_blocksize_bits - 9));
1559
1560 if (UDF_I_CRTIME(inode).tv_sec > inode->i_atime.tv_sec ||
1561 (UDF_I_CRTIME(inode).tv_sec == inode->i_atime.tv_sec &&
1562 UDF_I_CRTIME(inode).tv_nsec > inode->i_atime.tv_nsec))
1563 {
1564 UDF_I_CRTIME(inode) = inode->i_atime;
1565 }
1566 if (UDF_I_CRTIME(inode).tv_sec > inode->i_mtime.tv_sec ||
1567 (UDF_I_CRTIME(inode).tv_sec == inode->i_mtime.tv_sec &&
1568 UDF_I_CRTIME(inode).tv_nsec > inode->i_mtime.tv_nsec))
1569 {
1570 UDF_I_CRTIME(inode) = inode->i_mtime;
1571 }
1572 if (UDF_I_CRTIME(inode).tv_sec > inode->i_ctime.tv_sec ||
1573 (UDF_I_CRTIME(inode).tv_sec == inode->i_ctime.tv_sec &&
1574 UDF_I_CRTIME(inode).tv_nsec > inode->i_ctime.tv_nsec))
1575 {
1576 UDF_I_CRTIME(inode) = inode->i_ctime;
1577 }
1578
1579 if (udf_time_to_stamp(&cpu_time, inode->i_atime))
1580 efe->accessTime = cpu_to_lets(cpu_time);
1581 if (udf_time_to_stamp(&cpu_time, inode->i_mtime))
1582 efe->modificationTime = cpu_to_lets(cpu_time);
1583 if (udf_time_to_stamp(&cpu_time, UDF_I_CRTIME(inode)))
1584 efe->createTime = cpu_to_lets(cpu_time);
1585 if (udf_time_to_stamp(&cpu_time, inode->i_ctime))
1586 efe->attrTime = cpu_to_lets(cpu_time);
1587
1588 memset(&(efe->impIdent), 0, sizeof(regid));
1589 strcpy(efe->impIdent.ident, UDF_ID_DEVELOPER);
1590 efe->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX;
1591 efe->impIdent.identSuffix[1] = UDF_OS_ID_LINUX;
1592 efe->uniqueID = cpu_to_le64(UDF_I_UNIQUE(inode));
1593 efe->lengthExtendedAttr = cpu_to_le32(UDF_I_LENEATTR(inode));
1594 efe->lengthAllocDescs = cpu_to_le32(UDF_I_LENALLOC(inode));
1595 efe->descTag.tagIdent = cpu_to_le16(TAG_IDENT_EFE);
1596 crclen = sizeof(struct extendedFileEntry);
1597 }
1598 if (UDF_I_STRAT4096(inode))
1599 {
1600 fe->icbTag.strategyType = cpu_to_le16(4096);
1601 fe->icbTag.strategyParameter = cpu_to_le16(1);
1602 fe->icbTag.numEntries = cpu_to_le16(2);
1603 }
1604 else
1605 {
1606 fe->icbTag.strategyType = cpu_to_le16(4);
1607 fe->icbTag.numEntries = cpu_to_le16(1);
1608 }
1609
1610 if (S_ISDIR(inode->i_mode))
1611 fe->icbTag.fileType = ICBTAG_FILE_TYPE_DIRECTORY;
1612 else if (S_ISREG(inode->i_mode))
1613 fe->icbTag.fileType = ICBTAG_FILE_TYPE_REGULAR;
1614 else if (S_ISLNK(inode->i_mode))
1615 fe->icbTag.fileType = ICBTAG_FILE_TYPE_SYMLINK;
1616 else if (S_ISBLK(inode->i_mode))
1617 fe->icbTag.fileType = ICBTAG_FILE_TYPE_BLOCK;
1618 else if (S_ISCHR(inode->i_mode))
1619 fe->icbTag.fileType = ICBTAG_FILE_TYPE_CHAR;
1620 else if (S_ISFIFO(inode->i_mode))
1621 fe->icbTag.fileType = ICBTAG_FILE_TYPE_FIFO;
1622 else if (S_ISSOCK(inode->i_mode))
1623 fe->icbTag.fileType = ICBTAG_FILE_TYPE_SOCKET;
1624
1625 icbflags = UDF_I_ALLOCTYPE(inode) |
1626 ((inode->i_mode & S_ISUID) ? ICBTAG_FLAG_SETUID : 0) |
1627 ((inode->i_mode & S_ISGID) ? ICBTAG_FLAG_SETGID : 0) |
1628 ((inode->i_mode & S_ISVTX) ? ICBTAG_FLAG_STICKY : 0) |
1629 (le16_to_cpu(fe->icbTag.flags) &
1630 ~(ICBTAG_FLAG_AD_MASK | ICBTAG_FLAG_SETUID |
1631 ICBTAG_FLAG_SETGID | ICBTAG_FLAG_STICKY));
1632
1633 fe->icbTag.flags = cpu_to_le16(icbflags);
1634 if (UDF_SB_UDFREV(inode->i_sb) >= 0x0200)
1635 fe->descTag.descVersion = cpu_to_le16(3);
1636 else
1637 fe->descTag.descVersion = cpu_to_le16(2);
1638 fe->descTag.tagSerialNum = cpu_to_le16(UDF_SB_SERIALNUM(inode->i_sb));
1639 fe->descTag.tagLocation = cpu_to_le32(UDF_I_LOCATION(inode).logicalBlockNum);
1640 crclen += UDF_I_LENEATTR(inode) + UDF_I_LENALLOC(inode) - sizeof(tag);
1641 fe->descTag.descCRCLength = cpu_to_le16(crclen);
1642 fe->descTag.descCRC = cpu_to_le16(udf_crc((char *)fe + sizeof(tag), crclen, 0));
1643
1644 fe->descTag.tagChecksum = 0;
1645 for (i=0; i<16; i++)
1646 if (i != 4)
1647 fe->descTag.tagChecksum += ((uint8_t *)&(fe->descTag))[i];
1648
1649 /* write the data blocks */
1650 mark_buffer_dirty(bh);
1651 if (do_sync)
1652 {
1653 sync_dirty_buffer(bh);
1654 if (buffer_req(bh) && !buffer_uptodate(bh))
1655 {
1656 printk("IO error syncing udf inode [%s:%08lx]\n",
1657 inode->i_sb->s_id, inode->i_ino);
1658 err = -EIO;
1659 }
1660 }
1661 brelse(bh);
1662 return err;
1663 }
1664
1665 struct inode *
1666 udf_iget(struct super_block *sb, kernel_lb_addr ino)
1667 {
1668 unsigned long block = udf_get_lb_pblock(sb, ino, 0);
1669 struct inode *inode = iget_locked(sb, block);
1670
1671 if (!inode)
1672 return NULL;
1673
1674 if (inode->i_state & I_NEW) {
1675 memcpy(&UDF_I_LOCATION(inode), &ino, sizeof(kernel_lb_addr));
1676 __udf_read_inode(inode);
1677 unlock_new_inode(inode);
1678 }
1679
1680 if (is_bad_inode(inode))
1681 goto out_iput;
1682
1683 if (ino.logicalBlockNum >= UDF_SB_PARTLEN(sb, ino.partitionReferenceNum)) {
1684 udf_debug("block=%d, partition=%d out of range\n",
1685 ino.logicalBlockNum, ino.partitionReferenceNum);
1686 make_bad_inode(inode);
1687 goto out_iput;
1688 }
1689
1690 return inode;
1691
1692 out_iput:
1693 iput(inode);
1694 return NULL;
1695 }
1696
1697 int8_t udf_add_aext(struct inode *inode, struct extent_position *epos,
1698 kernel_lb_addr eloc, uint32_t elen, int inc)
1699 {
1700 int adsize;
1701 short_ad *sad = NULL;
1702 long_ad *lad = NULL;
1703 struct allocExtDesc *aed;
1704 int8_t etype;
1705 uint8_t *ptr;
1706
1707 if (!epos->bh)
1708 ptr = UDF_I_DATA(inode) + epos->offset - udf_file_entry_alloc_offset(inode) + UDF_I_LENEATTR(inode);
1709 else
1710 ptr = epos->bh->b_data + epos->offset;
1711
1712 if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_SHORT)
1713 adsize = sizeof(short_ad);
1714 else if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_LONG)
1715 adsize = sizeof(long_ad);
1716 else
1717 return -1;
1718
1719 if (epos->offset + (2 * adsize) > inode->i_sb->s_blocksize)
1720 {
1721 char *sptr, *dptr;
1722 struct buffer_head *nbh;
1723 int err, loffset;
1724 kernel_lb_addr obloc = epos->block;
1725
1726 if (!(epos->block.logicalBlockNum = udf_new_block(inode->i_sb, NULL,
1727 obloc.partitionReferenceNum, obloc.logicalBlockNum, &err)))
1728 {
1729 return -1;
1730 }
1731 if (!(nbh = udf_tgetblk(inode->i_sb, udf_get_lb_pblock(inode->i_sb,
1732 epos->block, 0))))
1733 {
1734 return -1;
1735 }
1736 lock_buffer(nbh);
1737 memset(nbh->b_data, 0x00, inode->i_sb->s_blocksize);
1738 set_buffer_uptodate(nbh);
1739 unlock_buffer(nbh);
1740 mark_buffer_dirty_inode(nbh, inode);
1741
1742 aed = (struct allocExtDesc *)(nbh->b_data);
1743 if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT))
1744 aed->previousAllocExtLocation = cpu_to_le32(obloc.logicalBlockNum);
1745 if (epos->offset + adsize > inode->i_sb->s_blocksize)
1746 {
1747 loffset = epos->offset;
1748 aed->lengthAllocDescs = cpu_to_le32(adsize);
1749 sptr = ptr - adsize;
1750 dptr = nbh->b_data + sizeof(struct allocExtDesc);
1751 memcpy(dptr, sptr, adsize);
1752 epos->offset = sizeof(struct allocExtDesc) + adsize;
1753 }
1754 else
1755 {
1756 loffset = epos->offset + adsize;
1757 aed->lengthAllocDescs = cpu_to_le32(0);
1758 sptr = ptr;
1759 epos->offset = sizeof(struct allocExtDesc);
1760
1761 if (epos->bh)
1762 {
1763 aed = (struct allocExtDesc *)epos->bh->b_data;
1764 aed->lengthAllocDescs =
1765 cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) + adsize);
1766 }
1767 else
1768 {
1769 UDF_I_LENALLOC(inode) += adsize;
1770 mark_inode_dirty(inode);
1771 }
1772 }
1773 if (UDF_SB_UDFREV(inode->i_sb) >= 0x0200)
1774 udf_new_tag(nbh->b_data, TAG_IDENT_AED, 3, 1,
1775 epos->block.logicalBlockNum, sizeof(tag));
1776 else
1777 udf_new_tag(nbh->b_data, TAG_IDENT_AED, 2, 1,
1778 epos->block.logicalBlockNum, sizeof(tag));
1779 switch (UDF_I_ALLOCTYPE(inode))
1780 {
1781 case ICBTAG_FLAG_AD_SHORT:
1782 {
1783 sad = (short_ad *)sptr;
1784 sad->extLength = cpu_to_le32(
1785 EXT_NEXT_EXTENT_ALLOCDECS |
1786 inode->i_sb->s_blocksize);
1787 sad->extPosition = cpu_to_le32(epos->block.logicalBlockNum);
1788 break;
1789 }
1790 case ICBTAG_FLAG_AD_LONG:
1791 {
1792 lad = (long_ad *)sptr;
1793 lad->extLength = cpu_to_le32(
1794 EXT_NEXT_EXTENT_ALLOCDECS |
1795 inode->i_sb->s_blocksize);
1796 lad->extLocation = cpu_to_lelb(epos->block);
1797 memset(lad->impUse, 0x00, sizeof(lad->impUse));
1798 break;
1799 }
1800 }
1801 if (epos->bh)
1802 {
1803 if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) || UDF_SB_UDFREV(inode->i_sb) >= 0x0201)
1804 udf_update_tag(epos->bh->b_data, loffset);
1805 else
1806 udf_update_tag(epos->bh->b_data, sizeof(struct allocExtDesc));
1807 mark_buffer_dirty_inode(epos->bh, inode);
1808 brelse(epos->bh);
1809 }
1810 else
1811 mark_inode_dirty(inode);
1812 epos->bh = nbh;
1813 }
1814
1815 etype = udf_write_aext(inode, epos, eloc, elen, inc);
1816
1817 if (!epos->bh)
1818 {
1819 UDF_I_LENALLOC(inode) += adsize;
1820 mark_inode_dirty(inode);
1821 }
1822 else
1823 {
1824 aed = (struct allocExtDesc *)epos->bh->b_data;
1825 aed->lengthAllocDescs =
1826 cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) + adsize);
1827 if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) || UDF_SB_UDFREV(inode->i_sb) >= 0x0201)
1828 udf_update_tag(epos->bh->b_data, epos->offset + (inc ? 0 : adsize));
1829 else
1830 udf_update_tag(epos->bh->b_data, sizeof(struct allocExtDesc));
1831 mark_buffer_dirty_inode(epos->bh, inode);
1832 }
1833
1834 return etype;
1835 }
1836
1837 int8_t udf_write_aext(struct inode *inode, struct extent_position *epos,
1838 kernel_lb_addr eloc, uint32_t elen, int inc)
1839 {
1840 int adsize;
1841 uint8_t *ptr;
1842
1843 if (!epos->bh)
1844 ptr = UDF_I_DATA(inode) + epos->offset - udf_file_entry_alloc_offset(inode) + UDF_I_LENEATTR(inode);
1845 else
1846 ptr = epos->bh->b_data + epos->offset;
1847
1848 switch (UDF_I_ALLOCTYPE(inode))
1849 {
1850 case ICBTAG_FLAG_AD_SHORT:
1851 {
1852 short_ad *sad = (short_ad *)ptr;
1853 sad->extLength = cpu_to_le32(elen);
1854 sad->extPosition = cpu_to_le32(eloc.logicalBlockNum);
1855 adsize = sizeof(short_ad);
1856 break;
1857 }
1858 case ICBTAG_FLAG_AD_LONG:
1859 {
1860 long_ad *lad = (long_ad *)ptr;
1861 lad->extLength = cpu_to_le32(elen);
1862 lad->extLocation = cpu_to_lelb(eloc);
1863 memset(lad->impUse, 0x00, sizeof(lad->impUse));
1864 adsize = sizeof(long_ad);
1865 break;
1866 }
1867 default:
1868 return -1;
1869 }
1870
1871 if (epos->bh)
1872 {
1873 if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) || UDF_SB_UDFREV(inode->i_sb) >= 0x0201)
1874 {
1875 struct allocExtDesc *aed = (struct allocExtDesc *)epos->bh->b_data;
1876 udf_update_tag(epos->bh->b_data,
1877 le32_to_cpu(aed->lengthAllocDescs) + sizeof(struct allocExtDesc));
1878 }
1879 mark_buffer_dirty_inode(epos->bh, inode);
1880 }
1881 else
1882 mark_inode_dirty(inode);
1883
1884 if (inc)
1885 epos->offset += adsize;
1886 return (elen >> 30);
1887 }
1888
1889 int8_t udf_next_aext(struct inode *inode, struct extent_position *epos,
1890 kernel_lb_addr *eloc, uint32_t *elen, int inc)
1891 {
1892 int8_t etype;
1893
1894 while ((etype = udf_current_aext(inode, epos, eloc, elen, inc)) ==
1895 (EXT_NEXT_EXTENT_ALLOCDECS >> 30))
1896 {
1897 epos->block = *eloc;
1898 epos->offset = sizeof(struct allocExtDesc);
1899 brelse(epos->bh);
1900 if (!(epos->bh = udf_tread(inode->i_sb, udf_get_lb_pblock(inode->i_sb, epos->block, 0))))
1901 {
1902 udf_debug("reading block %d failed!\n",
1903 udf_get_lb_pblock(inode->i_sb, epos->block, 0));
1904 return -1;
1905 }
1906 }
1907
1908 return etype;
1909 }
1910
1911 int8_t udf_current_aext(struct inode *inode, struct extent_position *epos,
1912 kernel_lb_addr *eloc, uint32_t *elen, int inc)
1913 {
1914 int alen;
1915 int8_t etype;
1916 uint8_t *ptr;
1917
1918 if (!epos->bh)
1919 {
1920 if (!epos->offset)
1921 epos->offset = udf_file_entry_alloc_offset(inode);
1922 ptr = UDF_I_DATA(inode) + epos->offset - udf_file_entry_alloc_offset(inode) + UDF_I_LENEATTR(inode);
1923 alen = udf_file_entry_alloc_offset(inode) + UDF_I_LENALLOC(inode);
1924 }
1925 else
1926 {
1927 if (!epos->offset)
1928 epos->offset = sizeof(struct allocExtDesc);
1929 ptr = epos->bh->b_data + epos->offset;
1930 alen = sizeof(struct allocExtDesc) + le32_to_cpu(((struct allocExtDesc *)epos->bh->b_data)->lengthAllocDescs);
1931 }
1932
1933 switch (UDF_I_ALLOCTYPE(inode))
1934 {
1935 case ICBTAG_FLAG_AD_SHORT:
1936 {
1937 short_ad *sad;
1938
1939 if (!(sad = udf_get_fileshortad(ptr, alen, &epos->offset, inc)))
1940 return -1;
1941
1942 etype = le32_to_cpu(sad->extLength) >> 30;
1943 eloc->logicalBlockNum = le32_to_cpu(sad->extPosition);
1944 eloc->partitionReferenceNum = UDF_I_LOCATION(inode).partitionReferenceNum;
1945 *elen = le32_to_cpu(sad->extLength) & UDF_EXTENT_LENGTH_MASK;
1946 break;
1947 }
1948 case ICBTAG_FLAG_AD_LONG:
1949 {
1950 long_ad *lad;
1951
1952 if (!(lad = udf_get_filelongad(ptr, alen, &epos->offset, inc)))
1953 return -1;
1954
1955 etype = le32_to_cpu(lad->extLength) >> 30;
1956 *eloc = lelb_to_cpu(lad->extLocation);
1957 *elen = le32_to_cpu(lad->extLength) & UDF_EXTENT_LENGTH_MASK;
1958 break;
1959 }
1960 default:
1961 {
1962 udf_debug("alloc_type = %d unsupported\n", UDF_I_ALLOCTYPE(inode));
1963 return -1;
1964 }
1965 }
1966
1967 return etype;
1968 }
1969
1970 static int8_t
1971 udf_insert_aext(struct inode *inode, struct extent_position epos,
1972 kernel_lb_addr neloc, uint32_t nelen)
1973 {
1974 kernel_lb_addr oeloc;
1975 uint32_t oelen;
1976 int8_t etype;
1977
1978 if (epos.bh)
1979 get_bh(epos.bh);
1980
1981 while ((etype = udf_next_aext(inode, &epos, &oeloc, &oelen, 0)) != -1)
1982 {
1983 udf_write_aext(inode, &epos, neloc, nelen, 1);
1984
1985 neloc = oeloc;
1986 nelen = (etype << 30) | oelen;
1987 }
1988 udf_add_aext(inode, &epos, neloc, nelen, 1);
1989 brelse(epos.bh);
1990 return (nelen >> 30);
1991 }
1992
1993 int8_t udf_delete_aext(struct inode *inode, struct extent_position epos,
1994 kernel_lb_addr eloc, uint32_t elen)
1995 {
1996 struct extent_position oepos;
1997 int adsize;
1998 int8_t etype;
1999 struct allocExtDesc *aed;
2000
2001 if (epos.bh)
2002 {
2003 get_bh(epos.bh);
2004 get_bh(epos.bh);
2005 }
2006
2007 if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_SHORT)
2008 adsize = sizeof(short_ad);
2009 else if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_LONG)
2010 adsize = sizeof(long_ad);
2011 else
2012 adsize = 0;
2013
2014 oepos = epos;
2015 if (udf_next_aext(inode, &epos, &eloc, &elen, 1) == -1)
2016 return -1;
2017
2018 while ((etype = udf_next_aext(inode, &epos, &eloc, &elen, 1)) != -1)
2019 {
2020 udf_write_aext(inode, &oepos, eloc, (etype << 30) | elen, 1);
2021 if (oepos.bh != epos.bh)
2022 {
2023 oepos.block = epos.block;
2024 brelse(oepos.bh);
2025 get_bh(epos.bh);
2026 oepos.bh = epos.bh;
2027 oepos.offset = epos.offset - adsize;
2028 }
2029 }
2030 memset(&eloc, 0x00, sizeof(kernel_lb_addr));
2031 elen = 0;
2032
2033 if (epos.bh != oepos.bh)
2034 {
2035 udf_free_blocks(inode->i_sb, inode, epos.block, 0, 1);
2036 udf_write_aext(inode, &oepos, eloc, elen, 1);
2037 udf_write_aext(inode, &oepos, eloc, elen, 1);
2038 if (!oepos.bh)
2039 {
2040 UDF_I_LENALLOC(inode) -= (adsize * 2);
2041 mark_inode_dirty(inode);
2042 }
2043 else
2044 {
2045 aed = (struct allocExtDesc *)oepos.bh->b_data;
2046 aed->lengthAllocDescs =
2047 cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) - (2*adsize));
2048 if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) || UDF_SB_UDFREV(inode->i_sb) >= 0x0201)
2049 udf_update_tag(oepos.bh->b_data, oepos.offset - (2*adsize));
2050 else
2051 udf_update_tag(oepos.bh->b_data, sizeof(struct allocExtDesc));
2052 mark_buffer_dirty_inode(oepos.bh, inode);
2053 }
2054 }
2055 else
2056 {
2057 udf_write_aext(inode, &oepos, eloc, elen, 1);
2058 if (!oepos.bh)
2059 {
2060 UDF_I_LENALLOC(inode) -= adsize;
2061 mark_inode_dirty(inode);
2062 }
2063 else
2064 {
2065 aed = (struct allocExtDesc *)oepos.bh->b_data;
2066 aed->lengthAllocDescs =
2067 cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) - adsize);
2068 if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) || UDF_SB_UDFREV(inode->i_sb) >= 0x0201)
2069 udf_update_tag(oepos.bh->b_data, epos.offset - adsize);
2070 else
2071 udf_update_tag(oepos.bh->b_data, sizeof(struct allocExtDesc));
2072 mark_buffer_dirty_inode(oepos.bh, inode);
2073 }
2074 }
2075
2076 brelse(epos.bh);
2077 brelse(oepos.bh);
2078 return (elen >> 30);
2079 }
2080
2081 int8_t inode_bmap(struct inode *inode, sector_t block, struct extent_position *pos,
2082 kernel_lb_addr *eloc, uint32_t *elen, sector_t *offset)
2083 {
2084 loff_t lbcount = 0, bcount = (loff_t)block << inode->i_sb->s_blocksize_bits;
2085 int8_t etype;
2086
2087 if (block < 0)
2088 {
2089 printk(KERN_ERR "udf: inode_bmap: block < 0\n");
2090 return -1;
2091 }
2092
2093 pos->offset = 0;
2094 pos->block = UDF_I_LOCATION(inode);
2095 pos->bh = NULL;
2096 *elen = 0;
2097
2098 do
2099 {
2100 if ((etype = udf_next_aext(inode, pos, eloc, elen, 1)) == -1)
2101 {
2102 *offset = (bcount - lbcount) >> inode->i_sb->s_blocksize_bits;
2103 UDF_I_LENEXTENTS(inode) = lbcount;
2104 return -1;
2105 }
2106 lbcount += *elen;
2107 } while (lbcount <= bcount);
2108
2109 *offset = (bcount + *elen - lbcount) >> inode->i_sb->s_blocksize_bits;
2110
2111 return etype;
2112 }
2113
2114 long udf_block_map(struct inode *inode, sector_t block)
2115 {
2116 kernel_lb_addr eloc;
2117 uint32_t elen;
2118 sector_t offset;
2119 struct extent_position epos = { NULL, 0, { 0, 0}};
2120 int ret;
2121
2122 lock_kernel();
2123
2124 if (inode_bmap(inode, block, &epos, &eloc, &elen, &offset) == (EXT_RECORDED_ALLOCATED >> 30))
2125 ret = udf_get_lb_pblock(inode->i_sb, eloc, offset);
2126 else
2127 ret = 0;
2128
2129 unlock_kernel();
2130 brelse(epos.bh);
2131
2132 if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_VARCONV))
2133 return udf_fixed_to_variable(ret);
2134 else
2135 return ret;
2136 }
Support for the Chinese Samsung S3C2440 based development boards