namei.c 34 KB

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