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