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