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