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