?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Import 2.3.36
[davej-history.git] / fs / udf / namei.c
blobebf3448323d4999d657d3be4543e83cd9039b5d3
1 /*
2 * namei.c
3 *
4 * PURPOSE
5 * Inode name 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@hootie.lvld.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-1999 Ben Fennema
19 * (C) 1999 Stelias Computing Inc
20 *
21 * HISTORY
22 *
23 * 12/12/98 blf Created. Split out the lookup code from dir.c
24 * 04/19/99 blf link, mknod, symlink support
25 *
26 */
27
28 #include "udfdecl.h"
29
30 #if defined(__linux__) && defined(__KERNEL__)
31 #include <linux/version.h>
32 #include "udf_i.h"
33 #include "udf_sb.h"
34 #include <linux/string.h>
35 #include <linux/errno.h>
36 #include <linux/mm.h>
37 #include <linux/malloc.h>
38 #include <linux/udf_fs.h>
39 #endif
40
41 static inline int udf_match(int len, const char * const name, struct qstr *qs)
42 {
43 if (len != qs->len)
44 return 0;
45 return !memcmp(name, qs->name, len);
46 }
47
48 int udf_write_fi(struct FileIdentDesc *cfi, struct FileIdentDesc *sfi,
49 struct udf_fileident_bh *fibh,
50 Uint8 *impuse, Uint8 *fileident)
51 {
52 Uint16 crclen = fibh->eoffset - fibh->soffset - sizeof(tag);
53 Uint16 crc;
54 Uint8 checksum = 0;
55 int i;
56 int offset;
57 Uint16 liu = le16_to_cpu(cfi->lengthOfImpUse);
58 Uint8 lfi = cfi->lengthFileIdent;
59 int padlen = fibh->eoffset - fibh->soffset - liu - lfi -
60 sizeof(struct FileIdentDesc);
61
62
63 offset = fibh->soffset + sizeof(struct FileIdentDesc);
64
65 if (impuse)
66 {
67 if (offset + liu < 0)
68 memcpy((Uint8 *)sfi->impUse, impuse, liu);
69 else if (offset >= 0)
70 memcpy(fibh->ebh->b_data + offset, impuse, liu);
71 else
72 {
73 memcpy((Uint8 *)sfi->impUse, impuse, -offset);
74 memcpy(fibh->ebh->b_data, impuse - offset, liu + offset);
75 }
76 }
77
78 offset += liu;
79
80 if (fileident)
81 {
82 if (offset + lfi < 0)
83 memcpy((Uint8 *)sfi->fileIdent + liu, fileident, lfi);
84 else if (offset >= 0)
85 memcpy(fibh->ebh->b_data + offset, fileident, lfi);
86 else
87 {
88 memcpy((Uint8 *)sfi->fileIdent + liu, fileident, -offset);
89 memcpy(fibh->ebh->b_data, fileident - offset, lfi + offset);
90 }
91 }
92
93 offset += lfi;
94
95 if (offset + padlen < 0)
96 memset((Uint8 *)sfi->padding + liu + lfi, 0x00, padlen);
97 else if (offset >= 0)
98 memset(fibh->ebh->b_data + offset, 0x00, padlen);
99 else
100 {
101 memset((Uint8 *)sfi->padding + liu + lfi, 0x00, -offset);
102 memset(fibh->ebh->b_data, 0x00, padlen + offset);
103 }
104
105 crc = udf_crc((Uint8 *)cfi + sizeof(tag), sizeof(struct FileIdentDesc) -
106 sizeof(tag), 0);
107
108 if (fibh->sbh == fibh->ebh)
109 crc = udf_crc((Uint8 *)sfi->impUse,
110 crclen + sizeof(tag) - sizeof(struct FileIdentDesc), crc);
111 else if (sizeof(struct FileIdentDesc) >= -fibh->soffset)
112 crc = udf_crc(fibh->ebh->b_data + sizeof(struct FileIdentDesc) + fibh->soffset,
113 crclen + sizeof(tag) - sizeof(struct FileIdentDesc), crc);
114 else
115 {
116 crc = udf_crc((Uint8 *)sfi->impUse,
117 -fibh->soffset - sizeof(struct FileIdentDesc), crc);
118 crc = udf_crc(fibh->ebh->b_data, fibh->eoffset, crc);
119 }
120
121 cfi->descTag.descCRC = cpu_to_le32(crc);
122 cfi->descTag.descCRCLength = cpu_to_le16(crclen);
123
124 for (i=0; i<16; i++)
125 if (i != 4)
126 checksum += ((Uint8 *)&cfi->descTag)[i];
127
128 cfi->descTag.tagChecksum = checksum;
129 if (sizeof(struct FileIdentDesc) <= -fibh->soffset)
130 memcpy((Uint8 *)sfi, (Uint8 *)cfi, sizeof(struct FileIdentDesc));
131 else
132 {
133 memcpy((Uint8 *)sfi, (Uint8 *)cfi, -fibh->soffset);
134 memcpy(fibh->ebh->b_data, (Uint8 *)cfi - fibh->soffset,
135 sizeof(struct FileIdentDesc) + fibh->soffset);
136 }
137
138 if (fibh->sbh != fibh->ebh)
139 mark_buffer_dirty(fibh->ebh, 1);
140 mark_buffer_dirty(fibh->sbh, 1);
141 return 0;
142 }
143
144 static struct FileIdentDesc *
145 udf_find_entry(struct inode *dir, struct dentry *dentry,
146 struct udf_fileident_bh *fibh,
147 struct FileIdentDesc *cfi)
148 {
149 struct FileIdentDesc *fi=NULL;
150 loff_t f_pos;
151 int block, flen;
152 char fname[255];
153 char *nameptr;
154 Uint8 lfi;
155 Uint16 liu;
156 loff_t size = (UDF_I_EXT0OFFS(dir) + dir->i_size) >> 2;
157 lb_addr bloc, eloc;
158 Uint32 extoffset, elen, offset;
159 struct buffer_head *bh = NULL;
160
161 if (!dir)
162 return NULL;
163
164 f_pos = (UDF_I_EXT0OFFS(dir) >> 2);
165
166 fibh->soffset = fibh->eoffset = (f_pos & ((dir->i_sb->s_blocksize - 1) >> 2)) << 2;
167 if (inode_bmap(dir, f_pos >> (dir->i_sb->s_blocksize_bits - 2),
168 &bloc, &extoffset, &eloc, &elen, &offset, &bh) == EXTENT_RECORDED_ALLOCATED)
169 {
170 block = udf_get_lb_pblock(dir->i_sb, eloc, offset);
171 if ((++offset << dir->i_sb->s_blocksize_bits) < elen)
172 {
173 if (UDF_I_ALLOCTYPE(dir) == ICB_FLAG_AD_SHORT)
174 extoffset -= sizeof(short_ad);
175 else if (UDF_I_ALLOCTYPE(dir) == ICB_FLAG_AD_LONG)
176 extoffset -= sizeof(long_ad);
177 }
178 else
179 offset = 0;
180 }
181 else
182 {
183 udf_release_data(bh);
184 return NULL;
185 }
186
187 if (!(fibh->sbh = fibh->ebh = udf_tread(dir->i_sb, block, dir->i_sb->s_blocksize)))
188 {
189 udf_debug("udf_tread failed: block=%d\n", block);
190 udf_release_data(bh);
191 return NULL;
192 }
193
194 while ( (f_pos < size) )
195 {
196 fi = udf_fileident_read(dir, &f_pos, fibh, cfi, &bloc, &extoffset, &offset, &bh);
197
198 if (!fi)
199 {
200 if (fibh->sbh != fibh->ebh)
201 udf_release_data(fibh->ebh);
202 udf_release_data(fibh->sbh);
203 udf_release_data(bh);
204 return NULL;
205 }
206
207 liu = le16_to_cpu(cfi->lengthOfImpUse);
208 lfi = cfi->lengthFileIdent;
209
210 if (fibh->sbh == fibh->ebh)
211 {
212 nameptr = fi->fileIdent + liu;
213 }
214 else
215 {
216 int poffset; /* Unpaded ending offset */
217
218 poffset = fibh->soffset + sizeof(struct FileIdentDesc) + liu + lfi;
219
220 if (poffset >= lfi)
221 nameptr = (Uint8 *)(fibh->ebh->b_data + poffset - lfi);
222 else
223 {
224 nameptr = fname;
225 memcpy(nameptr, fi->fileIdent + liu, lfi - poffset);
226 memcpy(nameptr + lfi - poffset, fibh->ebh->b_data, poffset);
227 }
228 }
229
230 if ( (cfi->fileCharacteristics & FILE_DELETED) != 0 )
231 {
232 if ( !IS_UNDELETE(dir->i_sb) )
233 continue;
234 }
235
236 if ( (cfi->fileCharacteristics & FILE_HIDDEN) != 0 )
237 {
238 if ( !IS_UNHIDE(dir->i_sb) )
239 continue;
240 }
241
242 if (!lfi)
243 continue;
244
245 if ((flen = udf_get_filename(nameptr, fname, lfi)))
246 {
247 if (udf_match(flen, fname, &(dentry->d_name)))
248 {
249 udf_release_data(bh);
250 return fi;
251 }
252 }
253 }
254 if (fibh->sbh != fibh->ebh)
255 udf_release_data(fibh->ebh);
256 udf_release_data(fibh->sbh);
257 udf_release_data(bh);
258 return NULL;
259 }
260
261 /*
262 * udf_lookup
263 *
264 * PURPOSE
265 * Look-up the inode for a given name.
266 *
267 * DESCRIPTION
268 * Required - lookup_dentry() will return -ENOTDIR if this routine is not
269 * available for a directory. The filesystem is useless if this routine is
270 * not available for at least the filesystem's root directory.
271 *
272 * This routine is passed an incomplete dentry - it must be completed by
273 * calling d_add(dentry, inode). If the name does not exist, then the
274 * specified inode must be set to null. An error should only be returned
275 * when the lookup fails for a reason other than the name not existing.
276 * Note that the directory inode semaphore is held during the call.
277 *
278 * Refer to lookup_dentry() in fs/namei.c
279 * lookup_dentry() -> lookup() -> real_lookup() -> .
280 *
281 * PRE-CONDITIONS
282 * dir Pointer to inode of parent directory.
283 * dentry Pointer to dentry to complete.
284 *
285 * POST-CONDITIONS
286 * <return> Zero on success.
287 *
288 * HISTORY
289 * July 1, 1997 - Andrew E. Mileski
290 * Written, tested, and released.
291 */
292
293 struct dentry *
294 udf_lookup(struct inode *dir, struct dentry *dentry)
295 {
296 struct inode *inode = NULL;
297 struct FileIdentDesc cfi, *fi;
298 struct udf_fileident_bh fibh;
299
300 #ifdef UDF_RECOVERY
301 /* temporary shorthand for specifying files by inode number */
302 if (!strncmp(dentry->d_name.name, ".B=", 3) )
303 {
304 lb_addr lb = { 0, simple_strtoul(dentry->d_name.name+3, NULL, 0) };
305 inode = udf_iget(dir->i_sb, lb);
306 if (!inode)
307 return ERR_PTR(-EACCES);
308 }
309 else
310 #endif /* UDF_RECOVERY */
311
312 if ((fi = udf_find_entry(dir, dentry, &fibh, &cfi)))
313 {
314 if (fibh.sbh != fibh.ebh)
315 udf_release_data(fibh.ebh);
316 udf_release_data(fibh.sbh);
317
318 inode = udf_iget(dir->i_sb, lelb_to_cpu(cfi.icb.extLocation));
319 if ( !inode )
320 return ERR_PTR(-EACCES);
321 }
322 d_add(dentry, inode);
323 return NULL;
324 }
325
326 static struct FileIdentDesc *
327 udf_add_entry(struct inode *dir, struct dentry *dentry,
328 struct udf_fileident_bh *fibh,
329 struct FileIdentDesc *cfi, int *err)
330 {
331 struct super_block *sb;
332 struct FileIdentDesc *fi=NULL;
333 struct ustr unifilename;
334 char name[UDF_NAME_LEN], fname[UDF_NAME_LEN];
335 int namelen;
336 loff_t f_pos;
337 int flen;
338 char *nameptr;
339 loff_t size = (UDF_I_EXT0OFFS(dir) + dir->i_size) >> 2;
340 int nfidlen;
341 Uint8 lfi;
342 Uint16 liu;
343 int block;
344 lb_addr bloc, eloc;
345 Uint32 extoffset, elen, offset;
346 struct buffer_head *bh = NULL;
347
348 *err = -EINVAL;
349 if (!dir || !dir->i_nlink)
350 return NULL;
351 sb = dir->i_sb;
352
353 if (!dentry->d_name.len)
354 return NULL;
355
356 if (dir->i_size == 0)
357 {
358 *err = -ENOENT;
359 return NULL;
360 }
361
362 if ( !(udf_char_to_ustr(&unifilename, dentry->d_name.name, dentry->d_name.len)) )
363 {
364 *err = -ENAMETOOLONG;
365 return NULL;
366 }
367
368 if ( !(namelen = udf_UTF8toCS0(name, &unifilename, UDF_NAME_LEN)) )
369 return 0;
370
371 nfidlen = (sizeof(struct FileIdentDesc) + 0 + namelen + 3) & ~3;
372
373 f_pos = (UDF_I_EXT0OFFS(dir) >> 2);
374
375 fibh->soffset = fibh->eoffset = (f_pos & ((dir->i_sb->s_blocksize - 1) >> 2)) << 2;
376 if (inode_bmap(dir, f_pos >> (dir->i_sb->s_blocksize_bits - 2),
377 &bloc, &extoffset, &eloc, &elen, &offset, &bh) == EXTENT_RECORDED_ALLOCATED)
378 {
379 block = udf_get_lb_pblock(dir->i_sb, eloc, offset);
380 if ((++offset << dir->i_sb->s_blocksize_bits) < elen)
381 {
382 if (UDF_I_ALLOCTYPE(dir) == ICB_FLAG_AD_SHORT)
383 extoffset -= sizeof(short_ad);
384 else if (UDF_I_ALLOCTYPE(dir) == ICB_FLAG_AD_LONG)
385 extoffset -= sizeof(long_ad);
386 }
387 else
388 offset = 0;
389 }
390 else
391 {
392 udf_release_data(bh);
393 return NULL;
394 }
395
396 if (!(fibh->sbh = fibh->ebh = udf_tread(dir->i_sb, block, dir->i_sb->s_blocksize)))
397 return NULL;
398
399 block = UDF_I_LOCATION(dir).logicalBlockNum;
400
401 while ( (f_pos < size) )
402 {
403 fi = udf_fileident_read(dir, &f_pos, fibh, cfi, &bloc, &extoffset, &offset, &bh);
404
405 if (!fi)
406 {
407 if (fibh->sbh != fibh->ebh)
408 udf_release_data(fibh->ebh);
409 udf_release_data(fibh->sbh);
410 udf_release_data(bh);
411 return NULL;
412 }
413
414 liu = le16_to_cpu(cfi->lengthOfImpUse);
415 lfi = cfi->lengthFileIdent;
416
417 if (fibh->sbh == fibh->ebh)
418 nameptr = fi->fileIdent + liu;
419 else
420 {
421 int poffset; /* Unpaded ending offset */
422
423 poffset = fibh->soffset + sizeof(struct FileIdentDesc) + liu + lfi;
424
425 if (poffset >= lfi)
426 nameptr = (char *)(fibh->ebh->b_data + poffset - lfi);
427 else
428 {
429 nameptr = fname;
430 memcpy(nameptr, fi->fileIdent + liu, lfi - poffset);
431 memcpy(nameptr + lfi - poffset, fibh->ebh->b_data, poffset);
432 }
433 }
434
435 if ( (cfi->fileCharacteristics & FILE_DELETED) != 0 )
436 {
437 if (((sizeof(struct FileIdentDesc) + liu + lfi + 3) & ~3) == nfidlen)
438 {
439 udf_release_data(bh);
440 cfi->descTag.tagSerialNum = cpu_to_le16(1);
441 cfi->fileVersionNum = cpu_to_le16(1);
442 cfi->fileCharacteristics = 0;
443 cfi->lengthFileIdent = namelen;
444 cfi->lengthOfImpUse = cpu_to_le16(0);
445 if (!udf_write_fi(cfi, fi, fibh, NULL, name))
446 return fi;
447 else
448 return NULL;
449 }
450 }
451
452 if (!lfi)
453 continue;
454
455 if ((flen = udf_get_filename(nameptr, fname, lfi)))
456 {
457 if (udf_match(flen, fname, &(dentry->d_name)))
458 {
459 if (fibh->sbh != fibh->ebh)
460 udf_release_data(fibh->ebh);
461 udf_release_data(fibh->sbh);
462 udf_release_data(bh);
463 *err = -EEXIST;
464 return NULL;
465 }
466 }
467 }
468
469 f_pos += nfidlen;
470
471 if (UDF_I_ALLOCTYPE(dir) == ICB_FLAG_AD_IN_ICB &&
472 sb->s_blocksize - fibh->eoffset < nfidlen)
473 {
474 udf_release_data(bh);
475 bh = NULL;
476 fibh->soffset -= UDF_I_EXT0OFFS(dir);
477 fibh->eoffset -= UDF_I_EXT0OFFS(dir);
478 f_pos -= (UDF_I_EXT0OFFS(dir) >> 2);
479 if (fibh->sbh != fibh->ebh)
480 udf_release_data(fibh->ebh);
481 udf_release_data(fibh->sbh);
482 if (!(fibh->sbh = fibh->ebh = udf_expand_adinicb(dir, &block, 1, err)))
483 return NULL;
484 bloc = UDF_I_LOCATION(dir);
485 extoffset = udf_file_entry_alloc_offset(dir);
486 }
487 else
488 {
489 if (UDF_I_ALLOCTYPE(dir) == ICB_FLAG_AD_SHORT)
490 extoffset -= sizeof(short_ad);
491 else if (UDF_I_ALLOCTYPE(dir) == ICB_FLAG_AD_LONG)
492 extoffset -= sizeof(long_ad);
493 }
494
495 if (sb->s_blocksize - fibh->eoffset >= nfidlen)
496 {
497 fibh->soffset = fibh->eoffset;
498 fibh->eoffset += nfidlen;
499 if (fibh->sbh != fibh->ebh)
500 {
501 udf_release_data(fibh->sbh);
502 fibh->sbh = fibh->ebh;
503 }
504
505 if (UDF_I_ALLOCTYPE(dir) != ICB_FLAG_AD_IN_ICB)
506 {
507 Uint32 lextoffset = extoffset;
508 if (udf_next_aext(dir, &bloc, &extoffset, &eloc, &elen, &bh, 1) !=
509 EXTENT_RECORDED_ALLOCATED)
510 {
511 udf_release_data(bh);
512 udf_release_data(fibh->sbh);
513 return NULL;
514 }
515 else
516 {
517 if (elen & (sb->s_blocksize - 1))
518 elen += nfidlen;
519 block = eloc.logicalBlockNum + ((elen - 1) >>
520 dir->i_sb->s_blocksize_bits);
521 elen = (EXTENT_RECORDED_ALLOCATED << 30) | elen;
522 udf_write_aext(dir, bloc, &lextoffset, eloc, elen, &bh, 1);
523 }
524 }
525 else
526 block = UDF_I_LOCATION(dir).logicalBlockNum;
527
528 fi = (struct FileIdentDesc *)(fibh->sbh->b_data + fibh->soffset);
529 }
530 else
531 {
532 Uint32 lextoffset = extoffset;
533
534 fibh->soffset = fibh->eoffset - sb->s_blocksize;
535 fibh->eoffset += nfidlen - sb->s_blocksize;
536 if (fibh->sbh != fibh->ebh)
537 {
538 udf_release_data(fibh->sbh);
539 fibh->sbh = fibh->ebh;
540 }
541
542 if (udf_next_aext(dir, &bloc, &extoffset, &eloc, &elen, &bh, 1) !=
543 EXTENT_RECORDED_ALLOCATED)
544 {
545 udf_release_data(bh);
546 udf_release_data(fibh->sbh);
547 return NULL;
548 }
549 else
550 {
551 elen = ((elen + sb->s_blocksize - 1) & ~(sb->s_blocksize - 1));
552 block = eloc.logicalBlockNum +
553 ((elen - 1) >> dir->i_sb->s_blocksize_bits);
554 elen = (EXTENT_RECORDED_ALLOCATED << 30) | elen;
555 udf_write_aext(dir, bloc, &lextoffset, eloc, elen, &bh, 0);
556 }
557
558 *err = -ENOSPC;
559 if (!(fibh->ebh = udf_bread(dir, f_pos >> (dir->i_sb->s_blocksize_bits - 2), 1, err)))
560 {
561 udf_release_data(bh);
562 udf_release_data(fibh->sbh);
563 return NULL;
564 }
565 if (!(fibh->soffset))
566 {
567 if (udf_next_aext(dir, &bloc, &lextoffset, &eloc, &elen, &bh, 1) ==
568 EXTENT_RECORDED_ALLOCATED)
569 {
570 if (block == (eloc.logicalBlockNum +
571 ((elen - 1) >> dir->i_sb->s_blocksize_bits)))
572 {
573 if (udf_next_aext(dir, &bloc, &lextoffset, &eloc, &elen, &bh, 1) !=
574 EXTENT_RECORDED_ALLOCATED)
575 {
576 udf_release_data(bh);
577 udf_release_data(fibh->sbh);
578 udf_release_data(fibh->ebh);
579 udf_debug("next extent not recorded and allocated\n");
580 return NULL;
581 }
582 }
583 }
584 else
585 {
586 udf_release_data(bh);
587 udf_release_data(fibh->sbh);
588 udf_release_data(fibh->ebh);
589 udf_debug("next extent not recorded and allocated\n");
590 return NULL;
591 }
592 block = eloc.logicalBlockNum + ((elen - 1) >>
593 dir->i_sb->s_blocksize_bits);
594 }
595
596 fi = (struct FileIdentDesc *)(fibh->sbh->b_data + sb->s_blocksize + fibh->soffset);
597 }
598
599 memset(cfi, 0, sizeof(struct FileIdentDesc));
600 udf_new_tag((char *)cfi, TID_FILE_IDENT_DESC, 2, 1, block, sizeof(tag));
601 cfi->fileVersionNum = cpu_to_le16(1);
602 cfi->lengthFileIdent = namelen;
603 cfi->lengthOfImpUse = cpu_to_le16(0);
604 if (!udf_write_fi(cfi, fi, fibh, NULL, name))
605 {
606 udf_release_data(bh);
607 dir->i_size += nfidlen;
608 if (UDF_I_ALLOCTYPE(dir) == ICB_FLAG_AD_IN_ICB)
609 UDF_I_LENALLOC(dir) += nfidlen;
610 dir->i_version = ++event;
611 mark_inode_dirty(dir);
612 return fi;
613 }
614 else
615 {
616 udf_release_data(bh);
617 if (fibh->sbh != fibh->ebh)
618 udf_release_data(fibh->ebh);
619 udf_release_data(fibh->sbh);
620 return NULL;
621 }
622 }
623
624 static int udf_delete_entry(struct FileIdentDesc *fi,
625 struct udf_fileident_bh *fibh,
626 struct FileIdentDesc *cfi)
627 {
628 cfi->fileCharacteristics |= FILE_DELETED;
629 return udf_write_fi(cfi, fi, fibh, NULL, NULL);
630 }
631
632 int udf_create(struct inode *dir, struct dentry *dentry, int mode)
633 {
634 struct udf_fileident_bh fibh;
635 struct inode *inode;
636 struct FileIdentDesc cfi, *fi;
637 int err;
638
639 inode = udf_new_inode(dir, mode, &err);
640 if (!inode)
641 return err;
642
643 inode->i_op = &udf_file_inode_operations;
644 inode->i_mode = mode;
645 mark_inode_dirty(inode);
646
647 if (!(fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err)))
648 {
649 udf_debug("udf_add_entry failure!\n");
650 inode->i_nlink --;
651 mark_inode_dirty(inode);
652 iput(inode);
653 return err;
654 }
655 cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize);
656 cfi.icb.extLocation = cpu_to_lelb(UDF_I_LOCATION(inode));
657 *(Uint32 *)((struct ADImpUse *)cfi.icb.impUse)->impUse =
658 cpu_to_le32(UDF_I_UNIQUE(inode) & 0x00000000FFFFFFFFUL);
659 udf_write_fi(&cfi, fi, &fibh, NULL, NULL);
660 if (UDF_I_ALLOCTYPE(dir) == ICB_FLAG_AD_IN_ICB)
661 {
662 mark_inode_dirty(dir);
663 dir->i_version = ++event;
664 }
665 if (fibh.sbh != fibh.ebh)
666 udf_release_data(fibh.ebh);
667 udf_release_data(fibh.sbh);
668 d_instantiate(dentry, inode);
669 return 0;
670 }
671
672 int udf_mknod(struct inode * dir, struct dentry * dentry, int mode, int rdev)
673 {
674 struct inode * inode;
675 struct udf_fileident_bh fibh;
676 int err;
677 struct FileIdentDesc cfi, *fi;
678
679 err = -EIO;
680 inode = udf_new_inode(dir, mode, &err);
681 if (!inode)
682 goto out;
683
684 inode->i_uid = current->fsuid;
685 inode->i_mode = mode;
686 inode->i_op = NULL;
687 if (!(fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err)))
688 {
689 udf_debug("udf_add_entry failure!\n");
690 inode->i_nlink --;
691 mark_inode_dirty(inode);
692 iput(inode);
693 return err;
694 }
695 cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize);
696 cfi.icb.extLocation = cpu_to_lelb(UDF_I_LOCATION(inode));
697 *(Uint32 *)((struct ADImpUse *)cfi.icb.impUse)->impUse =
698 cpu_to_le32(UDF_I_UNIQUE(inode) & 0x00000000FFFFFFFFUL);
699 udf_write_fi(&cfi, fi, &fibh, NULL, NULL);
700 if (UDF_I_ALLOCTYPE(dir) == ICB_FLAG_AD_IN_ICB)
701 {
702 mark_inode_dirty(dir);
703 dir->i_version = ++event;
704 }
705 init_special_inode(inode, mode, rdev);
706 mark_inode_dirty(inode);
707
708 if (fibh.sbh != fibh.ebh)
709 udf_release_data(fibh.ebh);
710 udf_release_data(fibh.sbh);
711 d_instantiate(dentry, inode);
712 err = 0;
713 out:
714 return err;
715 }
716
717 int udf_mkdir(struct inode * dir, struct dentry * dentry, int mode)
718 {
719 struct inode * inode;
720 struct udf_fileident_bh fibh;
721 int err;
722 struct FileEntry *fe;
723 struct FileIdentDesc cfi, *fi;
724 Uint32 loc;
725
726 err = -EMLINK;
727 if (dir->i_nlink >= (256<<sizeof(dir->i_nlink))-1)
728 goto out;
729
730 err = -EIO;
731 inode = udf_new_inode(dir, S_IFDIR, &err);
732 if (!inode)
733 goto out;
734
735 inode->i_op = &udf_dir_inode_operations;
736 inode->i_size = (sizeof(struct FileIdentDesc) + 3) & ~3;
737 if (UDF_I_ALLOCTYPE(inode) == ICB_FLAG_AD_IN_ICB)
738 {
739 UDF_I_EXT0LEN(inode) = inode->i_size;
740 UDF_I_EXT0LOC(inode) = UDF_I_LOCATION(inode);
741 UDF_I_LENALLOC(inode) = inode->i_size;
742 loc = UDF_I_LOCATION(inode).logicalBlockNum;
743 fibh.sbh = udf_tread(inode->i_sb, inode->i_ino, inode->i_sb->s_blocksize);
744 }
745 else
746 {
747 fibh.sbh = udf_bread (inode, 0, 1, &err);
748 loc = UDF_I_EXT0LOC(inode).logicalBlockNum;
749 }
750
751 if (!fibh.sbh)
752 {
753 inode->i_nlink--;
754 mark_inode_dirty(inode);
755 iput(inode);
756 goto out;
757 }
758 inode->i_nlink = 2;
759 fe = (struct FileEntry *)fibh.sbh->b_data;
760 fi = (struct FileIdentDesc *)&(fe->extendedAttr[UDF_I_LENEATTR(inode)]);
761 udf_new_tag((char *)&cfi, TID_FILE_IDENT_DESC, 2, 1, loc,
762 sizeof(struct FileIdentDesc));
763 cfi.fileVersionNum = cpu_to_le16(1);
764 cfi.fileCharacteristics = FILE_DIRECTORY | FILE_PARENT;
765 cfi.lengthFileIdent = 0;
766 cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize);
767 cfi.icb.extLocation = cpu_to_lelb(UDF_I_LOCATION(dir));
768 *(Uint32 *)((struct ADImpUse *)cfi.icb.impUse)->impUse =
769 cpu_to_le32(UDF_I_UNIQUE(dir) & 0x00000000FFFFFFFFUL);
770 cfi.lengthOfImpUse = cpu_to_le16(0);
771 fibh.ebh = fibh.sbh;
772 fibh.soffset = sizeof(struct FileEntry);
773 fibh.eoffset = sizeof(struct FileEntry) + inode->i_size;
774 udf_write_fi(&cfi, fi, &fibh, NULL, NULL);
775 udf_release_data(fibh.sbh);
776 inode->i_mode = S_IFDIR | (mode & (S_IRWXUGO|S_ISVTX) & ~current->fs->umask);
777 if (dir->i_mode & S_ISGID)
778 inode->i_mode |= S_ISGID;
779 mark_inode_dirty(inode);
780
781 if (!(fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err)))
782 {
783 udf_debug("udf_add_entry failure!\n");
784 inode->i_nlink = 0;
785 mark_inode_dirty(inode);
786 iput(inode);
787 goto out;
788 }
789 cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize);
790 cfi.icb.extLocation = cpu_to_lelb(UDF_I_LOCATION(inode));
791 *(Uint32 *)((struct ADImpUse *)cfi.icb.impUse)->impUse =
792 cpu_to_le32(UDF_I_UNIQUE(inode) & 0x00000000FFFFFFFFUL);
793 cfi.fileCharacteristics |= FILE_DIRECTORY;
794 udf_write_fi(&cfi, fi, &fibh, NULL, NULL);
795 dir->i_version = ++event;
796 dir->i_nlink++;
797 mark_inode_dirty(dir);
798 d_instantiate(dentry, inode);
799 if (fibh.sbh != fibh.ebh)
800 udf_release_data(fibh.ebh);
801 udf_release_data(fibh.sbh);
802 err = 0;
803 out:
804 return err;
805 }
806
807 static int empty_dir(struct inode *dir)
808 {
809 struct FileIdentDesc *fi, cfi;
810 struct udf_fileident_bh fibh;
811 loff_t f_pos;
812 loff_t size = (UDF_I_EXT0OFFS(dir) + dir->i_size) >> 2;
813 int block;
814 lb_addr bloc, eloc;
815 Uint32 extoffset, elen, offset;
816 struct buffer_head *bh = NULL;
817
818 f_pos = (UDF_I_EXT0OFFS(dir) >> 2);
819
820 fibh.soffset = fibh.eoffset = (f_pos & ((dir->i_sb->s_blocksize - 1) >> 2)) << 2;
821 if (inode_bmap(dir, f_pos >> (dir->i_sb->s_blocksize_bits - 2),
822 &bloc, &extoffset, &eloc, &elen, &offset, &bh) == EXTENT_RECORDED_ALLOCATED)
823 {
824 block = udf_get_lb_pblock(dir->i_sb, eloc, offset);
825 if ((++offset << dir->i_sb->s_blocksize_bits) < elen)
826 {
827 if (UDF_I_ALLOCTYPE(dir) == ICB_FLAG_AD_SHORT)
828 extoffset -= sizeof(short_ad);
829 else if (UDF_I_ALLOCTYPE(dir) == ICB_FLAG_AD_LONG)
830 extoffset -= sizeof(long_ad);
831 }
832 else
833 offset = 0;
834 }
835 else
836 {
837 udf_release_data(bh);
838 return 0;
839 }
840
841 if (!(fibh.sbh = fibh.ebh = udf_tread(dir->i_sb, block, dir->i_sb->s_blocksize)))
842 return 0;
843
844 while ( (f_pos < size) )
845 {
846 fi = udf_fileident_read(dir, &f_pos, &fibh, &cfi, &bloc, &extoffset, &offset, &bh);
847
848 if (!fi)
849 {
850 if (fibh.sbh != fibh.ebh)
851 udf_release_data(fibh.ebh);
852 udf_release_data(fibh.sbh);
853 udf_release_data(bh);
854 return 0;
855 }
856
857 if (cfi.lengthFileIdent && (cfi.fileCharacteristics & FILE_DELETED) == 0)
858 {
859 udf_release_data(bh);
860 return 0;
861 }
862 }
863 if (fibh.sbh != fibh.ebh)
864 udf_release_data(fibh.ebh);
865 udf_release_data(fibh.sbh);
866 udf_release_data(bh);
867 return 1;
868 }
869
870 int udf_rmdir(struct inode * dir, struct dentry * dentry)
871 {
872 int retval;
873 struct inode * inode;
874 struct udf_fileident_bh fibh;
875 struct FileIdentDesc *fi, cfi;
876
877 retval = -ENOENT;
878 fi = udf_find_entry(dir, dentry, &fibh, &cfi);
879 if (!fi)
880 goto out;
881
882 inode = dentry->d_inode;
883
884 retval = -EIO;
885 if (udf_get_lb_pblock(dir->i_sb, lelb_to_cpu(cfi.icb.extLocation), 0) != inode->i_ino)
886 goto end_rmdir;
887 retval = -ENOTEMPTY;
888 if (!empty_dir(inode))
889 goto end_rmdir;
890 retval = udf_delete_entry(fi, &fibh, &cfi);
891 dir->i_version = ++event;
892 if (retval)
893 goto end_rmdir;
894 if (inode->i_nlink != 2)
895 udf_warning(inode->i_sb, "udf_rmdir",
896 "empty directory has nlink != 2 (%d)",
897 inode->i_nlink);
898 inode->i_version = ++event;
899 inode->i_nlink = 0;
900 inode->i_size = 0;
901 mark_inode_dirty(inode);
902 dir->i_nlink --;
903 inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME;
904 UDF_I_UCTIME(inode) = UDF_I_UCTIME(dir) = UDF_I_UMTIME(dir) = CURRENT_UTIME;
905 mark_inode_dirty(dir);
906 d_delete(dentry);
907
908 end_rmdir:
909 if (fibh.sbh != fibh.ebh)
910 udf_release_data(fibh.ebh);
911 udf_release_data(fibh.sbh);
912 out:
913 return retval;
914 }
915
916 int udf_unlink(struct inode * dir, struct dentry * dentry)
917 {
918 int retval;
919 struct inode * inode;
920 struct udf_fileident_bh fibh;
921 struct FileIdentDesc *fi;
922 struct FileIdentDesc cfi;
923
924 retval = -ENOENT;
925 fi = udf_find_entry(dir, dentry, &fibh, &cfi);
926 if (!fi)
927 goto out;
928
929 inode = dentry->d_inode;
930
931 retval = -EIO;
932
933 if (udf_get_lb_pblock(dir->i_sb, lelb_to_cpu(cfi.icb.extLocation), 0) !=
934 inode->i_ino)
935 {
936 goto end_unlink;
937 }
938
939 if (!inode->i_nlink)
940 {
941 udf_debug("Deleting nonexistent file (%lu), %d\n",
942 inode->i_ino, inode->i_nlink);
943 inode->i_nlink = 1;
944 }
945 retval = udf_delete_entry(fi, &fibh, &cfi);
946 if (retval)
947 goto end_unlink;
948 dir->i_ctime = dir->i_mtime = CURRENT_TIME;
949 UDF_I_UCTIME(dir) = UDF_I_UMTIME(dir) = CURRENT_UTIME;
950 mark_inode_dirty(dir);
951 inode->i_nlink--;
952 mark_inode_dirty(inode);
953 inode->i_ctime = dir->i_ctime;
954 retval = 0;
955 d_delete(dentry); /* This also frees the inode */
956
957 end_unlink:
958 if (fibh.sbh != fibh.ebh)
959 udf_release_data(fibh.ebh);
960 udf_release_data(fibh.sbh);
961 out:
962 return retval;
963 }
964
965 int udf_symlink(struct inode * dir, struct dentry * dentry, const char * symname)
966 {
967 struct inode * inode;
968 struct PathComponent *pc;
969 struct udf_fileident_bh fibh;
970 struct buffer_head *bh = NULL;
971 int eoffset, elen = 0;
972 struct FileIdentDesc *fi;
973 struct FileIdentDesc cfi;
974 char *ea;
975 int err;
976
977 if (!(inode = udf_new_inode(dir, S_IFLNK, &err)))
978 goto out;
979
980 inode->i_mode = S_IFLNK | S_IRWXUGO;
981 inode->i_op = &udf_symlink_inode_operations;
982
983 bh = udf_tread(inode->i_sb, inode->i_ino, inode->i_sb->s_blocksize);
984 ea = bh->b_data + udf_file_entry_alloc_offset(inode);
985
986 eoffset = inode->i_sb->s_blocksize - (ea - bh->b_data);
987 pc = (struct PathComponent *)ea;
988
989 if (*symname == '/')
990 {
991 do
992 {
993 symname++;
994 } while (*symname == '/');
995
996 pc->componentType = 1;
997 pc->lengthComponentIdent = 0;
998 pc->componentFileVersionNum = 0;
999 pc += sizeof(struct PathComponent);
1000 elen += sizeof(struct PathComponent);
1001 }
1002
1003 while (*symname && eoffset > elen + sizeof(struct PathComponent))
1004 {
1005 char *compstart;
1006 pc = (struct PathComponent *)(ea + elen);
1007
1008 compstart = (char *)symname;
1009
1010 do
1011 {
1012 symname++;
1013 } while (*symname && *symname != '/');
1014
1015 pc->componentType = 5;
1016 pc->lengthComponentIdent = 0;
1017 pc->componentFileVersionNum = 0;
1018 if (pc->componentIdent[0] == '.')
1019 {
1020 if (pc->lengthComponentIdent == 1)
1021 pc->componentType = 4;
1022 else if (pc->lengthComponentIdent == 2 && pc->componentIdent[1] == '.')
1023 pc->componentType = 3;
1024 }
1025
1026 if (pc->componentType == 5)
1027 {
1028 if (elen + sizeof(struct PathComponent) + symname - compstart > eoffset)
1029 pc->lengthComponentIdent = eoffset - elen - sizeof(struct PathComponent);
1030 else
1031 pc->lengthComponentIdent = symname - compstart;
1032
1033 memcpy(pc->componentIdent, compstart, pc->lengthComponentIdent);
1034 }
1035
1036 elen += sizeof(struct PathComponent) + pc->lengthComponentIdent;
1037
1038 if (*symname)
1039 {
1040 do
1041 {
1042 symname++;
1043 } while (*symname == '/');
1044 }
1045 }
1046
1047 udf_release_data(bh);
1048 UDF_I_LENALLOC(inode) = inode->i_size = elen;
1049 mark_inode_dirty(inode);
1050
1051 if (!(fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err)))
1052 goto out;
1053 cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize);
1054 cfi.icb.extLocation = cpu_to_lelb(UDF_I_LOCATION(inode));
1055 if (UDF_SB_LVIDBH(inode->i_sb))
1056 {
1057 struct LogicalVolHeaderDesc *lvhd;
1058 Uint64 uniqueID;
1059 lvhd = (struct LogicalVolHeaderDesc *)(UDF_SB_LVID(inode->i_sb)->logicalVolContentsUse);
1060 uniqueID = le64_to_cpu(lvhd->uniqueID);
1061 *(Uint32 *)((struct ADImpUse *)cfi.icb.impUse)->impUse =
1062 le32_to_cpu(uniqueID & 0x00000000FFFFFFFFUL);
1063 if (!(++uniqueID & 0x00000000FFFFFFFFUL))
1064 uniqueID += 16;
1065 lvhd->uniqueID = cpu_to_le64(uniqueID);
1066 mark_buffer_dirty(UDF_SB_LVIDBH(inode->i_sb), 1);
1067 }
1068 udf_write_fi(&cfi, fi, &fibh, NULL, NULL);
1069 if (UDF_I_ALLOCTYPE(dir) == ICB_FLAG_AD_IN_ICB)
1070 {
1071 mark_inode_dirty(dir);
1072 dir->i_version = ++event;
1073 }
1074 if (fibh.sbh != fibh.ebh)
1075 udf_release_data(fibh.ebh);
1076 udf_release_data(fibh.sbh);
1077 d_instantiate(dentry, inode);
1078 err = 0;
1079
1080 out:
1081 return err;
1082 }
1083
1084 int udf_link(struct dentry * old_dentry, struct inode * dir,
1085 struct dentry *dentry)
1086 {
1087 struct inode *inode = old_dentry->d_inode;
1088 struct udf_fileident_bh fibh;
1089 int err;
1090 struct FileIdentDesc cfi, *fi;
1091
1092 if (S_ISDIR(inode->i_mode))
1093 return -EPERM;
1094
1095 if (inode->i_nlink >= (256<<sizeof(inode->i_nlink))-1)
1096 return -EMLINK;
1097
1098 if (!(fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err)))
1099 return err;
1100 cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize);
1101 cfi.icb.extLocation = cpu_to_lelb(UDF_I_LOCATION(inode));
1102 if (UDF_SB_LVIDBH(inode->i_sb))
1103 {
1104 struct LogicalVolHeaderDesc *lvhd;
1105 Uint64 uniqueID;
1106 lvhd = (struct LogicalVolHeaderDesc *)(UDF_SB_LVID(inode->i_sb)->logicalVolContentsUse);
1107 uniqueID = le64_to_cpu(lvhd->uniqueID);
1108 *(Uint32 *)((struct ADImpUse *)cfi.icb.impUse)->impUse =
1109 cpu_to_le32(uniqueID & 0x00000000FFFFFFFFUL);
1110 if (!(++uniqueID & 0x00000000FFFFFFFFUL))
1111 uniqueID += 16;
1112 lvhd->uniqueID = cpu_to_le64(uniqueID);
1113 mark_buffer_dirty(UDF_SB_LVIDBH(inode->i_sb), 1);
1114 }
1115 udf_write_fi(&cfi, fi, &fibh, NULL, NULL);
1116 if (UDF_I_ALLOCTYPE(dir) == ICB_FLAG_AD_IN_ICB)
1117 {
1118 mark_inode_dirty(dir);
1119 dir->i_version = ++event;
1120 }
1121 if (fibh.sbh != fibh.ebh)
1122 udf_release_data(fibh.ebh);
1123 udf_release_data(fibh.sbh);
1124 inode->i_nlink ++;
1125 inode->i_ctime = CURRENT_TIME;
1126 UDF_I_UCTIME(inode) = CURRENT_UTIME;
1127 mark_inode_dirty(inode);
1128 inode->i_count ++;
1129 d_instantiate(dentry, inode);
1130 return 0;
1131 }
1132
1133 /* Anybody can rename anything with this: the permission checks are left to the
1134 * higher-level routines.
1135 */
1136 int udf_rename (struct inode * old_dir, struct dentry * old_dentry,
1137 struct inode * new_dir, struct dentry * new_dentry)
1138 {
1139 struct inode * old_inode, * new_inode;
1140 struct udf_fileident_bh ofibh, nfibh;
1141 struct FileIdentDesc *ofi = NULL, *nfi = NULL, *dir_fi = NULL, ocfi, ncfi;
1142 struct buffer_head *dir_bh = NULL;
1143 int retval = -ENOENT;
1144
1145 old_inode = old_dentry->d_inode;
1146 ofi = udf_find_entry(old_dir, old_dentry, &ofibh, &ocfi);
1147 if (!ofi || udf_get_lb_pblock(old_dir->i_sb, lelb_to_cpu(ocfi.icb.extLocation), 0) !=
1148 old_inode->i_ino)
1149 {
1150 goto end_rename;
1151 }
1152
1153 new_inode = new_dentry->d_inode;
1154 nfi = udf_find_entry(new_dir, new_dentry, &nfibh, &ncfi);
1155 if (nfi)
1156 {
1157 if (!new_inode)
1158 {
1159 if (nfibh.sbh != nfibh.ebh)
1160 udf_release_data(nfibh.ebh);
1161 udf_release_data(nfibh.sbh);
1162 nfi = NULL;
1163 }
1164 else
1165 {
1166 /*
1167 DQUOT_INIT(new_inode);
1168 */
1169 }
1170 }
1171 if (S_ISDIR(old_inode->i_mode))
1172 {
1173 Uint32 offset = UDF_I_EXT0OFFS(old_inode);
1174
1175 if (new_inode)
1176 {
1177 retval = -ENOTEMPTY;
1178 if (!empty_dir(new_inode))
1179 goto end_rename;
1180 }
1181 retval = -EIO;
1182 dir_bh = udf_bread(old_inode, 0, 0, &retval);
1183 if (!dir_bh)
1184 goto end_rename;
1185 dir_fi = udf_get_fileident(dir_bh->b_data, old_inode->i_sb->s_blocksize, &offset);
1186 if (!dir_fi)
1187 goto end_rename;
1188 if (udf_get_lb_pblock(old_inode->i_sb, cpu_to_lelb(dir_fi->icb.extLocation), 0) !=
1189 old_dir->i_ino)
1190 {
1191 goto end_rename;
1192 }
1193 retval = -EMLINK;
1194 if (!new_inode && new_dir->i_nlink >= (256<<sizeof(new_dir->i_nlink))-1)
1195 goto end_rename;
1196 }
1197 if (!nfi)
1198 {
1199 nfi = udf_add_entry(new_dir, new_dentry, &nfibh, &ncfi, &retval);
1200 if (!nfi)
1201 goto end_rename;
1202 }
1203 new_dir->i_version = ++event;
1204
1205 /*
1206 * ok, that's it
1207 */
1208 ncfi.fileVersionNum = ocfi.fileVersionNum;
1209 ncfi.fileCharacteristics = ocfi.fileCharacteristics;
1210 memcpy(&(ncfi.icb), &(ocfi.icb), sizeof(long_ad));
1211 udf_write_fi(&ncfi, nfi, &nfibh, NULL, NULL);
1212
1213 udf_delete_entry(ofi, &ofibh, &ocfi);
1214
1215 old_dir->i_version = ++event;
1216 if (new_inode)
1217 {
1218 new_inode->i_nlink--;
1219 new_inode->i_ctime = CURRENT_TIME;
1220 UDF_I_UCTIME(new_inode) = CURRENT_UTIME;
1221 mark_inode_dirty(new_inode);
1222 }
1223 old_dir->i_ctime = old_dir->i_mtime = CURRENT_TIME;
1224 UDF_I_UCTIME(old_dir) = UDF_I_UMTIME(old_dir) = CURRENT_UTIME;
1225 mark_inode_dirty(old_dir);
1226
1227 if (dir_bh)
1228 {
1229 dir_fi->icb.extLocation = lelb_to_cpu(UDF_I_LOCATION(new_dir));
1230 udf_update_tag((char *)dir_fi, sizeof(struct FileIdentDesc) +
1231 cpu_to_le16(dir_fi->lengthOfImpUse));
1232 if (UDF_I_ALLOCTYPE(old_inode) == ICB_FLAG_AD_IN_ICB)
1233 {
1234 mark_inode_dirty(old_inode);
1235 old_inode->i_version = ++event;
1236 }
1237 else
1238 mark_buffer_dirty(dir_bh, 1);
1239 old_dir->i_nlink --;
1240 mark_inode_dirty(old_dir);
1241 if (new_inode)
1242 {
1243 new_inode->i_nlink --;
1244 mark_inode_dirty(new_inode);
1245 }
1246 else
1247 {
1248 new_dir->i_nlink ++;
1249 mark_inode_dirty(new_dir);
1250 }
1251 }
1252
1253 retval = 0;
1254
1255 end_rename:
1256 udf_release_data(dir_bh);
1257 if (ofi)
1258 {
1259 if (ofibh.sbh != ofibh.ebh)
1260 udf_release_data(ofibh.ebh);
1261 udf_release_data(ofibh.sbh);
1262 }
1263 if (nfi)
1264 {
1265 if (nfibh.sbh != nfibh.ebh)
1266 udf_release_data(nfibh.ebh);
1267 udf_release_data(nfibh.sbh);
1268 }
1269 return retval;
1270 }
Copy of Dave Jones history.git as used by http://archive.org/details/git-history-of-linux