?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[SERIAL] 8250_pnp: add support for other Wacom tablets
[pv_ops_mirror.git] / fs / udf / namei.c
blobab9a7629d23e82c094e8b7db9606a57af007e294
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;
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 (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 };
Mirror for ia64_pv_ops.git