namei.c 33 KB

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