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