?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PATCH] uml: Remove unused variable
[linux-2.6/mini2440.git] / fs / udf / inode.c
blob605f5111b6d86a100430897877f170c2b59248e7
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 inode->i_blksize = PAGE_SIZE;
920
921 bh = udf_read_ptagged(inode->i_sb, UDF_I_LOCATION(inode), 0, &ident);
922
923 if (!bh)
924 {
925 printk(KERN_ERR "udf: udf_read_inode(ino %ld) failed !bh\n",
926 inode->i_ino);
927 make_bad_inode(inode);
928 return;
929 }
930
931 if (ident != TAG_IDENT_FE && ident != TAG_IDENT_EFE &&
932 ident != TAG_IDENT_USE)
933 {
934 printk(KERN_ERR "udf: udf_read_inode(ino %ld) failed ident=%d\n",
935 inode->i_ino, ident);
936 udf_release_data(bh);
937 make_bad_inode(inode);
938 return;
939 }
940
941 fe = (struct fileEntry *)bh->b_data;
942
943 if (le16_to_cpu(fe->icbTag.strategyType) == 4096)
944 {
945 struct buffer_head *ibh = NULL, *nbh = NULL;
946 struct indirectEntry *ie;
947
948 ibh = udf_read_ptagged(inode->i_sb, UDF_I_LOCATION(inode), 1, &ident);
949 if (ident == TAG_IDENT_IE)
950 {
951 if (ibh)
952 {
953 kernel_lb_addr loc;
954 ie = (struct indirectEntry *)ibh->b_data;
955
956 loc = lelb_to_cpu(ie->indirectICB.extLocation);
957
958 if (ie->indirectICB.extLength &&
959 (nbh = udf_read_ptagged(inode->i_sb, loc, 0, &ident)))
960 {
961 if (ident == TAG_IDENT_FE ||
962 ident == TAG_IDENT_EFE)
963 {
964 memcpy(&UDF_I_LOCATION(inode), &loc, sizeof(kernel_lb_addr));
965 udf_release_data(bh);
966 udf_release_data(ibh);
967 udf_release_data(nbh);
968 __udf_read_inode(inode);
969 return;
970 }
971 else
972 {
973 udf_release_data(nbh);
974 udf_release_data(ibh);
975 }
976 }
977 else
978 udf_release_data(ibh);
979 }
980 }
981 else
982 udf_release_data(ibh);
983 }
984 else if (le16_to_cpu(fe->icbTag.strategyType) != 4)
985 {
986 printk(KERN_ERR "udf: unsupported strategy type: %d\n",
987 le16_to_cpu(fe->icbTag.strategyType));
988 udf_release_data(bh);
989 make_bad_inode(inode);
990 return;
991 }
992 udf_fill_inode(inode, bh);
993 udf_release_data(bh);
994 }
995
996 static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
997 {
998 struct fileEntry *fe;
999 struct extendedFileEntry *efe;
1000 time_t convtime;
1001 long convtime_usec;
1002 int offset;
1003
1004 fe = (struct fileEntry *)bh->b_data;
1005 efe = (struct extendedFileEntry *)bh->b_data;
1006
1007 if (le16_to_cpu(fe->icbTag.strategyType) == 4)
1008 UDF_I_STRAT4096(inode) = 0;
1009 else /* if (le16_to_cpu(fe->icbTag.strategyType) == 4096) */
1010 UDF_I_STRAT4096(inode) = 1;
1011
1012 UDF_I_ALLOCTYPE(inode) = le16_to_cpu(fe->icbTag.flags) & ICBTAG_FLAG_AD_MASK;
1013 UDF_I_UNIQUE(inode) = 0;
1014 UDF_I_LENEATTR(inode) = 0;
1015 UDF_I_LENEXTENTS(inode) = 0;
1016 UDF_I_LENALLOC(inode) = 0;
1017 UDF_I_NEXT_ALLOC_BLOCK(inode) = 0;
1018 UDF_I_NEXT_ALLOC_GOAL(inode) = 0;
1019 if (le16_to_cpu(fe->descTag.tagIdent) == TAG_IDENT_EFE)
1020 {
1021 UDF_I_EFE(inode) = 1;
1022 UDF_I_USE(inode) = 0;
1023 UDF_I_DATA(inode) = kmalloc(inode->i_sb->s_blocksize - sizeof(struct extendedFileEntry), GFP_KERNEL);
1024 memcpy(UDF_I_DATA(inode), bh->b_data + sizeof(struct extendedFileEntry), inode->i_sb->s_blocksize - sizeof(struct extendedFileEntry));
1025 }
1026 else if (le16_to_cpu(fe->descTag.tagIdent) == TAG_IDENT_FE)
1027 {
1028 UDF_I_EFE(inode) = 0;
1029 UDF_I_USE(inode) = 0;
1030 UDF_I_DATA(inode) = kmalloc(inode->i_sb->s_blocksize - sizeof(struct fileEntry), GFP_KERNEL);
1031 memcpy(UDF_I_DATA(inode), bh->b_data + sizeof(struct fileEntry), inode->i_sb->s_blocksize - sizeof(struct fileEntry));
1032 }
1033 else if (le16_to_cpu(fe->descTag.tagIdent) == TAG_IDENT_USE)
1034 {
1035 UDF_I_EFE(inode) = 0;
1036 UDF_I_USE(inode) = 1;
1037 UDF_I_LENALLOC(inode) =
1038 le32_to_cpu(
1039 ((struct unallocSpaceEntry *)bh->b_data)->lengthAllocDescs);
1040 UDF_I_DATA(inode) = kmalloc(inode->i_sb->s_blocksize - sizeof(struct unallocSpaceEntry), GFP_KERNEL);
1041 memcpy(UDF_I_DATA(inode), bh->b_data + sizeof(struct unallocSpaceEntry), inode->i_sb->s_blocksize - sizeof(struct unallocSpaceEntry));
1042 return;
1043 }
1044
1045 inode->i_uid = le32_to_cpu(fe->uid);
1046 if (inode->i_uid == -1 || UDF_QUERY_FLAG(inode->i_sb,
1047 UDF_FLAG_UID_IGNORE))
1048 inode->i_uid = UDF_SB(inode->i_sb)->s_uid;
1049
1050 inode->i_gid = le32_to_cpu(fe->gid);
1051 if (inode->i_gid == -1 || UDF_QUERY_FLAG(inode->i_sb,
1052 UDF_FLAG_GID_IGNORE))
1053 inode->i_gid = UDF_SB(inode->i_sb)->s_gid;
1054
1055 inode->i_nlink = le16_to_cpu(fe->fileLinkCount);
1056 if (!inode->i_nlink)
1057 inode->i_nlink = 1;
1058
1059 inode->i_size = le64_to_cpu(fe->informationLength);
1060 UDF_I_LENEXTENTS(inode) = inode->i_size;
1061
1062 inode->i_mode = udf_convert_permissions(fe);
1063 inode->i_mode &= ~UDF_SB(inode->i_sb)->s_umask;
1064
1065 if (UDF_I_EFE(inode) == 0)
1066 {
1067 inode->i_blocks = le64_to_cpu(fe->logicalBlocksRecorded) <<
1068 (inode->i_sb->s_blocksize_bits - 9);
1069
1070 if ( udf_stamp_to_time(&convtime, &convtime_usec,
1071 lets_to_cpu(fe->accessTime)) )
1072 {
1073 inode->i_atime.tv_sec = convtime;
1074 inode->i_atime.tv_nsec = convtime_usec * 1000;
1075 }
1076 else
1077 {
1078 inode->i_atime = UDF_SB_RECORDTIME(inode->i_sb);
1079 }
1080
1081 if ( udf_stamp_to_time(&convtime, &convtime_usec,
1082 lets_to_cpu(fe->modificationTime)) )
1083 {
1084 inode->i_mtime.tv_sec = convtime;
1085 inode->i_mtime.tv_nsec = convtime_usec * 1000;
1086 }
1087 else
1088 {
1089 inode->i_mtime = UDF_SB_RECORDTIME(inode->i_sb);
1090 }
1091
1092 if ( udf_stamp_to_time(&convtime, &convtime_usec,
1093 lets_to_cpu(fe->attrTime)) )
1094 {
1095 inode->i_ctime.tv_sec = convtime;
1096 inode->i_ctime.tv_nsec = convtime_usec * 1000;
1097 }
1098 else
1099 {
1100 inode->i_ctime = UDF_SB_RECORDTIME(inode->i_sb);
1101 }
1102
1103 UDF_I_UNIQUE(inode) = le64_to_cpu(fe->uniqueID);
1104 UDF_I_LENEATTR(inode) = le32_to_cpu(fe->lengthExtendedAttr);
1105 UDF_I_LENALLOC(inode) = le32_to_cpu(fe->lengthAllocDescs);
1106 offset = sizeof(struct fileEntry) + UDF_I_LENEATTR(inode);
1107 }
1108 else
1109 {
1110 inode->i_blocks = le64_to_cpu(efe->logicalBlocksRecorded) <<
1111 (inode->i_sb->s_blocksize_bits - 9);
1112
1113 if ( udf_stamp_to_time(&convtime, &convtime_usec,
1114 lets_to_cpu(efe->accessTime)) )
1115 {
1116 inode->i_atime.tv_sec = convtime;
1117 inode->i_atime.tv_nsec = convtime_usec * 1000;
1118 }
1119 else
1120 {
1121 inode->i_atime = UDF_SB_RECORDTIME(inode->i_sb);
1122 }
1123
1124 if ( udf_stamp_to_time(&convtime, &convtime_usec,
1125 lets_to_cpu(efe->modificationTime)) )
1126 {
1127 inode->i_mtime.tv_sec = convtime;
1128 inode->i_mtime.tv_nsec = convtime_usec * 1000;
1129 }
1130 else
1131 {
1132 inode->i_mtime = UDF_SB_RECORDTIME(inode->i_sb);
1133 }
1134
1135 if ( udf_stamp_to_time(&convtime, &convtime_usec,
1136 lets_to_cpu(efe->createTime)) )
1137 {
1138 UDF_I_CRTIME(inode).tv_sec = convtime;
1139 UDF_I_CRTIME(inode).tv_nsec = convtime_usec * 1000;
1140 }
1141 else
1142 {
1143 UDF_I_CRTIME(inode) = UDF_SB_RECORDTIME(inode->i_sb);
1144 }
1145
1146 if ( udf_stamp_to_time(&convtime, &convtime_usec,
1147 lets_to_cpu(efe->attrTime)) )
1148 {
1149 inode->i_ctime.tv_sec = convtime;
1150 inode->i_ctime.tv_nsec = convtime_usec * 1000;
1151 }
1152 else
1153 {
1154 inode->i_ctime = UDF_SB_RECORDTIME(inode->i_sb);
1155 }
1156
1157 UDF_I_UNIQUE(inode) = le64_to_cpu(efe->uniqueID);
1158 UDF_I_LENEATTR(inode) = le32_to_cpu(efe->lengthExtendedAttr);
1159 UDF_I_LENALLOC(inode) = le32_to_cpu(efe->lengthAllocDescs);
1160 offset = sizeof(struct extendedFileEntry) + UDF_I_LENEATTR(inode);
1161 }
1162
1163 switch (fe->icbTag.fileType)
1164 {
1165 case ICBTAG_FILE_TYPE_DIRECTORY:
1166 {
1167 inode->i_op = &udf_dir_inode_operations;
1168 inode->i_fop = &udf_dir_operations;
1169 inode->i_mode |= S_IFDIR;
1170 inode->i_nlink ++;
1171 break;
1172 }
1173 case ICBTAG_FILE_TYPE_REALTIME:
1174 case ICBTAG_FILE_TYPE_REGULAR:
1175 case ICBTAG_FILE_TYPE_UNDEF:
1176 {
1177 if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB)
1178 inode->i_data.a_ops = &udf_adinicb_aops;
1179 else
1180 inode->i_data.a_ops = &udf_aops;
1181 inode->i_op = &udf_file_inode_operations;
1182 inode->i_fop = &udf_file_operations;
1183 inode->i_mode |= S_IFREG;
1184 break;
1185 }
1186 case ICBTAG_FILE_TYPE_BLOCK:
1187 {
1188 inode->i_mode |= S_IFBLK;
1189 break;
1190 }
1191 case ICBTAG_FILE_TYPE_CHAR:
1192 {
1193 inode->i_mode |= S_IFCHR;
1194 break;
1195 }
1196 case ICBTAG_FILE_TYPE_FIFO:
1197 {
1198 init_special_inode(inode, inode->i_mode | S_IFIFO, 0);
1199 break;
1200 }
1201 case ICBTAG_FILE_TYPE_SOCKET:
1202 {
1203 init_special_inode(inode, inode->i_mode | S_IFSOCK, 0);
1204 break;
1205 }
1206 case ICBTAG_FILE_TYPE_SYMLINK:
1207 {
1208 inode->i_data.a_ops = &udf_symlink_aops;
1209 inode->i_op = &page_symlink_inode_operations;
1210 inode->i_mode = S_IFLNK|S_IRWXUGO;
1211 break;
1212 }
1213 default:
1214 {
1215 printk(KERN_ERR "udf: udf_fill_inode(ino %ld) failed unknown file type=%d\n",
1216 inode->i_ino, fe->icbTag.fileType);
1217 make_bad_inode(inode);
1218 return;
1219 }
1220 }
1221 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
1222 {
1223 struct deviceSpec *dsea =
1224 (struct deviceSpec *)
1225 udf_get_extendedattr(inode, 12, 1);
1226
1227 if (dsea)
1228 {
1229 init_special_inode(inode, inode->i_mode, MKDEV(
1230 le32_to_cpu(dsea->majorDeviceIdent),
1231 le32_to_cpu(dsea->minorDeviceIdent)));
1232 /* Developer ID ??? */
1233 }
1234 else
1235 {
1236 make_bad_inode(inode);
1237 }
1238 }
1239 }
1240
1241 static mode_t
1242 udf_convert_permissions(struct fileEntry *fe)
1243 {
1244 mode_t mode;
1245 uint32_t permissions;
1246 uint32_t flags;
1247
1248 permissions = le32_to_cpu(fe->permissions);
1249 flags = le16_to_cpu(fe->icbTag.flags);
1250
1251 mode = (( permissions ) & S_IRWXO) |
1252 (( permissions >> 2 ) & S_IRWXG) |
1253 (( permissions >> 4 ) & S_IRWXU) |
1254 (( flags & ICBTAG_FLAG_SETUID) ? S_ISUID : 0) |
1255 (( flags & ICBTAG_FLAG_SETGID) ? S_ISGID : 0) |
1256 (( flags & ICBTAG_FLAG_STICKY) ? S_ISVTX : 0);
1257
1258 return mode;
1259 }
1260
1261 /*
1262 * udf_write_inode
1263 *
1264 * PURPOSE
1265 * Write out the specified inode.
1266 *
1267 * DESCRIPTION
1268 * This routine is called whenever an inode is synced.
1269 * Currently this routine is just a placeholder.
1270 *
1271 * HISTORY
1272 * July 1, 1997 - Andrew E. Mileski
1273 * Written, tested, and released.
1274 */
1275
1276 int udf_write_inode(struct inode * inode, int sync)
1277 {
1278 int ret;
1279 lock_kernel();
1280 ret = udf_update_inode(inode, sync);
1281 unlock_kernel();
1282 return ret;
1283 }
1284
1285 int udf_sync_inode(struct inode * inode)
1286 {
1287 return udf_update_inode(inode, 1);
1288 }
1289
1290 static int
1291 udf_update_inode(struct inode *inode, int do_sync)
1292 {
1293 struct buffer_head *bh = NULL;
1294 struct fileEntry *fe;
1295 struct extendedFileEntry *efe;
1296 uint32_t udfperms;
1297 uint16_t icbflags;
1298 uint16_t crclen;
1299 int i;
1300 kernel_timestamp cpu_time;
1301 int err = 0;
1302
1303 bh = udf_tread(inode->i_sb,
1304 udf_get_lb_pblock(inode->i_sb, UDF_I_LOCATION(inode), 0));
1305
1306 if (!bh)
1307 {
1308 udf_debug("bread failure\n");
1309 return -EIO;
1310 }
1311
1312 memset(bh->b_data, 0x00, inode->i_sb->s_blocksize);
1313
1314 fe = (struct fileEntry *)bh->b_data;
1315 efe = (struct extendedFileEntry *)bh->b_data;
1316
1317 if (le16_to_cpu(fe->descTag.tagIdent) == TAG_IDENT_USE)
1318 {
1319 struct unallocSpaceEntry *use =
1320 (struct unallocSpaceEntry *)bh->b_data;
1321
1322 use->lengthAllocDescs = cpu_to_le32(UDF_I_LENALLOC(inode));
1323 memcpy(bh->b_data + sizeof(struct unallocSpaceEntry), UDF_I_DATA(inode), inode->i_sb->s_blocksize - sizeof(struct unallocSpaceEntry));
1324 crclen = sizeof(struct unallocSpaceEntry) + UDF_I_LENALLOC(inode) -
1325 sizeof(tag);
1326 use->descTag.tagLocation = cpu_to_le32(UDF_I_LOCATION(inode).logicalBlockNum);
1327 use->descTag.descCRCLength = cpu_to_le16(crclen);
1328 use->descTag.descCRC = cpu_to_le16(udf_crc((char *)use + sizeof(tag), crclen, 0));
1329
1330 use->descTag.tagChecksum = 0;
1331 for (i=0; i<16; i++)
1332 if (i != 4)
1333 use->descTag.tagChecksum += ((uint8_t *)&(use->descTag))[i];
1334
1335 mark_buffer_dirty(bh);
1336 udf_release_data(bh);
1337 return err;
1338 }
1339
1340 if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_UID_FORGET))
1341 fe->uid = cpu_to_le32(-1);
1342 else fe->uid = cpu_to_le32(inode->i_uid);
1343
1344 if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_GID_FORGET))
1345 fe->gid = cpu_to_le32(-1);
1346 else fe->gid = cpu_to_le32(inode->i_gid);
1347
1348 udfperms = ((inode->i_mode & S_IRWXO) ) |
1349 ((inode->i_mode & S_IRWXG) << 2) |
1350 ((inode->i_mode & S_IRWXU) << 4);
1351
1352 udfperms |= (le32_to_cpu(fe->permissions) &
1353 (FE_PERM_O_DELETE | FE_PERM_O_CHATTR |
1354 FE_PERM_G_DELETE | FE_PERM_G_CHATTR |
1355 FE_PERM_U_DELETE | FE_PERM_U_CHATTR));
1356 fe->permissions = cpu_to_le32(udfperms);
1357
1358 if (S_ISDIR(inode->i_mode))
1359 fe->fileLinkCount = cpu_to_le16(inode->i_nlink - 1);
1360 else
1361 fe->fileLinkCount = cpu_to_le16(inode->i_nlink);
1362
1363 fe->informationLength = cpu_to_le64(inode->i_size);
1364
1365 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
1366 {
1367 regid *eid;
1368 struct deviceSpec *dsea =
1369 (struct deviceSpec *)
1370 udf_get_extendedattr(inode, 12, 1);
1371
1372 if (!dsea)
1373 {
1374 dsea = (struct deviceSpec *)
1375 udf_add_extendedattr(inode,
1376 sizeof(struct deviceSpec) +
1377 sizeof(regid), 12, 0x3);
1378 dsea->attrType = cpu_to_le32(12);
1379 dsea->attrSubtype = 1;
1380 dsea->attrLength = cpu_to_le32(sizeof(struct deviceSpec) +
1381 sizeof(regid));
1382 dsea->impUseLength = cpu_to_le32(sizeof(regid));
1383 }
1384 eid = (regid *)dsea->impUse;
1385 memset(eid, 0, sizeof(regid));
1386 strcpy(eid->ident, UDF_ID_DEVELOPER);
1387 eid->identSuffix[0] = UDF_OS_CLASS_UNIX;
1388 eid->identSuffix[1] = UDF_OS_ID_LINUX;
1389 dsea->majorDeviceIdent = cpu_to_le32(imajor(inode));
1390 dsea->minorDeviceIdent = cpu_to_le32(iminor(inode));
1391 }
1392
1393 if (UDF_I_EFE(inode) == 0)
1394 {
1395 memcpy(bh->b_data + sizeof(struct fileEntry), UDF_I_DATA(inode), inode->i_sb->s_blocksize - sizeof(struct fileEntry));
1396 fe->logicalBlocksRecorded = cpu_to_le64(
1397 (inode->i_blocks + (1 << (inode->i_sb->s_blocksize_bits - 9)) - 1) >>
1398 (inode->i_sb->s_blocksize_bits - 9));
1399
1400 if (udf_time_to_stamp(&cpu_time, inode->i_atime))
1401 fe->accessTime = cpu_to_lets(cpu_time);
1402 if (udf_time_to_stamp(&cpu_time, inode->i_mtime))
1403 fe->modificationTime = cpu_to_lets(cpu_time);
1404 if (udf_time_to_stamp(&cpu_time, inode->i_ctime))
1405 fe->attrTime = cpu_to_lets(cpu_time);
1406 memset(&(fe->impIdent), 0, sizeof(regid));
1407 strcpy(fe->impIdent.ident, UDF_ID_DEVELOPER);
1408 fe->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX;
1409 fe->impIdent.identSuffix[1] = UDF_OS_ID_LINUX;
1410 fe->uniqueID = cpu_to_le64(UDF_I_UNIQUE(inode));
1411 fe->lengthExtendedAttr = cpu_to_le32(UDF_I_LENEATTR(inode));
1412 fe->lengthAllocDescs = cpu_to_le32(UDF_I_LENALLOC(inode));
1413 fe->descTag.tagIdent = cpu_to_le16(TAG_IDENT_FE);
1414 crclen = sizeof(struct fileEntry);
1415 }
1416 else
1417 {
1418 memcpy(bh->b_data + sizeof(struct extendedFileEntry), UDF_I_DATA(inode), inode->i_sb->s_blocksize - sizeof(struct extendedFileEntry));
1419 efe->objectSize = cpu_to_le64(inode->i_size);
1420 efe->logicalBlocksRecorded = cpu_to_le64(
1421 (inode->i_blocks + (1 << (inode->i_sb->s_blocksize_bits - 9)) - 1) >>
1422 (inode->i_sb->s_blocksize_bits - 9));
1423
1424 if (UDF_I_CRTIME(inode).tv_sec > inode->i_atime.tv_sec ||
1425 (UDF_I_CRTIME(inode).tv_sec == inode->i_atime.tv_sec &&
1426 UDF_I_CRTIME(inode).tv_nsec > inode->i_atime.tv_nsec))
1427 {
1428 UDF_I_CRTIME(inode) = inode->i_atime;
1429 }
1430 if (UDF_I_CRTIME(inode).tv_sec > inode->i_mtime.tv_sec ||
1431 (UDF_I_CRTIME(inode).tv_sec == inode->i_mtime.tv_sec &&
1432 UDF_I_CRTIME(inode).tv_nsec > inode->i_mtime.tv_nsec))
1433 {
1434 UDF_I_CRTIME(inode) = inode->i_mtime;
1435 }
1436 if (UDF_I_CRTIME(inode).tv_sec > inode->i_ctime.tv_sec ||
1437 (UDF_I_CRTIME(inode).tv_sec == inode->i_ctime.tv_sec &&
1438 UDF_I_CRTIME(inode).tv_nsec > inode->i_ctime.tv_nsec))
1439 {
1440 UDF_I_CRTIME(inode) = inode->i_ctime;
1441 }
1442
1443 if (udf_time_to_stamp(&cpu_time, inode->i_atime))
1444 efe->accessTime = cpu_to_lets(cpu_time);
1445 if (udf_time_to_stamp(&cpu_time, inode->i_mtime))
1446 efe->modificationTime = cpu_to_lets(cpu_time);
1447 if (udf_time_to_stamp(&cpu_time, UDF_I_CRTIME(inode)))
1448 efe->createTime = cpu_to_lets(cpu_time);
1449 if (udf_time_to_stamp(&cpu_time, inode->i_ctime))
1450 efe->attrTime = cpu_to_lets(cpu_time);
1451
1452 memset(&(efe->impIdent), 0, sizeof(regid));
1453 strcpy(efe->impIdent.ident, UDF_ID_DEVELOPER);
1454 efe->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX;
1455 efe->impIdent.identSuffix[1] = UDF_OS_ID_LINUX;
1456 efe->uniqueID = cpu_to_le64(UDF_I_UNIQUE(inode));
1457 efe->lengthExtendedAttr = cpu_to_le32(UDF_I_LENEATTR(inode));
1458 efe->lengthAllocDescs = cpu_to_le32(UDF_I_LENALLOC(inode));
1459 efe->descTag.tagIdent = cpu_to_le16(TAG_IDENT_EFE);
1460 crclen = sizeof(struct extendedFileEntry);
1461 }
1462 if (UDF_I_STRAT4096(inode))
1463 {
1464 fe->icbTag.strategyType = cpu_to_le16(4096);
1465 fe->icbTag.strategyParameter = cpu_to_le16(1);
1466 fe->icbTag.numEntries = cpu_to_le16(2);
1467 }
1468 else
1469 {
1470 fe->icbTag.strategyType = cpu_to_le16(4);
1471 fe->icbTag.numEntries = cpu_to_le16(1);
1472 }
1473
1474 if (S_ISDIR(inode->i_mode))
1475 fe->icbTag.fileType = ICBTAG_FILE_TYPE_DIRECTORY;
1476 else if (S_ISREG(inode->i_mode))
1477 fe->icbTag.fileType = ICBTAG_FILE_TYPE_REGULAR;
1478 else if (S_ISLNK(inode->i_mode))
1479 fe->icbTag.fileType = ICBTAG_FILE_TYPE_SYMLINK;
1480 else if (S_ISBLK(inode->i_mode))
1481 fe->icbTag.fileType = ICBTAG_FILE_TYPE_BLOCK;
1482 else if (S_ISCHR(inode->i_mode))
1483 fe->icbTag.fileType = ICBTAG_FILE_TYPE_CHAR;
1484 else if (S_ISFIFO(inode->i_mode))
1485 fe->icbTag.fileType = ICBTAG_FILE_TYPE_FIFO;
1486 else if (S_ISSOCK(inode->i_mode))
1487 fe->icbTag.fileType = ICBTAG_FILE_TYPE_SOCKET;
1488
1489 icbflags = UDF_I_ALLOCTYPE(inode) |
1490 ((inode->i_mode & S_ISUID) ? ICBTAG_FLAG_SETUID : 0) |
1491 ((inode->i_mode & S_ISGID) ? ICBTAG_FLAG_SETGID : 0) |
1492 ((inode->i_mode & S_ISVTX) ? ICBTAG_FLAG_STICKY : 0) |
1493 (le16_to_cpu(fe->icbTag.flags) &
1494 ~(ICBTAG_FLAG_AD_MASK | ICBTAG_FLAG_SETUID |
1495 ICBTAG_FLAG_SETGID | ICBTAG_FLAG_STICKY));
1496
1497 fe->icbTag.flags = cpu_to_le16(icbflags);
1498 if (UDF_SB_UDFREV(inode->i_sb) >= 0x0200)
1499 fe->descTag.descVersion = cpu_to_le16(3);
1500 else
1501 fe->descTag.descVersion = cpu_to_le16(2);
1502 fe->descTag.tagSerialNum = cpu_to_le16(UDF_SB_SERIALNUM(inode->i_sb));
1503 fe->descTag.tagLocation = cpu_to_le32(UDF_I_LOCATION(inode).logicalBlockNum);
1504 crclen += UDF_I_LENEATTR(inode) + UDF_I_LENALLOC(inode) - sizeof(tag);
1505 fe->descTag.descCRCLength = cpu_to_le16(crclen);
1506 fe->descTag.descCRC = cpu_to_le16(udf_crc((char *)fe + sizeof(tag), crclen, 0));
1507
1508 fe->descTag.tagChecksum = 0;
1509 for (i=0; i<16; i++)
1510 if (i != 4)
1511 fe->descTag.tagChecksum += ((uint8_t *)&(fe->descTag))[i];
1512
1513 /* write the data blocks */
1514 mark_buffer_dirty(bh);
1515 if (do_sync)
1516 {
1517 sync_dirty_buffer(bh);
1518 if (buffer_req(bh) && !buffer_uptodate(bh))
1519 {
1520 printk("IO error syncing udf inode [%s:%08lx]\n",
1521 inode->i_sb->s_id, inode->i_ino);
1522 err = -EIO;
1523 }
1524 }
1525 udf_release_data(bh);
1526 return err;
1527 }
1528
1529 struct inode *
1530 udf_iget(struct super_block *sb, kernel_lb_addr ino)
1531 {
1532 unsigned long block = udf_get_lb_pblock(sb, ino, 0);
1533 struct inode *inode = iget_locked(sb, block);
1534
1535 if (!inode)
1536 return NULL;
1537
1538 if (inode->i_state & I_NEW) {
1539 memcpy(&UDF_I_LOCATION(inode), &ino, sizeof(kernel_lb_addr));
1540 __udf_read_inode(inode);
1541 unlock_new_inode(inode);
1542 }
1543
1544 if (is_bad_inode(inode))
1545 goto out_iput;
1546
1547 if (ino.logicalBlockNum >= UDF_SB_PARTLEN(sb, ino.partitionReferenceNum)) {
1548 udf_debug("block=%d, partition=%d out of range\n",
1549 ino.logicalBlockNum, ino.partitionReferenceNum);
1550 make_bad_inode(inode);
1551 goto out_iput;
1552 }
1553
1554 return inode;
1555
1556 out_iput:
1557 iput(inode);
1558 return NULL;
1559 }
1560
1561 int8_t udf_add_aext(struct inode *inode, kernel_lb_addr *bloc, int *extoffset,
1562 kernel_lb_addr eloc, uint32_t elen, struct buffer_head **bh, int inc)
1563 {
1564 int adsize;
1565 short_ad *sad = NULL;
1566 long_ad *lad = NULL;
1567 struct allocExtDesc *aed;
1568 int8_t etype;
1569 uint8_t *ptr;
1570
1571 if (!*bh)
1572 ptr = UDF_I_DATA(inode) + *extoffset - udf_file_entry_alloc_offset(inode) + UDF_I_LENEATTR(inode);
1573 else
1574 ptr = (*bh)->b_data + *extoffset;
1575
1576 if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_SHORT)
1577 adsize = sizeof(short_ad);
1578 else if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_LONG)
1579 adsize = sizeof(long_ad);
1580 else
1581 return -1;
1582
1583 if (*extoffset + (2 * adsize) > inode->i_sb->s_blocksize)
1584 {
1585 char *sptr, *dptr;
1586 struct buffer_head *nbh;
1587 int err, loffset;
1588 kernel_lb_addr obloc = *bloc;
1589
1590 if (!(bloc->logicalBlockNum = udf_new_block(inode->i_sb, NULL,
1591 obloc.partitionReferenceNum, obloc.logicalBlockNum, &err)))
1592 {
1593 return -1;
1594 }
1595 if (!(nbh = udf_tgetblk(inode->i_sb, udf_get_lb_pblock(inode->i_sb,
1596 *bloc, 0))))
1597 {
1598 return -1;
1599 }
1600 lock_buffer(nbh);
1601 memset(nbh->b_data, 0x00, inode->i_sb->s_blocksize);
1602 set_buffer_uptodate(nbh);
1603 unlock_buffer(nbh);
1604 mark_buffer_dirty_inode(nbh, inode);
1605
1606 aed = (struct allocExtDesc *)(nbh->b_data);
1607 if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT))
1608 aed->previousAllocExtLocation = cpu_to_le32(obloc.logicalBlockNum);
1609 if (*extoffset + adsize > inode->i_sb->s_blocksize)
1610 {
1611 loffset = *extoffset;
1612 aed->lengthAllocDescs = cpu_to_le32(adsize);
1613 sptr = ptr - adsize;
1614 dptr = nbh->b_data + sizeof(struct allocExtDesc);
1615 memcpy(dptr, sptr, adsize);
1616 *extoffset = sizeof(struct allocExtDesc) + adsize;
1617 }
1618 else
1619 {
1620 loffset = *extoffset + adsize;
1621 aed->lengthAllocDescs = cpu_to_le32(0);
1622 sptr = ptr;
1623 *extoffset = sizeof(struct allocExtDesc);
1624
1625 if (*bh)
1626 {
1627 aed = (struct allocExtDesc *)(*bh)->b_data;
1628 aed->lengthAllocDescs =
1629 cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) + adsize);
1630 }
1631 else
1632 {
1633 UDF_I_LENALLOC(inode) += adsize;
1634 mark_inode_dirty(inode);
1635 }
1636 }
1637 if (UDF_SB_UDFREV(inode->i_sb) >= 0x0200)
1638 udf_new_tag(nbh->b_data, TAG_IDENT_AED, 3, 1,
1639 bloc->logicalBlockNum, sizeof(tag));
1640 else
1641 udf_new_tag(nbh->b_data, TAG_IDENT_AED, 2, 1,
1642 bloc->logicalBlockNum, sizeof(tag));
1643 switch (UDF_I_ALLOCTYPE(inode))
1644 {
1645 case ICBTAG_FLAG_AD_SHORT:
1646 {
1647 sad = (short_ad *)sptr;
1648 sad->extLength = cpu_to_le32(
1649 EXT_NEXT_EXTENT_ALLOCDECS |
1650 inode->i_sb->s_blocksize);
1651 sad->extPosition = cpu_to_le32(bloc->logicalBlockNum);
1652 break;
1653 }
1654 case ICBTAG_FLAG_AD_LONG:
1655 {
1656 lad = (long_ad *)sptr;
1657 lad->extLength = cpu_to_le32(
1658 EXT_NEXT_EXTENT_ALLOCDECS |
1659 inode->i_sb->s_blocksize);
1660 lad->extLocation = cpu_to_lelb(*bloc);
1661 memset(lad->impUse, 0x00, sizeof(lad->impUse));
1662 break;
1663 }
1664 }
1665 if (*bh)
1666 {
1667 if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) || UDF_SB_UDFREV(inode->i_sb) >= 0x0201)
1668 udf_update_tag((*bh)->b_data, loffset);
1669 else
1670 udf_update_tag((*bh)->b_data, sizeof(struct allocExtDesc));
1671 mark_buffer_dirty_inode(*bh, inode);
1672 udf_release_data(*bh);
1673 }
1674 else
1675 mark_inode_dirty(inode);
1676 *bh = nbh;
1677 }
1678
1679 etype = udf_write_aext(inode, *bloc, extoffset, eloc, elen, *bh, inc);
1680
1681 if (!*bh)
1682 {
1683 UDF_I_LENALLOC(inode) += adsize;
1684 mark_inode_dirty(inode);
1685 }
1686 else
1687 {
1688 aed = (struct allocExtDesc *)(*bh)->b_data;
1689 aed->lengthAllocDescs =
1690 cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) + adsize);
1691 if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) || UDF_SB_UDFREV(inode->i_sb) >= 0x0201)
1692 udf_update_tag((*bh)->b_data, *extoffset + (inc ? 0 : adsize));
1693 else
1694 udf_update_tag((*bh)->b_data, sizeof(struct allocExtDesc));
1695 mark_buffer_dirty_inode(*bh, inode);
1696 }
1697
1698 return etype;
1699 }
1700
1701 int8_t udf_write_aext(struct inode *inode, kernel_lb_addr bloc, int *extoffset,
1702 kernel_lb_addr eloc, uint32_t elen, struct buffer_head *bh, int inc)
1703 {
1704 int adsize;
1705 uint8_t *ptr;
1706
1707 if (!bh)
1708 ptr = UDF_I_DATA(inode) + *extoffset - udf_file_entry_alloc_offset(inode) + UDF_I_LENEATTR(inode);
1709 else
1710 {
1711 ptr = bh->b_data + *extoffset;
1712 atomic_inc(&bh->b_count);
1713 }
1714
1715 switch (UDF_I_ALLOCTYPE(inode))
1716 {
1717 case ICBTAG_FLAG_AD_SHORT:
1718 {
1719 short_ad *sad = (short_ad *)ptr;
1720 sad->extLength = cpu_to_le32(elen);
1721 sad->extPosition = cpu_to_le32(eloc.logicalBlockNum);
1722 adsize = sizeof(short_ad);
1723 break;
1724 }
1725 case ICBTAG_FLAG_AD_LONG:
1726 {
1727 long_ad *lad = (long_ad *)ptr;
1728 lad->extLength = cpu_to_le32(elen);
1729 lad->extLocation = cpu_to_lelb(eloc);
1730 memset(lad->impUse, 0x00, sizeof(lad->impUse));
1731 adsize = sizeof(long_ad);
1732 break;
1733 }
1734 default:
1735 return -1;
1736 }
1737
1738 if (bh)
1739 {
1740 if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) || UDF_SB_UDFREV(inode->i_sb) >= 0x0201)
1741 {
1742 struct allocExtDesc *aed = (struct allocExtDesc *)(bh)->b_data;
1743 udf_update_tag((bh)->b_data,
1744 le32_to_cpu(aed->lengthAllocDescs) + sizeof(struct allocExtDesc));
1745 }
1746 mark_buffer_dirty_inode(bh, inode);
1747 udf_release_data(bh);
1748 }
1749 else
1750 mark_inode_dirty(inode);
1751
1752 if (inc)
1753 *extoffset += adsize;
1754 return (elen >> 30);
1755 }
1756
1757 int8_t udf_next_aext(struct inode *inode, kernel_lb_addr *bloc, int *extoffset,
1758 kernel_lb_addr *eloc, uint32_t *elen, struct buffer_head **bh, int inc)
1759 {
1760 int8_t etype;
1761
1762 while ((etype = udf_current_aext(inode, bloc, extoffset, eloc, elen, bh, inc)) ==
1763 (EXT_NEXT_EXTENT_ALLOCDECS >> 30))
1764 {
1765 *bloc = *eloc;
1766 *extoffset = sizeof(struct allocExtDesc);
1767 udf_release_data(*bh);
1768 if (!(*bh = udf_tread(inode->i_sb, udf_get_lb_pblock(inode->i_sb, *bloc, 0))))
1769 {
1770 udf_debug("reading block %d failed!\n",
1771 udf_get_lb_pblock(inode->i_sb, *bloc, 0));
1772 return -1;
1773 }
1774 }
1775
1776 return etype;
1777 }
1778
1779 int8_t udf_current_aext(struct inode *inode, kernel_lb_addr *bloc, int *extoffset,
1780 kernel_lb_addr *eloc, uint32_t *elen, struct buffer_head **bh, int inc)
1781 {
1782 int alen;
1783 int8_t etype;
1784 uint8_t *ptr;
1785
1786 if (!*bh)
1787 {
1788 if (!(*extoffset))
1789 *extoffset = udf_file_entry_alloc_offset(inode);
1790 ptr = UDF_I_DATA(inode) + *extoffset - udf_file_entry_alloc_offset(inode) + UDF_I_LENEATTR(inode);
1791 alen = udf_file_entry_alloc_offset(inode) + UDF_I_LENALLOC(inode);
1792 }
1793 else
1794 {
1795 if (!(*extoffset))
1796 *extoffset = sizeof(struct allocExtDesc);
1797 ptr = (*bh)->b_data + *extoffset;
1798 alen = sizeof(struct allocExtDesc) + le32_to_cpu(((struct allocExtDesc *)(*bh)->b_data)->lengthAllocDescs);
1799 }
1800
1801 switch (UDF_I_ALLOCTYPE(inode))
1802 {
1803 case ICBTAG_FLAG_AD_SHORT:
1804 {
1805 short_ad *sad;
1806
1807 if (!(sad = udf_get_fileshortad(ptr, alen, extoffset, inc)))
1808 return -1;
1809
1810 etype = le32_to_cpu(sad->extLength) >> 30;
1811 eloc->logicalBlockNum = le32_to_cpu(sad->extPosition);
1812 eloc->partitionReferenceNum = UDF_I_LOCATION(inode).partitionReferenceNum;
1813 *elen = le32_to_cpu(sad->extLength) & UDF_EXTENT_LENGTH_MASK;
1814 break;
1815 }
1816 case ICBTAG_FLAG_AD_LONG:
1817 {
1818 long_ad *lad;
1819
1820 if (!(lad = udf_get_filelongad(ptr, alen, extoffset, inc)))
1821 return -1;
1822
1823 etype = le32_to_cpu(lad->extLength) >> 30;
1824 *eloc = lelb_to_cpu(lad->extLocation);
1825 *elen = le32_to_cpu(lad->extLength) & UDF_EXTENT_LENGTH_MASK;
1826 break;
1827 }
1828 default:
1829 {
1830 udf_debug("alloc_type = %d unsupported\n", UDF_I_ALLOCTYPE(inode));
1831 return -1;
1832 }
1833 }
1834
1835 return etype;
1836 }
1837
1838 static int8_t
1839 udf_insert_aext(struct inode *inode, kernel_lb_addr bloc, int extoffset,
1840 kernel_lb_addr neloc, uint32_t nelen, struct buffer_head *bh)
1841 {
1842 kernel_lb_addr oeloc;
1843 uint32_t oelen;
1844 int8_t etype;
1845
1846 if (bh)
1847 atomic_inc(&bh->b_count);
1848
1849 while ((etype = udf_next_aext(inode, &bloc, &extoffset, &oeloc, &oelen, &bh, 0)) != -1)
1850 {
1851 udf_write_aext(inode, bloc, &extoffset, neloc, nelen, bh, 1);
1852
1853 neloc = oeloc;
1854 nelen = (etype << 30) | oelen;
1855 }
1856 udf_add_aext(inode, &bloc, &extoffset, neloc, nelen, &bh, 1);
1857 udf_release_data(bh);
1858 return (nelen >> 30);
1859 }
1860
1861 int8_t udf_delete_aext(struct inode *inode, kernel_lb_addr nbloc, int nextoffset,
1862 kernel_lb_addr eloc, uint32_t elen, struct buffer_head *nbh)
1863 {
1864 struct buffer_head *obh;
1865 kernel_lb_addr obloc;
1866 int oextoffset, adsize;
1867 int8_t etype;
1868 struct allocExtDesc *aed;
1869
1870 if (nbh)
1871 {
1872 atomic_inc(&nbh->b_count);
1873 atomic_inc(&nbh->b_count);
1874 }
1875
1876 if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_SHORT)
1877 adsize = sizeof(short_ad);
1878 else if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_LONG)
1879 adsize = sizeof(long_ad);
1880 else
1881 adsize = 0;
1882
1883 obh = nbh;
1884 obloc = nbloc;
1885 oextoffset = nextoffset;
1886
1887 if (udf_next_aext(inode, &nbloc, &nextoffset, &eloc, &elen, &nbh, 1) == -1)
1888 return -1;
1889
1890 while ((etype = udf_next_aext(inode, &nbloc, &nextoffset, &eloc, &elen, &nbh, 1)) != -1)
1891 {
1892 udf_write_aext(inode, obloc, &oextoffset, eloc, (etype << 30) | elen, obh, 1);
1893 if (obh != nbh)
1894 {
1895 obloc = nbloc;
1896 udf_release_data(obh);
1897 atomic_inc(&nbh->b_count);
1898 obh = nbh;
1899 oextoffset = nextoffset - adsize;
1900 }
1901 }
1902 memset(&eloc, 0x00, sizeof(kernel_lb_addr));
1903 elen = 0;
1904
1905 if (nbh != obh)
1906 {
1907 udf_free_blocks(inode->i_sb, inode, nbloc, 0, 1);
1908 udf_write_aext(inode, obloc, &oextoffset, eloc, elen, obh, 1);
1909 udf_write_aext(inode, obloc, &oextoffset, eloc, elen, obh, 1);
1910 if (!obh)
1911 {
1912 UDF_I_LENALLOC(inode) -= (adsize * 2);
1913 mark_inode_dirty(inode);
1914 }
1915 else
1916 {
1917 aed = (struct allocExtDesc *)(obh)->b_data;
1918 aed->lengthAllocDescs =
1919 cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) - (2*adsize));
1920 if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) || UDF_SB_UDFREV(inode->i_sb) >= 0x0201)
1921 udf_update_tag((obh)->b_data, oextoffset - (2*adsize));
1922 else
1923 udf_update_tag((obh)->b_data, sizeof(struct allocExtDesc));
1924 mark_buffer_dirty_inode(obh, inode);
1925 }
1926 }
1927 else
1928 {
1929 udf_write_aext(inode, obloc, &oextoffset, eloc, elen, obh, 1);
1930 if (!obh)
1931 {
1932 UDF_I_LENALLOC(inode) -= adsize;
1933 mark_inode_dirty(inode);
1934 }
1935 else
1936 {
1937 aed = (struct allocExtDesc *)(obh)->b_data;
1938 aed->lengthAllocDescs =
1939 cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) - adsize);
1940 if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) || UDF_SB_UDFREV(inode->i_sb) >= 0x0201)
1941 udf_update_tag((obh)->b_data, oextoffset - adsize);
1942 else
1943 udf_update_tag((obh)->b_data, sizeof(struct allocExtDesc));
1944 mark_buffer_dirty_inode(obh, inode);
1945 }
1946 }
1947
1948 udf_release_data(nbh);
1949 udf_release_data(obh);
1950 return (elen >> 30);
1951 }
1952
1953 int8_t inode_bmap(struct inode *inode, int block, kernel_lb_addr *bloc, uint32_t *extoffset,
1954 kernel_lb_addr *eloc, uint32_t *elen, uint32_t *offset, struct buffer_head **bh)
1955 {
1956 uint64_t lbcount = 0, bcount = (uint64_t)block << inode->i_sb->s_blocksize_bits;
1957 int8_t etype;
1958
1959 if (block < 0)
1960 {
1961 printk(KERN_ERR "udf: inode_bmap: block < 0\n");
1962 return -1;
1963 }
1964
1965 *extoffset = 0;
1966 *elen = 0;
1967 *bloc = UDF_I_LOCATION(inode);
1968
1969 do
1970 {
1971 if ((etype = udf_next_aext(inode, bloc, extoffset, eloc, elen, bh, 1)) == -1)
1972 {
1973 *offset = bcount - lbcount;
1974 UDF_I_LENEXTENTS(inode) = lbcount;
1975 return -1;
1976 }
1977 lbcount += *elen;
1978 } while (lbcount <= bcount);
1979
1980 *offset = bcount + *elen - lbcount;
1981
1982 return etype;
1983 }
1984
1985 long udf_block_map(struct inode *inode, long block)
1986 {
1987 kernel_lb_addr eloc, bloc;
1988 uint32_t offset, extoffset, elen;
1989 struct buffer_head *bh = NULL;
1990 int ret;
1991
1992 lock_kernel();
1993
1994 if (inode_bmap(inode, block, &bloc, &extoffset, &eloc, &elen, &offset, &bh) == (EXT_RECORDED_ALLOCATED >> 30))
1995 ret = udf_get_lb_pblock(inode->i_sb, eloc, offset >> inode->i_sb->s_blocksize_bits);
1996 else
1997 ret = 0;
1998
1999 unlock_kernel();
2000 udf_release_data(bh);
2001
2002 if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_VARCONV))
2003 return udf_fixed_to_variable(ret);
2004 else
2005 return ret;
2006 }
Support for the Chinese Samsung S3C2440 based development boards