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