开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
inode.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：57k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

inode.c：源码内容
  1. /*
  2.  * inode.c
  3.  *
  4.  * PURPOSE
  5.  *  Inode handling routines for the OSTA-UDF(tm) filesystem.
  6.  *
  7.  * CONTACTS
  8.  *  E-mail regarding any portion of the Linux UDF file system should be
  9.  *  directed to the development team mailing list (run by majordomo):
  10.  *    linux_udf@hpesjro.fc.hp.com
  11.  *
  12.  * COPYRIGHT
  13.  *  This file is distributed under the terms of the GNU General Public
  14.  *  License (GPL). Copies of the GPL can be obtained from:
  15.  *    ftp://prep.ai.mit.edu/pub/gnu/GPL
  16.  *  Each contributing author retains all rights to their own work.
  17.  *
  18.  *  (C) 1998 Dave Boynton
  19.  *  (C) 1998-2001 Ben Fennema
  20.  *  (C) 1999-2000 Stelias Computing Inc
  21.  *
  22.  * HISTORY
  23.  *
  24.  *  10/04/98 dgb  Added rudimentary directory functions
  25.  *  10/07/98      Fully working udf_block_map! It works!
  26.  *  11/25/98      bmap altered to better support extents
  27.  *  12/06/98 blf  partition support in udf_iget, udf_block_map and udf_read_inode
  28.  *  12/12/98      rewrote udf_block_map to handle next extents and descs across
  29.  *                block boundaries (which is not actually allowed)
  30.  *  12/20/98      added support for strategy 4096
  31.  *  03/07/99      rewrote udf_block_map (again)
  32.  *                New funcs, inode_bmap, udf_next_aext
  33.  *  04/19/99      Support for writing device EA's for major/minor #
  34.  */
  36. #include "udfdecl.h"
  37. #include <linux/locks.h>
  38. #include <linux/mm.h>
  39. #include <linux/smp_lock.h>
  40. #include <linux/module.h>
  42. #include "udf_i.h"
  43. #include "udf_sb.h"
  45. MODULE_AUTHOR("Ben Fennema");
  46. MODULE_DESCRIPTION("Universal Disk Format Filesystem");
  47. MODULE_LICENSE("GPL");
  49. #define EXTENT_MERGE_SIZE 5
  51. static mode_t udf_convert_permissions(struct fileEntry *);
  52. static int udf_update_inode(struct inode *, int);
  53. static void udf_fill_inode(struct inode *, struct buffer_head *);
  54. static struct buffer_head *inode_getblk(struct inode *, long, int *, long *, int *);
  55. static void udf_split_extents(struct inode *, int *, int, int,
  56. long_ad [EXTENT_MERGE_SIZE], int *);
  57. static void udf_prealloc_extents(struct inode *, int, int,
  58.  long_ad [EXTENT_MERGE_SIZE], int *);
  59. static void udf_merge_extents(struct inode *,
  60.  long_ad [EXTENT_MERGE_SIZE], int *);
  61. static void udf_update_extents(struct inode *,
  62. long_ad [EXTENT_MERGE_SIZE], int, int,
  63. lb_addr, uint32_t, struct buffer_head **);
  64. static int udf_get_block(struct inode *, long, struct buffer_head *, int);
  66. /*
  67.  * udf_put_inode
  68.  *
  69.  * PURPOSE
  70.  *
  71.  * DESCRIPTION
  72.  * This routine is called whenever the kernel no longer needs the inode.
  73.  *
  74.  * HISTORY
  75.  * July 1, 1997 - Andrew E. Mileski
  76.  * Written, tested, and released.
  77.  *
  78.  *  Called at each iput()
  79.  */
  80. void udf_put_inode(struct inode * inode)
  81. {
  82. if (!(inode->i_sb->s_flags & MS_RDONLY))
  83. {
  84. lock_kernel();
  85. udf_discard_prealloc(inode);
  86. unlock_kernel();
  87. }
  88. }
  90. /*
  91.  * udf_delete_inode
  92.  *
  93.  * PURPOSE
  94.  * Clean-up before the specified inode is destroyed.
  95.  *
  96.  * DESCRIPTION
  97.  * This routine is called when the kernel destroys an inode structure
  98.  * ie. when iput() finds i_count == 0.
  99.  *
  100.  * HISTORY
  101.  * July 1, 1997 - Andrew E. Mileski
  102.  * Written, tested, and released.
  103.  *
  104.  *  Called at the last iput() if i_nlink is zero.
  105.  */
  106. void udf_delete_inode(struct inode * inode)
  107. {
  108. lock_kernel();
  110. if (is_bad_inode(inode))
  111. goto no_delete;
  113. inode->i_size = 0;
  114. udf_truncate(inode);
  115. udf_update_inode(inode, IS_SYNC(inode));
  116. udf_free_inode(inode);
  118. unlock_kernel();
  119. return;
  120. no_delete:
  121. unlock_kernel();
  122. clear_inode(inode);
  123. }
  125. void udf_discard_prealloc(struct inode * inode)
  126. {
  127. if (inode->i_size && inode->i_size != UDF_I_LENEXTENTS(inode) &&
  128. UDF_I_ALLOCTYPE(inode) != ICBTAG_FLAG_AD_IN_ICB)
  129. {
  130. udf_truncate_extents(inode);
  131. }
  132. }
  134. static int udf_writepage(struct page *page)
  135. {
  136. return block_write_full_page(page, udf_get_block);
  137. }
  139. static int udf_readpage(struct file *file, struct page *page)
  140. {
  141. return block_read_full_page(page, udf_get_block);
  142. }
  144. static int udf_prepare_write(struct file *file, struct page *page, unsigned from, unsigned to)
  145. {
  146. return block_prepare_write(page, from, to, udf_get_block);
  147. }
  149. static int udf_bmap(struct address_space *mapping, long block)
  150. {
  151. return generic_block_bmap(mapping,block,udf_get_block);
  152. }
  154. struct address_space_operations udf_aops = {
  155. readpage: udf_readpage,
  156. writepage: udf_writepage,
  157. sync_page: block_sync_page,
  158. prepare_write: udf_prepare_write,
  159. commit_write: generic_commit_write,
  160. bmap: udf_bmap,
  161. };
  163. void udf_expand_file_adinicb(struct inode * inode, int newsize, int * err)
  164. {
  165. struct buffer_head *bh = NULL;
  166. struct page *page;
  167. char *kaddr;
  168. int block;
  170. /* from now on we have normal address_space methods */
  171. inode->i_data.a_ops = &udf_aops;
  173. if (!UDF_I_LENALLOC(inode))
  174. {
  175. if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_SHORT_AD))
  176. UDF_I_ALLOCTYPE(inode) = ICBTAG_FLAG_AD_SHORT;
  177. else
  178. UDF_I_ALLOCTYPE(inode) = ICBTAG_FLAG_AD_LONG;
  179. mark_inode_dirty(inode);
  180. return;
  181. }
  183. block = udf_get_lb_pblock(inode->i_sb, UDF_I_LOCATION(inode), 0);
  184. bh = udf_tread(inode->i_sb, block);
  185. if (!bh)
  186. return;
  187. page = grab_cache_page(inode->i_mapping, 0);
  188. if (!PageLocked(page))
  189. PAGE_BUG(page);
  190. if (!Page_Uptodate(page))
  191. {
  192. kaddr = kmap(page);
  193. memset(kaddr + UDF_I_LENALLOC(inode), 0x00,
  194. PAGE_CACHE_SIZE - UDF_I_LENALLOC(inode));
  195. memcpy(kaddr, bh->b_data + udf_file_entry_alloc_offset(inode),
  196. UDF_I_LENALLOC(inode));
  197. flush_dcache_page(page);
  198. SetPageUptodate(page);
  199. kunmap(page);
  200. }
  201. memset(bh->b_data + udf_file_entry_alloc_offset(inode),
  202. 0, UDF_I_LENALLOC(inode));
  203. UDF_I_LENALLOC(inode) = 0;
  204. if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_SHORT_AD))
  205. UDF_I_ALLOCTYPE(inode) = ICBTAG_FLAG_AD_SHORT;
  206. else
  207. UDF_I_ALLOCTYPE(inode) = ICBTAG_FLAG_AD_LONG;
  208. mark_buffer_dirty_inode(bh, inode);
  209. udf_release_data(bh);
  211. inode->i_data.a_ops->writepage(page);
  212. page_cache_release(page);
  214. mark_inode_dirty(inode);
  215. inode->i_version ++;
  216. }
  218. struct buffer_head * udf_expand_dir_adinicb(struct inode *inode, int *block, int *err)
  219. {
  220. int newblock;
  221. struct buffer_head *sbh = NULL, *dbh = NULL;
  222. lb_addr bloc, eloc;
  223. uint32_t elen, extoffset;
  225. struct udf_fileident_bh sfibh, dfibh;
  226. loff_t f_pos = udf_ext0_offset(inode) >> 2;
  227. int size = (udf_ext0_offset(inode) + inode->i_size) >> 2;
  228. struct fileIdentDesc cfi, *sfi, *dfi;
  230. if (!inode->i_size)
  231. {
  232. if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_SHORT_AD))
  233. UDF_I_ALLOCTYPE(inode) = ICBTAG_FLAG_AD_SHORT;
  234. else
  235. UDF_I_ALLOCTYPE(inode) = ICBTAG_FLAG_AD_LONG;
  236. mark_inode_dirty(inode);
  237. return NULL;
  238. }
  240. /* alloc block, and copy data to it */
  241. *block = udf_new_block(inode->i_sb, inode,
  242. UDF_I_LOCATION(inode).partitionReferenceNum,
  243. UDF_I_LOCATION(inode).logicalBlockNum, err);
  245. if (!(*block))
  246. return NULL;
  247. newblock = udf_get_pblock(inode->i_sb, *block,
  248. UDF_I_LOCATION(inode).partitionReferenceNum, 0);
  249. if (!newblock)
  250. return NULL;
  251. sbh = udf_tread(inode->i_sb, inode->i_ino);
  252. if (!sbh)
  253. return NULL;
  254. dbh = udf_tgetblk(inode->i_sb, newblock);
  255. if (!dbh)
  256. return NULL;
  257. lock_buffer(dbh);
  258. memset(dbh->b_data, 0x00, inode->i_sb->s_blocksize);
  259. mark_buffer_uptodate(dbh, 1);
  260. unlock_buffer(dbh);
  261. mark_buffer_dirty_inode(dbh, inode);
  263. sfibh.soffset = sfibh.eoffset = (f_pos & ((inode->i_sb->s_blocksize - 1) >> 2)) << 2;
  264. sfibh.sbh = sfibh.ebh = sbh;
  265. dfibh.soffset = dfibh.eoffset = 0;
  266. dfibh.sbh = dfibh.ebh = dbh;
  267. while ( (f_pos < size) )
  268. {
  269. sfi = udf_fileident_read(inode, &f_pos, &sfibh, &cfi, NULL, NULL, NULL, NULL, NULL, NULL);
  270. if (!sfi)
  271. {
  272. udf_release_data(sbh);
  273. udf_release_data(dbh);
  274. return NULL;
  275. }
  276. sfi->descTag.tagLocation = *block;
  277. dfibh.soffset = dfibh.eoffset;
  278. dfibh.eoffset += (sfibh.eoffset - sfibh.soffset);
  279. dfi = (struct fileIdentDesc *)(dbh->b_data + dfibh.soffset);
  280. if (udf_write_fi(inode, sfi, dfi, &dfibh, sfi->impUse,
  281. sfi->fileIdent + sfi->lengthOfImpUse))
  282. {
  283. udf_release_data(sbh);
  284. udf_release_data(dbh);
  285. return NULL;
  286. }
  287. }
  288. mark_buffer_dirty_inode(dbh, inode);
  290. memset(sbh->b_data + udf_file_entry_alloc_offset(inode),
  291. 0, UDF_I_LENALLOC(inode));
  293. UDF_I_LENALLOC(inode) = 0;
  294. if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_SHORT_AD))
  295. UDF_I_ALLOCTYPE(inode) = ICBTAG_FLAG_AD_SHORT;
  296. else
  297. UDF_I_ALLOCTYPE(inode) = ICBTAG_FLAG_AD_LONG;
  298. bloc = UDF_I_LOCATION(inode);
  299. eloc.logicalBlockNum = *block;
  300. eloc.partitionReferenceNum = UDF_I_LOCATION(inode).partitionReferenceNum;
  301. elen = inode->i_size;
  302. UDF_I_LENEXTENTS(inode) = elen;
  303. extoffset = udf_file_entry_alloc_offset(inode);
  304. udf_add_aext(inode, &bloc, &extoffset, eloc, elen, &sbh, 0);
  305. /* UniqueID stuff */
  307. mark_buffer_dirty(sbh);
  308. udf_release_data(sbh);
  309. mark_inode_dirty(inode);
  310. inode->i_version ++;
  311. return dbh;
  312. }
  314. static int udf_get_block(struct inode *inode, long block, struct buffer_head *bh_result, int create)
  315. {
  316. int err, new;
  317. struct buffer_head *bh;
  318. unsigned long phys;
  320. if (!create)
  321. {
  322. phys = udf_block_map(inode, block);
  323. if (phys)
  324. {
  325. bh_result->b_dev = inode->i_dev;
  326. bh_result->b_blocknr = phys;
  327. bh_result->b_state |= (1UL << BH_Mapped);
  328. }
  329. return 0;
  330. }
  332. err = -EIO;
  333. new = 0;
  334. bh = NULL;
  336. lock_kernel();
  338. if (block < 0)
  339. goto abort_negative;
  341. if (block == UDF_I_NEXT_ALLOC_BLOCK(inode) + 1)
  342. {
  343. UDF_I_NEXT_ALLOC_BLOCK(inode) ++;
  344. UDF_I_NEXT_ALLOC_GOAL(inode) ++;
  345. }
  347. err = 0;
  349. bh = inode_getblk(inode, block, &err, &phys, &new);
  350. if (bh)
  351. BUG();
  352. if (err)
  353. goto abort;
  354. if (!phys)
  355. BUG();
  357. bh_result->b_dev = inode->i_dev;
  358. bh_result->b_blocknr = phys;
  359. bh_result->b_state |= (1UL << BH_Mapped);
  360. if (new)
  361. bh_result->b_state |= (1UL << BH_New);
  362. abort:
  363. unlock_kernel();
  364. return err;
  366. abort_negative:
  367. udf_warning(inode->i_sb, "udf_get_block", "block < 0");
  368. goto abort;
  369. }
  371. struct buffer_head * udf_getblk(struct inode * inode, long block,
  372. int create, int * err)
  373. {
  374. struct buffer_head dummy;
  376. dummy.b_state = 0;
  377. dummy.b_blocknr = -1000;
  378. *err = udf_get_block(inode, block, &dummy, create);
  379. if (!*err && buffer_mapped(&dummy))
  380. {
  381. struct buffer_head *bh;
  382. bh = sb_getblk(inode->i_sb, dummy.b_blocknr);
  383. if (buffer_new(&dummy))
  384. {
  385. lock_buffer(bh);
  386. memset(bh->b_data, 0x00, inode->i_sb->s_blocksize);
  387. mark_buffer_uptodate(bh, 1);
  388. unlock_buffer(bh);
  389. mark_buffer_dirty_inode(bh, inode);
  390. }
  391. return bh;
  392. }
  393. return NULL;
  394. }
  396. static struct buffer_head * inode_getblk(struct inode * inode, long block,
  397. int *err, long *phys, int *new)
  398. {
  399. struct buffer_head *pbh = NULL, *cbh = NULL, *nbh = NULL, *result = NULL;
  400. long_ad laarr[EXTENT_MERGE_SIZE];
  401. uint32_t pextoffset = 0, cextoffset = 0, nextoffset = 0;
  402. int count = 0, startnum = 0, endnum = 0;
  403. uint32_t elen = 0;
  404. lb_addr eloc, pbloc, cbloc, nbloc;
  405. int c = 1;
  406. uint64_t lbcount = 0, b_off = 0;
  407. uint32_t newblocknum, newblock, offset = 0;
  408. int8_t etype;
  409. int goal = 0, pgoal = UDF_I_LOCATION(inode).logicalBlockNum;
  410. char lastblock = 0;
  412. pextoffset = cextoffset = nextoffset = udf_file_entry_alloc_offset(inode);
  413. b_off = (uint64_t)block << inode->i_sb->s_blocksize_bits;
  414. pbloc = cbloc = nbloc = UDF_I_LOCATION(inode);
  416. /* find the extent which contains the block we are looking for.
  417.        alternate between laarr[0] and laarr[1] for locations of the
  418.        current extent, and the previous extent */
  419. do
  420. {
  421. if (pbh != cbh)
  422. {
  423. udf_release_data(pbh);
  424. atomic_inc(&cbh->b_count);
  425. pbh = cbh;
  426. }
  427. if (cbh != nbh)
  428. {
  429. udf_release_data(cbh);
  430. atomic_inc(&nbh->b_count);
  431. cbh = nbh;
  432. }
  434. lbcount += elen;
  436. pbloc = cbloc;
  437. cbloc = nbloc;
  439. pextoffset = cextoffset;
  440. cextoffset = nextoffset;
  442. if ((etype = udf_next_aext(inode, &nbloc, &nextoffset, &eloc, &elen, &nbh, 1)) == -1)
  443. break;
  445. c = !c;
  447. laarr[c].extLength = (etype << 30) | elen;
  448. laarr[c].extLocation = eloc;
  450. if (etype != (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30))
  451. pgoal = eloc.logicalBlockNum +
  452. ((elen + inode->i_sb->s_blocksize - 1) >>
  453. inode->i_sb->s_blocksize_bits);
  455. count ++;
  456. } while (lbcount + elen <= b_off);
  458. b_off -= lbcount;
  459. offset = b_off >> inode->i_sb->s_blocksize_bits;
  461. /* if the extent is allocated and recorded, return the block
  462.        if the extent is not a multiple of the blocksize, round up */
  464. if (etype == (EXT_RECORDED_ALLOCATED >> 30))
  465. {
  466. if (elen & (inode->i_sb->s_blocksize - 1))
  467. {
  468. elen = EXT_RECORDED_ALLOCATED |
  469. ((elen + inode->i_sb->s_blocksize - 1) &
  470. ~(inode->i_sb->s_blocksize - 1));
  471. etype = udf_write_aext(inode, nbloc, &cextoffset, eloc, elen, nbh, 1);
  472. }
  473. udf_release_data(pbh);
  474. udf_release_data(cbh);
  475. udf_release_data(nbh);
  476. newblock = udf_get_lb_pblock(inode->i_sb, eloc, offset);
  477. *phys = newblock;
  478. return NULL;
  479. }
  481. if (etype == -1)
  482. {
  483. endnum = startnum = ((count > 1) ? 1 : count);
  484. if (laarr[c].extLength & (inode->i_sb->s_blocksize - 1))
  485. {
  486. laarr[c].extLength =
  487. (laarr[c].extLength & UDF_EXTENT_FLAG_MASK) |
  488. (((laarr[c].extLength & UDF_EXTENT_LENGTH_MASK) +
  489. inode->i_sb->s_blocksize - 1) &
  490. ~(inode->i_sb->s_blocksize - 1));
  491. UDF_I_LENEXTENTS(inode) =
  492. (UDF_I_LENEXTENTS(inode) + inode->i_sb->s_blocksize - 1) &
  493. ~(inode->i_sb->s_blocksize - 1);
  494. }
  495. c = !c;
  496. laarr[c].extLength = EXT_NOT_RECORDED_NOT_ALLOCATED |
  497. ((offset + 1) << inode->i_sb->s_blocksize_bits);
  498. memset(&laarr[c].extLocation, 0x00, sizeof(lb_addr));
  499. count ++;
  500. endnum ++;
  501. lastblock = 1;
  502. }
  503. else
  504. endnum = startnum = ((count > 2) ? 2 : count);
  506. /* if the current extent is in position 0, swap it with the previous */
  507. if (!c && count != 1)
  508. {
  509. laarr[2] = laarr[0];
  510. laarr[0] = laarr[1];
  511. laarr[1] = laarr[2];
  512. c = 1;
  513. }
  515. /* if the current block is located in a extent, read the next extent */
  516. if (etype != -1)
  517. {
  518. if ((etype = udf_next_aext(inode, &nbloc, &nextoffset, &eloc, &elen, &nbh, 0)) != -1)
  519. {
  520. laarr[c+1].extLength = (etype << 30) | elen;
  521. laarr[c+1].extLocation = eloc;
  522. count ++;
  523. startnum ++;
  524. endnum ++;
  525. }
  526. else
  527. lastblock = 1;
  528. }
  529. udf_release_data(nbh);
  530. if (!pbh)
  531. pbh = cbh;
  532. else
  533. udf_release_data(cbh);
  535. /* if the current extent is not recorded but allocated, get the
  536. block in the extent corresponding to the requested block */
  537. if ((laarr[c].extLength >> 30) == (EXT_NOT_RECORDED_ALLOCATED >> 30))
  538. newblocknum = laarr[c].extLocation.logicalBlockNum + offset;
  539. else /* otherwise, allocate a new block */
  540. {
  541. if (UDF_I_NEXT_ALLOC_BLOCK(inode) == block)
  542. goal = UDF_I_NEXT_ALLOC_GOAL(inode);
  544. if (!goal)
  545. {
  546. if (!(goal = pgoal))
  547. goal = UDF_I_LOCATION(inode).logicalBlockNum + 1;
  548. }
  550. if (!(newblocknum = udf_new_block(inode->i_sb, inode,
  551. UDF_I_LOCATION(inode).partitionReferenceNum, goal, err)))
  552. {
  553. udf_release_data(pbh);
  554. *err = -ENOSPC;
  555. return NULL;
  556. }
  557. UDF_I_LENEXTENTS(inode) += inode->i_sb->s_blocksize;
  558. }
  560. /* if the extent the requsted block is located in contains multiple blocks,
  561.        split the extent into at most three extents. blocks prior to requested
  562.        block, requested block, and blocks after requested block */
  563. udf_split_extents(inode, &c, offset, newblocknum, laarr, &endnum);
  565. #ifdef UDF_PREALLOCATE
  566. /* preallocate blocks */
  567. udf_prealloc_extents(inode, c, lastblock, laarr, &endnum);
  568. #endif
  570. /* merge any continuous blocks in laarr */
  571. udf_merge_extents(inode, laarr, &endnum);
  573. /* write back the new extents, inserting new extents if the new number
  574.        of extents is greater than the old number, and deleting extents if
  575.        the new number of extents is less than the old number */
  576. udf_update_extents(inode, laarr, startnum, endnum, pbloc, pextoffset, &pbh);
  578. udf_release_data(pbh);
  580. if (!(newblock = udf_get_pblock(inode->i_sb, newblocknum,
  581. UDF_I_LOCATION(inode).partitionReferenceNum, 0)))
  582. {
  583. return NULL;
  584. }
  585. *phys = newblock;
  586. *err = 0;
  587. *new = 1;
  588. UDF_I_NEXT_ALLOC_BLOCK(inode) = block;
  589. UDF_I_NEXT_ALLOC_GOAL(inode) = newblocknum;
  590. inode->i_ctime = CURRENT_TIME;
  591. UDF_I_UCTIME(inode) = CURRENT_UTIME;
  593. if (IS_SYNC(inode))
  594. udf_sync_inode(inode);
  595. else
  596. mark_inode_dirty(inode);
  597. return result;
  598. }
  600. static void udf_split_extents(struct inode *inode, int *c, int offset, int newblocknum,
  601. long_ad laarr[EXTENT_MERGE_SIZE], int *endnum)
  602. {
  603. if ((laarr[*c].extLength >> 30) == (EXT_NOT_RECORDED_ALLOCATED >> 30) ||
  604. (laarr[*c].extLength >> 30) == (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30))
  605. {
  606. int curr = *c;
  607. int blen = ((laarr[curr].extLength & UDF_EXTENT_LENGTH_MASK) +
  608. inode->i_sb->s_blocksize - 1) >> inode->i_sb->s_blocksize_bits;
  609. int type = laarr[curr].extLength & ~UDF_EXTENT_LENGTH_MASK;
  611. if (blen == 1)
  612. ;
  613. else if (!offset || blen == offset + 1)
  614. {
  615. laarr[curr+2] = laarr[curr+1];
  616. laarr[curr+1] = laarr[curr];
  617. }
  618. else
  619. {
  620. laarr[curr+3] = laarr[curr+1];
  621. laarr[curr+2] = laarr[curr+1] = laarr[curr];
  622. }
  624. if (offset)
  625. {
  626. if ((type >> 30) == (EXT_NOT_RECORDED_ALLOCATED >> 30))
  627. {
  628. udf_free_blocks(inode->i_sb, inode, laarr[curr].extLocation, 0, offset);
  629. laarr[curr].extLength = EXT_NOT_RECORDED_NOT_ALLOCATED |
  630. (offset << inode->i_sb->s_blocksize_bits);
  631. laarr[curr].extLocation.logicalBlockNum = 0;
  632. laarr[curr].extLocation.partitionReferenceNum = 0;
  633. }
  634. else
  635. laarr[curr].extLength = type |
  636. (offset << inode->i_sb->s_blocksize_bits);
  637. curr ++;
  638. (*c) ++;
  639. (*endnum) ++;
  640. }
  642. laarr[curr].extLocation.logicalBlockNum = newblocknum;
  643. if ((type >> 30) == (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30))
  644. laarr[curr].extLocation.partitionReferenceNum =
  645. UDF_I_LOCATION(inode).partitionReferenceNum;
  646. laarr[curr].extLength = EXT_RECORDED_ALLOCATED |
  647. inode->i_sb->s_blocksize;
  648. curr ++;
  650. if (blen != offset + 1)
  651. {
  652. if ((type >> 30) == (EXT_NOT_RECORDED_ALLOCATED >> 30))
  653. laarr[curr].extLocation.logicalBlockNum += (offset + 1);
  654. laarr[curr].extLength = type |
  655. ((blen - (offset + 1)) << inode->i_sb->s_blocksize_bits);
  656. curr ++;
  657. (*endnum) ++;
  658. }
  659. }
  660. }
  662. static void udf_prealloc_extents(struct inode *inode, int c, int lastblock,
  663.  long_ad laarr[EXTENT_MERGE_SIZE], int *endnum)
  664. {
  665. int start, length = 0, currlength = 0, i;
  667. if (*endnum >= (c+1))
  668. {
  669. if (!lastblock)
  670. return;
  671. else
  672. start = c;
  673. }
  674. else
  675. {
  676. if ((laarr[c+1].extLength >> 30) == (EXT_NOT_RECORDED_ALLOCATED >> 30))
  677. {
  678. start = c+1;
  679. length = currlength = (((laarr[c+1].extLength & UDF_EXTENT_LENGTH_MASK) +
  680. inode->i_sb->s_blocksize - 1) >> inode->i_sb->s_blocksize_bits);
  681. }
  682. else
  683. start = c;
  684. }
  686. for (i=start+1; i<=*endnum; i++)
  687. {
  688. if (i == *endnum)
  689. {
  690. if (lastblock)
  691. length += UDF_DEFAULT_PREALLOC_BLOCKS;
  692. }
  693. else if ((laarr[i].extLength >> 30) == (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30))
  694. length += (((laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) +
  695. inode->i_sb->s_blocksize - 1) >> inode->i_sb->s_blocksize_bits);
  696. else
  697. break;
  698. }
  700. if (length)
  701. {
  702. int next = laarr[start].extLocation.logicalBlockNum +
  703. (((laarr[start].extLength & UDF_EXTENT_LENGTH_MASK) +
  704. inode->i_sb->s_blocksize - 1) >> inode->i_sb->s_blocksize_bits);
  705. int numalloc = udf_prealloc_blocks(inode->i_sb, inode,
  706. laarr[start].extLocation.partitionReferenceNum,
  707. next, (UDF_DEFAULT_PREALLOC_BLOCKS > length ? length :
  708. UDF_DEFAULT_PREALLOC_BLOCKS) - currlength);
  710. if (numalloc)
  711. {
  712. if (start == (c+1))
  713. laarr[start].extLength +=
  714. (numalloc << inode->i_sb->s_blocksize_bits);
  715. else
  716. {
  717. memmove(&laarr[c+2], &laarr[c+1],
  718. sizeof(long_ad) * (*endnum - (c+1)));
  719. (*endnum) ++;
  720. laarr[c+1].extLocation.logicalBlockNum = next;
  721. laarr[c+1].extLocation.partitionReferenceNum =
  722. laarr[c].extLocation.partitionReferenceNum;
  723. laarr[c+1].extLength = EXT_NOT_RECORDED_ALLOCATED |
  724. (numalloc << inode->i_sb->s_blocksize_bits);
  725. start = c+1;
  726. }
  728. for (i=start+1; numalloc && i<*endnum; i++)
  729. {
  730. int elen = ((laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) +
  731. inode->i_sb->s_blocksize - 1) >> inode->i_sb->s_blocksize_bits;
  733. if (elen > numalloc)
  734. {
  735. laarr[c].extLength -=
  736. (numalloc << inode->i_sb->s_blocksize_bits);
  737. numalloc = 0;
  738. }
  739. else
  740. {
  741. numalloc -= elen;
  742. if (*endnum > (i+1))
  743. memmove(&laarr[i], &laarr[i+1], 
  744. sizeof(long_ad) * (*endnum - (i+1)));
  745. i --;
  746. (*endnum) --;
  747. }
  748. }
  749. UDF_I_LENEXTENTS(inode) += numalloc << inode->i_sb->s_blocksize_bits;
  750. }
  751. }
  752. }
  754. static void udf_merge_extents(struct inode *inode,
  755.  long_ad laarr[EXTENT_MERGE_SIZE], int *endnum)
  756. {
  757. int i;
  759. for (i=0; i<(*endnum-1); i++)
  760. {
  761. if ((laarr[i].extLength >> 30) == (laarr[i+1].extLength >> 30))
  762. {
  763. if (((laarr[i].extLength >> 30) == (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30)) ||
  764. ((laarr[i+1].extLocation.logicalBlockNum - laarr[i].extLocation.logicalBlockNum) ==
  765. (((laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) +
  766. inode->i_sb->s_blocksize - 1) >> inode->i_sb->s_blocksize_bits)))
  767. {
  768. if (((laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) +
  769. (laarr[i+1].extLength & UDF_EXTENT_LENGTH_MASK) +
  770. inode->i_sb->s_blocksize - 1) & ~UDF_EXTENT_LENGTH_MASK)
  771. {
  772. laarr[i+1].extLength = (laarr[i+1].extLength -
  773. (laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) +
  774. UDF_EXTENT_LENGTH_MASK) & ~(inode->i_sb->s_blocksize-1);
  775. laarr[i].extLength = (UDF_EXTENT_LENGTH_MASK + 1) -
  776. inode->i_sb->s_blocksize;
  777. laarr[i+1].extLocation.logicalBlockNum =
  778. laarr[i].extLocation.logicalBlockNum +
  779. ((laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) >>
  780. inode->i_sb->s_blocksize_bits);
  781. }
  782. else
  783. {
  784. laarr[i].extLength = laarr[i+1].extLength +
  785. (((laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) +
  786. inode->i_sb->s_blocksize - 1) & ~(inode->i_sb->s_blocksize-1));
  787. if (*endnum > (i+2))
  788. memmove(&laarr[i+1], &laarr[i+2],
  789. sizeof(long_ad) * (*endnum - (i+2)));
  790. i --;
  791. (*endnum) --;
  792. }
  793. }
  794. }
  795. }
  796. }
  798. static void udf_update_extents(struct inode *inode,
  799. long_ad laarr[EXTENT_MERGE_SIZE], int startnum, int endnum,
  800. lb_addr pbloc, uint32_t pextoffset, struct buffer_head **pbh)
  801. {
  802. int start = 0, i;
  803. lb_addr tmploc;
  804. uint32_t tmplen;
  806. if (startnum > endnum)
  807. {
  808. for (i=0; i<(startnum-endnum); i++)
  809. {
  810. udf_delete_aext(inode, pbloc, pextoffset, laarr[i].extLocation,
  811. laarr[i].extLength, *pbh);
  812. }
  813. }
  814. else if (startnum < endnum)
  815. {
  816. for (i=0; i<(endnum-startnum); i++)
  817. {
  818. udf_insert_aext(inode, pbloc, pextoffset, laarr[i].extLocation,
  819. laarr[i].extLength, *pbh);
  820. udf_next_aext(inode, &pbloc, &pextoffset, &laarr[i].extLocation,
  821. &laarr[i].extLength, pbh, 1);
  822. start ++;
  823. }
  824. }
  826. for (i=start; i<endnum; i++)
  827. {
  828. udf_next_aext(inode, &pbloc, &pextoffset, &tmploc, &tmplen, pbh, 0);
  829. udf_write_aext(inode, pbloc, &pextoffset, laarr[i].extLocation,
  830. laarr[i].extLength, *pbh, 1);
  831. }
  832. }
  834. struct buffer_head * udf_bread(struct inode * inode, int block,
  835. int create, int * err)
  836. {
  837. struct buffer_head * bh = NULL;
  839. bh = udf_getblk(inode, block, create, err);
  840. if (!bh)
  841. return NULL;
  843. if (buffer_uptodate(bh))
  844. return bh;
  845. ll_rw_block(READ, 1, &bh);
  846. wait_on_buffer(bh);
  847. if (buffer_uptodate(bh))
  848. return bh;
  849. brelse(bh);
  850. *err = -EIO;
  851. return NULL;
  852. }
  854. void udf_truncate(struct inode * inode)
  855. {
  856. int offset;
  857. struct buffer_head *bh;
  858. int err;
  860. if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
  861. S_ISLNK(inode->i_mode)))
  862. return;
  863. if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
  864. return;
  866. if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB)
  867. {
  868. if (inode->i_sb->s_blocksize < (udf_file_entry_alloc_offset(inode) +
  869. inode->i_size))
  870. {
  871. udf_expand_file_adinicb(inode, inode->i_size, &err);
  872. if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB)
  873. {
  874. inode->i_size = UDF_I_LENALLOC(inode);
  875. return;
  876. }
  877. else
  878. udf_truncate_extents(inode);
  879. }
  880. else
  881. {
  882. offset = (inode->i_size & (inode->i_sb->s_blocksize - 1)) +
  883. udf_file_entry_alloc_offset(inode);
  885. if ((bh = udf_tread(inode->i_sb,
  886. udf_get_lb_pblock(inode->i_sb, UDF_I_LOCATION(inode), 0))))
  887. {
  888. memset(bh->b_data + offset, 0x00, inode->i_sb->s_blocksize - offset);
  889. mark_buffer_dirty(bh);
  890. udf_release_data(bh);
  891. }
  892. UDF_I_LENALLOC(inode) = inode->i_size;
  893. }
  894. }
  895. else
  896. {
  897. block_truncate_page(inode->i_mapping, inode->i_size, udf_get_block);
  898. udf_truncate_extents(inode);
  899. }
  901. inode->i_mtime = inode->i_ctime = CURRENT_TIME;
  902. UDF_I_UMTIME(inode) = UDF_I_UCTIME(inode) = CURRENT_UTIME;
  903. if (IS_SYNC(inode))
  904. udf_sync_inode (inode);
  905. else
  906. mark_inode_dirty(inode);
  907. }
  909. /*
  910.  * udf_read_inode
  911.  *
  912.  * PURPOSE
  913.  * Read an inode.
  914.  *
  915.  * DESCRIPTION
  916.  * This routine is called by iget() [which is called by udf_iget()]
  917.  *      (clean_inode() will have been called first)
  918.  * when an inode is first read into memory.
  919.  *
  920.  * HISTORY
  921.  * July 1, 1997 - Andrew E. Mileski
  922.  * Written, tested, and released.
  923.  *
  924.  * 12/19/98 dgb  Updated to fix size problems.
  925.  */
  927. void
  928. udf_read_inode(struct inode *inode)
  929. {
  930. memset(&UDF_I_LOCATION(inode), 0xFF, sizeof(lb_addr));
  931. }
  933. void
  934. __udf_read_inode(struct inode *inode)
  935. {
  936. struct buffer_head *bh = NULL;
  937. struct fileEntry *fe;
  938. uint16_t ident;
  940. /*
  941.  * Set defaults, but the inode is still incomplete!
  942.  * Note: get_new_inode() sets the following on a new inode:
  943.  *      i_sb = sb
  944.  *      i_dev = sb->s_dev;
  945.  *      i_no = ino
  946.  *      i_flags = sb->s_flags
  947.  *      i_state = 0
  948.  * clean_inode(): zero fills and sets
  949.  *      i_count = 1
  950.  *      i_nlink = 1
  951.  *      i_op = NULL;
  952.  */
  954. inode->i_blksize = PAGE_SIZE;
  956. bh = udf_read_ptagged(inode->i_sb, UDF_I_LOCATION(inode), 0, &ident);
  958. if (!bh)
  959. {
  960. printk(KERN_ERR "udf: udf_read_inode(ino %ld) failed !bhn",
  961. inode->i_ino);
  962. make_bad_inode(inode);
  963. return;
  964. }
  966. if (ident != TAG_IDENT_FE && ident != TAG_IDENT_EFE &&
  967. ident != TAG_IDENT_USE)
  968. {
  969. printk(KERN_ERR "udf: udf_read_inode(ino %ld) failed ident=%dn",
  970. inode->i_ino, ident);
  971. udf_release_data(bh);
  972. make_bad_inode(inode);
  973. return;
  974. }
  976. fe = (struct fileEntry *)bh->b_data;
  978. if (le16_to_cpu(fe->icbTag.strategyType) == 4096)
  979. {
  980. struct buffer_head *ibh = NULL, *nbh = NULL;
  981. struct indirectEntry *ie;
  983. ibh = udf_read_ptagged(inode->i_sb, UDF_I_LOCATION(inode), 1, &ident);
  984. if (ident == TAG_IDENT_IE)
  985. {
  986. if (ibh)
  987. {
  988. lb_addr loc;
  989. ie = (struct indirectEntry *)ibh->b_data;
  991. loc = lelb_to_cpu(ie->indirectICB.extLocation);
  993. if (ie->indirectICB.extLength && 
  994. (nbh = udf_read_ptagged(inode->i_sb, loc, 0, &ident)))
  995. {
  996. if (ident == TAG_IDENT_FE ||
  997. ident == TAG_IDENT_EFE)
  998. {
  999. memcpy(&UDF_I_LOCATION(inode), &loc, sizeof(lb_addr));
  1000. udf_release_data(bh);
  1001. udf_release_data(ibh);
  1002. udf_release_data(nbh);
  1003. __udf_read_inode(inode);
  1004. return;
  1005. }
  1006. else
  1007. {
  1008. udf_release_data(nbh);
  1009. udf_release_data(ibh);
  1010. }
  1011. }
  1012. else
  1013. udf_release_data(ibh);
  1014. }
  1015. }
  1016. else
  1017. udf_release_data(ibh);
  1018. }
  1019. else if (le16_to_cpu(fe->icbTag.strategyType) != 4)
  1020. {
  1021. printk(KERN_ERR "udf: unsupported strategy type: %dn",
  1022. le16_to_cpu(fe->icbTag.strategyType));
  1023. udf_release_data(bh);
  1024. make_bad_inode(inode);
  1025. return;
  1026. }
  1027. udf_fill_inode(inode, bh);
  1028. udf_release_data(bh);
  1029. }
  1031. static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
  1032. {
  1033. struct fileEntry *fe;
  1034. struct extendedFileEntry *efe;
  1035. time_t convtime;
  1036. long convtime_usec;
  1037. int offset, alen;
  1039. inode->i_version = ++event;
  1040. UDF_I_NEW_INODE(inode) = 0;
  1042. fe = (struct fileEntry *)bh->b_data;
  1043. efe = (struct extendedFileEntry *)bh->b_data;
  1045. if (le16_to_cpu(fe->icbTag.strategyType) == 4)
  1046. UDF_I_STRAT4096(inode) = 0;
  1047. else /* if (le16_to_cpu(fe->icbTag.strategyType) == 4096) */
  1048. UDF_I_STRAT4096(inode) = 1;
  1050. UDF_I_ALLOCTYPE(inode) = le16_to_cpu(fe->icbTag.flags) & ICBTAG_FLAG_AD_MASK;
  1051. if (le16_to_cpu(fe->descTag.tagIdent) == TAG_IDENT_EFE)
  1052. UDF_I_EXTENDED_FE(inode) = 1;
  1053. else if (le16_to_cpu(fe->descTag.tagIdent) == TAG_IDENT_FE)
  1054. UDF_I_EXTENDED_FE(inode) = 0;
  1055. else if (le16_to_cpu(fe->descTag.tagIdent) == TAG_IDENT_USE)
  1056. {
  1057. UDF_I_LENALLOC(inode) =
  1058. le32_to_cpu(
  1059. ((struct unallocSpaceEntry *)bh->b_data)->lengthAllocDescs);
  1060. return;
  1061. }
  1063. inode->i_uid = le32_to_cpu(fe->uid);
  1064. if ( inode->i_uid == -1 ) inode->i_uid = UDF_SB(inode->i_sb)->s_uid;
  1066. inode->i_gid = le32_to_cpu(fe->gid);
  1067. if ( inode->i_gid == -1 ) inode->i_gid = UDF_SB(inode->i_sb)->s_gid;
  1069. inode->i_nlink = le16_to_cpu(fe->fileLinkCount);
  1070. if (!inode->i_nlink)
  1071. inode->i_nlink = 1;
  1073. inode->i_size = le64_to_cpu(fe->informationLength);
  1074. UDF_I_LENEXTENTS(inode) = inode->i_size;
  1076. inode->i_mode = udf_convert_permissions(fe);
  1077. inode->i_mode &= ~UDF_SB(inode->i_sb)->s_umask;
  1079. UDF_I_NEXT_ALLOC_BLOCK(inode) = 0;
  1080. UDF_I_NEXT_ALLOC_GOAL(inode) = 0;
  1082. if (UDF_I_EXTENDED_FE(inode) == 0)
  1083. {
  1084. inode->i_blocks = le64_to_cpu(fe->logicalBlocksRecorded) <<
  1085. (inode->i_sb->s_blocksize_bits - 9);
  1087. if ( udf_stamp_to_time(&convtime, &convtime_usec,
  1088. lets_to_cpu(fe->accessTime)) )
  1089. {
  1090. inode->i_atime = convtime;
  1091. }
  1092. else
  1093. {
  1094. inode->i_atime = UDF_SB_RECORDTIME(inode->i_sb);
  1095. }
  1097. if ( udf_stamp_to_time(&convtime, &convtime_usec,
  1098. lets_to_cpu(fe->modificationTime)) )
  1099. {
  1100. inode->i_mtime = convtime;
  1101. UDF_I_UMTIME(inode) = convtime_usec;
  1102. }
  1103. else
  1104. {
  1105. inode->i_mtime = UDF_SB_RECORDTIME(inode->i_sb);
  1106. UDF_I_UMTIME(inode) = 0;
  1107. }
  1109. if ( udf_stamp_to_time(&convtime, &convtime_usec,
  1110. lets_to_cpu(fe->attrTime)) )
  1111. {
  1112. inode->i_ctime = convtime;
  1113. UDF_I_UCTIME(inode) = convtime_usec;
  1114. }
  1115. else
  1116. {
  1117. inode->i_ctime = UDF_SB_RECORDTIME(inode->i_sb);
  1118. UDF_I_UCTIME(inode) = 0;
  1119. }
  1121. UDF_I_UNIQUE(inode) = le64_to_cpu(fe->uniqueID);
  1122. UDF_I_LENEATTR(inode) = le32_to_cpu(fe->lengthExtendedAttr);
  1123. UDF_I_LENALLOC(inode) = le32_to_cpu(fe->lengthAllocDescs);
  1124. offset = sizeof(struct fileEntry) + UDF_I_LENEATTR(inode);
  1125. alen = offset + UDF_I_LENALLOC(inode);
  1126. }
  1127. else
  1128. {
  1129. inode->i_blocks = le64_to_cpu(efe->logicalBlocksRecorded) << 
  1130. (inode->i_sb->s_blocksize_bits - 9);
  1132. if ( udf_stamp_to_time(&convtime, &convtime_usec,
  1133. lets_to_cpu(efe->accessTime)) )
  1134. {
  1135. inode->i_atime = convtime;
  1136. }
  1137. else
  1138. {
  1139. inode->i_atime = UDF_SB_RECORDTIME(inode->i_sb);
  1140. }
  1142. if ( udf_stamp_to_time(&convtime, &convtime_usec,
  1143. lets_to_cpu(efe->modificationTime)) )
  1144. {
  1145. inode->i_mtime = convtime;
  1146. UDF_I_UMTIME(inode) = convtime_usec;
  1147. }
  1148. else
  1149. {
  1150. inode->i_mtime = UDF_SB_RECORDTIME(inode->i_sb);
  1151. UDF_I_UMTIME(inode) = 0;
  1152. }
  1154. if ( udf_stamp_to_time(&convtime, &convtime_usec,
  1155. lets_to_cpu(efe->createTime)) )
  1156. {
  1157. UDF_I_CRTIME(inode) = convtime;
  1158. UDF_I_UCRTIME(inode) = convtime_usec;
  1159. }
  1160. else
  1161. {
  1162. UDF_I_CRTIME(inode) = UDF_SB_RECORDTIME(inode->i_sb);
  1163. UDF_I_UCRTIME(inode) = 0;
  1164. }
  1166. if ( udf_stamp_to_time(&convtime, &convtime_usec,
  1167. lets_to_cpu(efe->attrTime)) )
  1168. {
  1169. inode->i_ctime = convtime;
  1170. UDF_I_UCTIME(inode) = convtime_usec;
  1171. }
  1172. else
  1173. {
  1174. inode->i_ctime = UDF_SB_RECORDTIME(inode->i_sb);
  1175. UDF_I_UCTIME(inode) = 0;
  1176. }
  1178. UDF_I_UNIQUE(inode) = le64_to_cpu(efe->uniqueID);
  1179. UDF_I_LENEATTR(inode) = le32_to_cpu(efe->lengthExtendedAttr);
  1180. UDF_I_LENALLOC(inode) = le32_to_cpu(efe->lengthAllocDescs);
  1181. offset = sizeof(struct extendedFileEntry) + UDF_I_LENEATTR(inode);
  1182. alen = offset + UDF_I_LENALLOC(inode);
  1183. }
  1185. switch (fe->icbTag.fileType)
  1186. {
  1187. case ICBTAG_FILE_TYPE_DIRECTORY:
  1188. {
  1189. inode->i_op = &udf_dir_inode_operations;
  1190. inode->i_fop = &udf_dir_operations;
  1191. inode->i_mode |= S_IFDIR;
  1192. inode->i_nlink ++;
  1193. break;
  1194. }
  1195. case ICBTAG_FILE_TYPE_REALTIME:
  1196. case ICBTAG_FILE_TYPE_REGULAR:
  1197. case ICBTAG_FILE_TYPE_UNDEF:
  1198. {
  1199. if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB)
  1200. inode->i_data.a_ops = &udf_adinicb_aops;
  1201. else
  1202. inode->i_data.a_ops = &udf_aops;
  1203. inode->i_op = &udf_file_inode_operations;
  1204. inode->i_fop = &udf_file_operations;
  1205. inode->i_mode |= S_IFREG;
  1206. break;
  1207. }
  1208. case ICBTAG_FILE_TYPE_BLOCK:
  1209. {
  1210. inode->i_mode |= S_IFBLK;
  1211. break;
  1212. }
  1213. case ICBTAG_FILE_TYPE_CHAR:
  1214. {
  1215. inode->i_mode |= S_IFCHR;
  1216. break;
  1217. }
  1218. case ICBTAG_FILE_TYPE_FIFO:
  1219. {
  1220. init_special_inode(inode, inode->i_mode | S_IFIFO, 0);
  1221. break;
  1222. }
  1223. case ICBTAG_FILE_TYPE_SYMLINK:
  1224. {
  1225. inode->i_data.a_ops = &udf_symlink_aops;
  1226. inode->i_op = &page_symlink_inode_operations;
  1227. inode->i_mode = S_IFLNK|S_IRWXUGO;
  1228. break;
  1229. }
  1230. default:
  1231. {
  1232. printk(KERN_ERR "udf: udf_fill_inode(ino %ld) failed unknown file type=%dn",
  1233. inode->i_ino, fe->icbTag.fileType);
  1234. make_bad_inode(inode);
  1235. return;
  1236. }
  1237. }
  1238. if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
  1239. {
  1240. struct buffer_head *tbh = NULL;
  1241. struct deviceSpec *dsea =
  1242. (struct deviceSpec *)
  1243. udf_get_extendedattr(inode, 12, 1, &tbh);
  1245. if (dsea)
  1246. {
  1247. init_special_inode(inode, inode->i_mode,
  1248. ((le32_to_cpu(dsea->majorDeviceIdent)) << 8) |
  1249. (le32_to_cpu(dsea->minorDeviceIdent) & 0xFF));
  1250. /* Developer ID ??? */
  1251. udf_release_data(tbh);
  1252. }
  1253. else
  1254. {
  1255. make_bad_inode(inode);
  1256. }
  1257. }
  1258. }
  1260. static mode_t
  1261. udf_convert_permissions(struct fileEntry *fe)
  1262. {
  1263. mode_t mode;
  1264. uint32_t permissions;
  1265. uint32_t flags;
  1267. permissions = le32_to_cpu(fe->permissions);
  1268. flags = le16_to_cpu(fe->icbTag.flags);
  1270. mode = (( permissions      ) & S_IRWXO) |
  1271. (( permissions >> 2 ) & S_IRWXG) |
  1272. (( permissions >> 4 ) & S_IRWXU) |
  1273. (( flags & ICBTAG_FLAG_SETUID) ? S_ISUID : 0) |
  1274. (( flags & ICBTAG_FLAG_SETGID) ? S_ISGID : 0) |
  1275. (( flags & ICBTAG_FLAG_STICKY) ? S_ISVTX : 0);
  1277. return mode;
  1278. }
  1280. /*
  1281.  * udf_write_inode
  1282.  *
  1283.  * PURPOSE
  1284.  * Write out the specified inode.
  1285.  *
  1286.  * DESCRIPTION
  1287.  * This routine is called whenever an inode is synced.
  1288.  * Currently this routine is just a placeholder.
  1289.  *
  1290.  * HISTORY
  1291.  * July 1, 1997 - Andrew E. Mileski
  1292.  * Written, tested, and released.
  1293.  */
  1295. void udf_write_inode(struct inode * inode, int sync)
  1296. {
  1297. lock_kernel();
  1298. udf_update_inode(inode, sync);
  1299. unlock_kernel();
  1300. }
  1302. int udf_sync_inode(struct inode * inode)
  1303. {
  1304. return udf_update_inode(inode, 1);
  1305. }
  1307. static int
  1308. udf_update_inode(struct inode *inode, int do_sync)
  1309. {
  1310. struct buffer_head *bh = NULL;
  1311. struct fileEntry *fe;
  1312. struct extendedFileEntry *efe;
  1313. uint32_t udfperms;
  1314. uint16_t icbflags;
  1315. uint16_t crclen;
  1316. int i;
  1317. timestamp cpu_time;
  1318. int err = 0;
  1320. bh = udf_tread(inode->i_sb,
  1321. udf_get_lb_pblock(inode->i_sb, UDF_I_LOCATION(inode), 0));
  1323. if (!bh)
  1324. {
  1325. udf_debug("bread failuren");
  1326. return -EIO;
  1327. }
  1328. fe = (struct fileEntry *)bh->b_data;
  1329. efe = (struct extendedFileEntry *)bh->b_data;
  1330. if (UDF_I_NEW_INODE(inode) == 1)
  1331. {
  1332. if (UDF_I_EXTENDED_FE(inode) == 0)
  1333. memset(bh->b_data, 0x00, sizeof(struct fileEntry));
  1334. else
  1335. memset(bh->b_data, 0x00, sizeof(struct extendedFileEntry));
  1336. memset(bh->b_data + udf_file_entry_alloc_offset(inode) +
  1337. UDF_I_LENALLOC(inode), 0x0, inode->i_sb->s_blocksize -
  1338. udf_file_entry_alloc_offset(inode) - UDF_I_LENALLOC(inode));
  1339. UDF_I_NEW_INODE(inode) = 0;
  1340. }
  1342. if (le16_to_cpu(fe->descTag.tagIdent) == TAG_IDENT_USE)
  1343. {
  1344. struct unallocSpaceEntry *use =
  1345. (struct unallocSpaceEntry *)bh->b_data;
  1347. use->lengthAllocDescs = cpu_to_le32(UDF_I_LENALLOC(inode));
  1348. crclen = sizeof(struct unallocSpaceEntry) + UDF_I_LENALLOC(inode) -
  1349. sizeof(tag);
  1350. use->descTag.tagLocation = cpu_to_le32(UDF_I_LOCATION(inode).logicalBlockNum);
  1351. use->descTag.descCRCLength = cpu_to_le16(crclen);
  1352. use->descTag.descCRC = cpu_to_le16(udf_crc((char *)use + sizeof(tag), crclen, 0));
  1354. use->descTag.tagChecksum = 0;
  1355. for (i=0; i<16; i++)
  1356. if (i != 4)
  1357. use->descTag.tagChecksum += ((uint8_t *)&(use->descTag))[i];
  1359. mark_buffer_dirty(bh);
  1360. udf_release_data(bh);
  1361. return err;
  1362. }
  1364. if (inode->i_uid != UDF_SB(inode->i_sb)->s_uid)
  1365. fe->uid = cpu_to_le32(inode->i_uid);
  1367. if (inode->i_gid != UDF_SB(inode->i_sb)->s_gid)
  1368. fe->gid = cpu_to_le32(inode->i_gid);
  1370. udfperms = ((inode->i_mode & S_IRWXO)     ) |
  1371. ((inode->i_mode & S_IRWXG) << 2) |
  1372. ((inode->i_mode & S_IRWXU) << 4);
  1374. udfperms |= (le32_to_cpu(fe->permissions) &
  1375. (FE_PERM_O_DELETE | FE_PERM_O_CHATTR |
  1376.  FE_PERM_G_DELETE | FE_PERM_G_CHATTR |
  1377.  FE_PERM_U_DELETE | FE_PERM_U_CHATTR));
  1378. fe->permissions = cpu_to_le32(udfperms);
  1380. if (S_ISDIR(inode->i_mode))
  1381. fe->fileLinkCount = cpu_to_le16(inode->i_nlink - 1);
  1382. else
  1383. fe->fileLinkCount = cpu_to_le16(inode->i_nlink);
  1385. fe->informationLength = cpu_to_le64(inode->i_size);
  1387. if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
  1388. {
  1389. regid *eid;
  1390. struct buffer_head *tbh = NULL;
  1391. struct deviceSpec *dsea =
  1392. (struct deviceSpec *)
  1393. udf_get_extendedattr(inode, 12, 1, &tbh);
  1395. if (!dsea)
  1396. {
  1397. dsea = (struct deviceSpec *)
  1398. udf_add_extendedattr(inode,
  1399. sizeof(struct deviceSpec) +
  1400. sizeof(regid), 12, 0x3, &tbh);
  1401. dsea->attrType = 12;
  1402. dsea->attrSubtype = 1;
  1403. dsea->attrLength = sizeof(struct deviceSpec) +
  1404. sizeof(regid);
  1405. dsea->impUseLength = sizeof(regid);
  1406. }
  1407. eid = (regid *)dsea->impUse;
  1408. memset(eid, 0, sizeof(regid));
  1409. strcpy(eid->ident, UDF_ID_DEVELOPER);
  1410. eid->identSuffix[0] = UDF_OS_CLASS_UNIX;
  1411. eid->identSuffix[1] = UDF_OS_ID_LINUX;
  1412. dsea->majorDeviceIdent = kdev_t_to_nr(inode->i_rdev) >> 8;
  1413. dsea->minorDeviceIdent = kdev_t_to_nr(inode->i_rdev) & 0xFF;
  1414. mark_buffer_dirty_inode(tbh, inode);
  1415. udf_release_data(tbh);
  1416. }
  1418. if (UDF_I_EXTENDED_FE(inode) == 0)
  1419. {
  1420. fe->logicalBlocksRecorded = cpu_to_le64(
  1421. (inode->i_blocks + (1 << (inode->i_sb->s_blocksize_bits - 9)) - 1) >>
  1422. (inode->i_sb->s_blocksize_bits - 9));
  1424. if (udf_time_to_stamp(&cpu_time, inode->i_atime, 0))
  1425. fe->accessTime = cpu_to_lets(cpu_time);
  1426. if (udf_time_to_stamp(&cpu_time, inode->i_mtime, UDF_I_UMTIME(inode)))
  1427. fe->modificationTime = cpu_to_lets(cpu_time);
  1428. if (udf_time_to_stamp(&cpu_time, inode->i_ctime, UDF_I_UCTIME(inode)))
  1429. fe->attrTime = cpu_to_lets(cpu_time);
  1430. memset(&(fe->impIdent), 0, sizeof(regid));
  1431. strcpy(fe->impIdent.ident, UDF_ID_DEVELOPER);
  1432. fe->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX;
  1433. fe->impIdent.identSuffix[1] = UDF_OS_ID_LINUX;
  1434. fe->uniqueID = cpu_to_le64(UDF_I_UNIQUE(inode));
  1435. fe->lengthExtendedAttr = cpu_to_le32(UDF_I_LENEATTR(inode));
  1436. fe->lengthAllocDescs = cpu_to_le32(UDF_I_LENALLOC(inode));
  1437. fe->descTag.tagIdent = le16_to_cpu(TAG_IDENT_FE);
  1438. crclen = sizeof(struct fileEntry);
  1439. }
  1440. else
  1441. {
  1442. efe->objectSize = cpu_to_le64(inode->i_size);
  1443. efe->logicalBlocksRecorded = cpu_to_le64(
  1444. (inode->i_blocks + (1 << (inode->i_sb->s_blocksize_bits - 9)) - 1) >>
  1445. (inode->i_sb->s_blocksize_bits - 9));
  1447. if (UDF_I_CRTIME(inode) >= inode->i_atime)
  1448. {
  1449. UDF_I_CRTIME(inode) = inode->i_atime;
  1450. UDF_I_UCRTIME(inode) = 0;
  1451. }
  1452. if (UDF_I_CRTIME(inode) > inode->i_mtime ||
  1453. (UDF_I_CRTIME(inode) == inode->i_mtime &&
  1454.  UDF_I_UCRTIME(inode) > UDF_I_UMTIME(inode)))
  1455. {
  1456. UDF_I_CRTIME(inode) = inode->i_mtime;
  1457. UDF_I_UCRTIME(inode) = UDF_I_UMTIME(inode);
  1458. }
  1459. if (UDF_I_CRTIME(inode) > inode->i_ctime ||
  1460. (UDF_I_CRTIME(inode) == inode->i_ctime &&
  1461.  UDF_I_UCRTIME(inode) > UDF_I_UCTIME(inode)))
  1462. {
  1463. UDF_I_CRTIME(inode) = inode->i_ctime;
  1464. UDF_I_UCRTIME(inode) = UDF_I_UCTIME(inode);
  1465. }
  1467. if (udf_time_to_stamp(&cpu_time, inode->i_atime, 0))
  1468. efe->accessTime = cpu_to_lets(cpu_time);
  1469. if (udf_time_to_stamp(&cpu_time, inode->i_mtime, UDF_I_UMTIME(inode)))
  1470. efe->modificationTime = cpu_to_lets(cpu_time);
  1471. if (udf_time_to_stamp(&cpu_time, UDF_I_CRTIME(inode), UDF_I_UCRTIME(inode)))
  1472. efe->createTime = cpu_to_lets(cpu_time);
  1473. if (udf_time_to_stamp(&cpu_time, inode->i_ctime, UDF_I_UCTIME(inode)))
  1474. efe->attrTime = cpu_to_lets(cpu_time);
  1476. memset(&(efe->impIdent), 0, sizeof(regid));
  1477. strcpy(efe->impIdent.ident, UDF_ID_DEVELOPER);
  1478. efe->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX;
  1479. efe->impIdent.identSuffix[1] = UDF_OS_ID_LINUX;
  1480. efe->uniqueID = cpu_to_le64(UDF_I_UNIQUE(inode));
  1481. efe->lengthExtendedAttr = cpu_to_le32(UDF_I_LENEATTR(inode));
  1482. efe->lengthAllocDescs = cpu_to_le32(UDF_I_LENALLOC(inode));
  1483. efe->descTag.tagIdent = le16_to_cpu(TAG_IDENT_EFE);
  1484. crclen = sizeof(struct extendedFileEntry);
  1485. }
  1486. if (UDF_I_STRAT4096(inode))
  1487. {
  1488. fe->icbTag.strategyType = cpu_to_le16(4096);
  1489. fe->icbTag.strategyParameter = cpu_to_le16(1);
  1490. fe->icbTag.numEntries = cpu_to_le16(2);
  1491. }
  1492. else
  1493. {
  1494. fe->icbTag.strategyType = cpu_to_le16(4);
  1495. fe->icbTag.numEntries = cpu_to_le16(1);
  1496. }
  1498. if (S_ISDIR(inode->i_mode))
  1499. fe->icbTag.fileType = ICBTAG_FILE_TYPE_DIRECTORY;
  1500. else if (S_ISREG(inode->i_mode))
  1501. fe->icbTag.fileType = ICBTAG_FILE_TYPE_REGULAR;
  1502. else if (S_ISLNK(inode->i_mode))
  1503. fe->icbTag.fileType = ICBTAG_FILE_TYPE_SYMLINK;
  1504. else if (S_ISBLK(inode->i_mode))
  1505. fe->icbTag.fileType = ICBTAG_FILE_TYPE_BLOCK;
  1506. else if (S_ISCHR(inode->i_mode))
  1507. fe->icbTag.fileType = ICBTAG_FILE_TYPE_CHAR;
  1508. else if (S_ISFIFO(inode->i_mode))
  1509. fe->icbTag.fileType = ICBTAG_FILE_TYPE_FIFO;
  1511. icbflags = UDF_I_ALLOCTYPE(inode) |
  1512. ((inode->i_mode & S_ISUID) ? ICBTAG_FLAG_SETUID : 0) |
  1513. ((inode->i_mode & S_ISGID) ? ICBTAG_FLAG_SETGID : 0) |
  1514. ((inode->i_mode & S_ISVTX) ? ICBTAG_FLAG_STICKY : 0) |
  1515. (le16_to_cpu(fe->icbTag.flags) &
  1516. ~(ICBTAG_FLAG_AD_MASK | ICBTAG_FLAG_SETUID |
  1517. ICBTAG_FLAG_SETGID | ICBTAG_FLAG_STICKY));
  1519. fe->icbTag.flags = cpu_to_le16(icbflags);
  1520. if (UDF_SB_UDFREV(inode->i_sb) >= 0x0200)
  1521. fe->descTag.descVersion = cpu_to_le16(3);
  1522. else
  1523. fe->descTag.descVersion = cpu_to_le16(2);
  1524. fe->descTag.tagSerialNum = cpu_to_le16(UDF_SB_SERIALNUM(inode->i_sb));
  1525. fe->descTag.tagLocation = cpu_to_le32(UDF_I_LOCATION(inode).logicalBlockNum);
  1526. crclen += UDF_I_LENEATTR(inode) + UDF_I_LENALLOC(inode) - sizeof(tag);
  1527. fe->descTag.descCRCLength = cpu_to_le16(crclen);
  1528. fe->descTag.descCRC = cpu_to_le16(udf_crc((char *)fe + sizeof(tag), crclen, 0));
  1530. fe->descTag.tagChecksum = 0;
  1531. for (i=0; i<16; i++)
  1532. if (i != 4)
  1533. fe->descTag.tagChecksum += ((uint8_t *)&(fe->descTag))[i];
  1535. /* write the data blocks */
  1536. mark_buffer_dirty(bh);
  1537. if (do_sync)
  1538. {
  1539. ll_rw_block(WRITE, 1, &bh);
  1540. wait_on_buffer(bh);
  1541. if (buffer_req(bh) && !buffer_uptodate(bh))
  1542. {
  1543. printk("IO error syncing udf inode [%s:%08lx]n",
  1544. bdevname(inode->i_dev), inode->i_ino);
  1545. err = -EIO;
  1546. }
  1547. }
  1548. udf_release_data(bh);
  1549. return err;
  1550. }
  1552. /*
  1553.  * udf_iget
  1554.  *
  1555.  * PURPOSE
  1556.  * Get an inode.
  1557.  *
  1558.  * DESCRIPTION
  1559.  * This routine replaces iget() and read_inode().
  1560.  *
  1561.  * HISTORY
  1562.  * October 3, 1997 - Andrew E. Mileski
  1563.  * Written, tested, and released.
  1564.  *
  1565.  * 12/19/98 dgb  Added semaphore and changed to be a wrapper of iget
  1566.  */
  1567. struct inode *
  1568. udf_iget(struct super_block *sb, lb_addr ino)
  1569. {
  1570. struct inode *inode;
  1571. unsigned long block;
  1573. block = udf_get_lb_pblock(sb, ino, 0);
  1575. /* Get the inode */
  1577. inode = iget(sb, block);
  1578. /* calls udf_read_inode() ! */
  1580. if (!inode)
  1581. {
  1582. printk(KERN_ERR "udf: iget() failedn");
  1583. return NULL;
  1584. }
  1585. else if (is_bad_inode(inode))
  1586. {
  1587. iput(inode);
  1588. return NULL;
  1589. }
  1590. else if (UDF_I_LOCATION(inode).logicalBlockNum == 0xFFFFFFFF &&
  1591. UDF_I_LOCATION(inode).partitionReferenceNum == 0xFFFF)
  1592. {
  1593. memcpy(&UDF_I_LOCATION(inode), &ino, sizeof(lb_addr));
  1594. __udf_read_inode(inode);
  1595. if (is_bad_inode(inode))
  1596. {
  1597. iput(inode);
  1598. return NULL;
  1599. }
  1600. }
  1602. if ( ino.logicalBlockNum >= UDF_SB_PARTLEN(sb, ino.partitionReferenceNum) )
  1603. {
  1604. udf_debug("block=%d, partition=%d out of rangen",
  1605. ino.logicalBlockNum, ino.partitionReferenceNum);
  1606. make_bad_inode(inode);
  1607. iput(inode);
  1608. return NULL;
  1609.   }
  1611. return inode;
  1612. }
  1614. int8_t udf_add_aext(struct inode *inode, lb_addr *bloc, int *extoffset,
  1615. lb_addr eloc, uint32_t elen, struct buffer_head **bh, int inc)
  1616. {
  1617. int adsize;
  1618. short_ad *sad = NULL;
  1619. long_ad *lad = NULL;
  1620. struct allocExtDesc *aed;
  1621. int8_t etype;
  1623. if (!(*bh))
  1624. {
  1625. if (!(*bh = udf_tread(inode->i_sb,
  1626. udf_get_lb_pblock(inode->i_sb, *bloc, 0))))
  1627. {
  1628. udf_debug("reading block %d failed!n",
  1629. udf_get_lb_pblock(inode->i_sb, *bloc, 0));
  1630. return -1;
  1631. }
  1632. }
  1634. if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_SHORT)
  1635. adsize = sizeof(short_ad);
  1636. else if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_LONG)
  1637. adsize = sizeof(long_ad);
  1638. else
  1639. return -1;
  1641. if (*extoffset + (2 * adsize) > inode->i_sb->s_blocksize)
  1642. {
  1643. char *sptr, *dptr;
  1644. struct buffer_head *nbh;
  1645. int err, loffset;
  1646. lb_addr obloc = *bloc;
  1648. if (!(bloc->logicalBlockNum = udf_new_block(inode->i_sb, inode,
  1649. obloc.partitionReferenceNum, obloc.logicalBlockNum, &err)))
  1650. {
  1651. return -1;
  1652. }
  1653. if (!(nbh = udf_tgetblk(inode->i_sb, udf_get_lb_pblock(inode->i_sb,
  1654. *bloc, 0))))
  1655. {
  1656. return -1;
  1657. }
  1658. lock_buffer(nbh);
  1659. memset(nbh->b_data, 0x00, inode->i_sb->s_blocksize);
  1660. mark_buffer_uptodate(nbh, 1);
  1661. unlock_buffer(nbh);
  1662. mark_buffer_dirty_inode(nbh, inode);
  1664. aed = (struct allocExtDesc *)(nbh->b_data);
  1665. if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT))
  1666. aed->previousAllocExtLocation = cpu_to_le32(obloc.logicalBlockNum);
  1667. if (*extoffset + adsize > inode->i_sb->s_blocksize)
  1668. {
  1669. loffset = *extoffset;
  1670. aed->lengthAllocDescs = cpu_to_le32(adsize);
  1671. sptr = (*bh)->b_data + *extoffset - adsize;
  1672. dptr = nbh->b_data + sizeof(struct allocExtDesc);
  1673. memcpy(dptr, sptr, adsize);
  1674. *extoffset = sizeof(struct allocExtDesc) + adsize;
  1675. }
  1676. else
  1677. {
  1678. loffset = *extoffset + adsize;
  1679. aed->lengthAllocDescs = cpu_to_le32(0);
  1680. sptr = (*bh)->b_data + *extoffset;
  1681. *extoffset = sizeof(struct allocExtDesc);
  1683. if (memcmp(&UDF_I_LOCATION(inode), &obloc, sizeof(lb_addr)))
  1684. {
  1685. aed = (struct allocExtDesc *)(*bh)->b_data;
  1686. aed->lengthAllocDescs =
  1687. cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) + adsize);
  1688. }
  1689. else
  1690. {
  1691. UDF_I_LENALLOC(inode) += adsize;
  1692. mark_inode_dirty(inode);
  1693. }
  1694. }
  1695. if (UDF_SB_UDFREV(inode->i_sb) >= 0x0200)
  1696. udf_new_tag(nbh->b_data, TAG_IDENT_AED, 3, 1,
  1697. bloc->logicalBlockNum, sizeof(tag));
  1698. else
  1699. udf_new_tag(nbh->b_data, TAG_IDENT_AED, 2, 1,
  1700. bloc->logicalBlockNum, sizeof(tag));
  1701. switch (UDF_I_ALLOCTYPE(inode))
  1702. {
  1703. case ICBTAG_FLAG_AD_SHORT:
  1704. {
  1705. sad = (short_ad *)sptr;
  1706. sad->extLength = cpu_to_le32(
  1707. EXT_NEXT_EXTENT_ALLOCDECS |
  1708. inode->i_sb->s_blocksize);
  1709. sad->extPosition = cpu_to_le32(bloc->logicalBlockNum);
  1710. break;
  1711. }
  1712. case ICBTAG_FLAG_AD_LONG:
  1713. {
  1714. lad = (long_ad *)sptr;
  1715. lad->extLength = cpu_to_le32(
  1716. EXT_NEXT_EXTENT_ALLOCDECS |
  1717. inode->i_sb->s_blocksize);
  1718. lad->extLocation = cpu_to_lelb(*bloc);
  1719. memset(lad->impUse, 0x00, sizeof(lad->impUse));
  1720. break;
  1721. }
  1722. }
  1723. if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) || UDF_SB_UDFREV(inode->i_sb) >= 0x0201)
  1724. udf_update_tag((*bh)->b_data, loffset);
  1725. else
  1726. udf_update_tag((*bh)->b_data, sizeof(struct allocExtDesc));
  1727. mark_buffer_dirty_inode(*bh, inode);
  1728. udf_release_data(*bh);
  1729. *bh = nbh;
  1730. }
  1732. etype = udf_write_aext(inode, *bloc, extoffset, eloc, elen, *bh, inc);
  1734. if (!memcmp(&UDF_I_LOCATION(inode), bloc, sizeof(lb_addr)))
  1735. {
  1736. UDF_I_LENALLOC(inode) += adsize;
  1737. mark_inode_dirty(inode);
  1738. }
  1739. else
  1740. {
  1741. aed = (struct allocExtDesc *)(*bh)->b_data;
  1742. aed->lengthAllocDescs =
  1743. cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) + adsize);
  1744. if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) || UDF_SB_UDFREV(inode->i_sb) >= 0x0201)
  1745. udf_update_tag((*bh)->b_data, *extoffset + (inc ? 0 : adsize));
  1746. else
  1747. udf_update_tag((*bh)->b_data, sizeof(struct allocExtDesc));
  1748. mark_buffer_dirty_inode(*bh, inode);
  1749. }
  1751. return etype;
  1752. }
  1754. int8_t udf_write_aext(struct inode *inode, lb_addr bloc, int *extoffset,
  1755.     lb_addr eloc, uint32_t elen, struct buffer_head *bh, int inc)
  1756. {
  1757. int adsize;
  1758. short_ad *sad = NULL;
  1759. long_ad *lad = NULL;
  1761. if (!(bh))
  1762. {
  1763. if (!(bh = udf_tread(inode->i_sb,
  1764. udf_get_lb_pblock(inode->i_sb, bloc, 0))))
  1765. {
  1766. udf_debug("reading block %d failed!n",
  1767. udf_get_lb_pblock(inode->i_sb, bloc, 0));
  1768. return -1;
  1769. }
  1770. }
  1771. else
  1772. atomic_inc(&bh->b_count);
  1774. if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_SHORT)
  1775. adsize = sizeof(short_ad);
  1776. else if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_LONG)
  1777. adsize = sizeof(long_ad);
  1778. else
  1779. return -1;
  1781. switch (UDF_I_ALLOCTYPE(inode))
  1782. {
  1783. case ICBTAG_FLAG_AD_SHORT:
  1784. {
  1785. sad = (short_ad *)((bh)->b_data + *extoffset);
  1786. sad->extLength = cpu_to_le32(elen);
  1787. sad->extPosition = cpu_to_le32(eloc.logicalBlockNum);
  1788. break;
  1789. }
  1790. case ICBTAG_FLAG_AD_LONG:
  1791. {
  1792. lad = (long_ad *)((bh)->b_data + *extoffset);
  1793. lad->extLength = cpu_to_le32(elen);
  1794. lad->extLocation = cpu_to_lelb(eloc);
  1795. memset(lad->impUse, 0x00, sizeof(lad->impUse));
  1796. break;
  1797. }
  1798. }
  1800. if (memcmp(&UDF_I_LOCATION(inode), &bloc, sizeof(lb_addr)))
  1801. {
  1802. if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) || UDF_SB_UDFREV(inode->i_sb) >= 0x0201)
  1803. {
  1804. struct allocExtDesc *aed = (struct allocExtDesc *)(bh)->b_data;
  1805. udf_update_tag((bh)->b_data,
  1806. le32_to_cpu(aed->lengthAllocDescs) + sizeof(struct allocExtDesc));
  1807. }
  1808. mark_buffer_dirty_inode(bh, inode);
  1809. }
  1810. else
  1811. {
  1812. mark_inode_dirty(inode);
  1813. mark_buffer_dirty(bh);
  1814. }
  1816. if (inc)
  1817. *extoffset += adsize;
  1818. udf_release_data(bh);
  1819. return (elen >> 30);
  1820. }
  1822. int8_t udf_next_aext(struct inode *inode, lb_addr *bloc, int *extoffset,
  1823. lb_addr *eloc, uint32_t *elen, struct buffer_head **bh, int inc)
  1824. {
  1825. uint16_t tagIdent;
  1826. int pos, alen;
  1827. int8_t etype;
  1829. if (!(*bh))
  1830. {
  1831. if (!(*bh = udf_tread(inode->i_sb,
  1832. udf_get_lb_pblock(inode->i_sb, *bloc, 0))))
  1833. {
  1834. udf_debug("reading block %d failed!n",
  1835. udf_get_lb_pblock(inode->i_sb, *bloc, 0));
  1836. return -1;
  1837. }
  1838. }
  1840. tagIdent = le16_to_cpu(((tag *)(*bh)->b_data)->tagIdent);
  1842. if (!memcmp(&UDF_I_LOCATION(inode), bloc, sizeof(lb_addr)))
  1843. {
  1844. if (tagIdent == TAG_IDENT_FE || tagIdent == TAG_IDENT_EFE ||
  1845. UDF_I_NEW_INODE(inode))
  1846. {
  1847. pos = udf_file_entry_alloc_offset(inode);
  1848. alen = UDF_I_LENALLOC(inode) + pos;
  1849. }
  1850. else if (tagIdent == TAG_IDENT_USE)
  1851. {
  1852. pos = sizeof(struct unallocSpaceEntry);
  1853. alen = UDF_I_LENALLOC(inode) + pos;
  1854. }
  1855. else
  1856. return -1;
  1857. }
  1858. else if (tagIdent == TAG_IDENT_AED)
  1859. {
  1860. struct allocExtDesc *aed = (struct allocExtDesc *)(*bh)->b_data;
  1862. pos = sizeof(struct allocExtDesc);
  1863. alen = le32_to_cpu(aed->lengthAllocDescs) + pos;
  1864. }
  1865. else
  1866. return -1;
  1868. if (!(*extoffset))
  1869. *extoffset = pos;
  1871. switch (UDF_I_ALLOCTYPE(inode))
  1872. {
  1873. case ICBTAG_FLAG_AD_SHORT:
  1874. {
  1875. short_ad *sad;
  1877. if (!(sad = udf_get_fileshortad((*bh)->b_data, alen, extoffset, inc)))
  1878. return -1;
  1880. if ((etype = le32_to_cpu(sad->extLength) >> 30) == (EXT_NEXT_EXTENT_ALLOCDECS >> 30))
  1881. {
  1882. bloc->logicalBlockNum = le32_to_cpu(sad->extPosition);
  1883. *extoffset = 0;
  1884. udf_release_data(*bh);
  1885. *bh = NULL;
  1886. return udf_next_aext(inode, bloc, extoffset, eloc, elen, bh, inc);
  1887. }
  1888. else
  1889. {
  1890. eloc->logicalBlockNum = le32_to_cpu(sad->extPosition);
  1891. eloc->partitionReferenceNum = UDF_I_LOCATION(inode).partitionReferenceNum;
  1892. *elen = le32_to_cpu(sad->extLength) & UDF_EXTENT_LENGTH_MASK;
  1893. }
  1894. break;
  1895. }
  1896. case ICBTAG_FLAG_AD_LONG:
  1897. {
  1898. long_ad *lad;
  1900. if (!(lad = udf_get_filelongad((*bh)->b_data, alen, extoffset, inc)))
  1901. return -1;
  1903. if ((etype = le32_to_cpu(lad->extLength) >> 30) == (EXT_NEXT_EXTENT_ALLOCDECS >> 30))
  1904. {
  1905. *bloc = lelb_to_cpu(lad->extLocation);
  1906. *extoffset = 0;
  1907. udf_release_data(*bh);
  1908. *bh = NULL;
  1909. return udf_next_aext(inode, bloc, extoffset, eloc, elen, bh, inc);
  1910. }
  1911. else
  1912. {
  1913. *eloc = lelb_to_cpu(lad->extLocation);
  1914. *elen = le32_to_cpu(lad->extLength) & UDF_EXTENT_LENGTH_MASK;
  1915. }
  1916. break;
  1917. }
  1918. case ICBTAG_FLAG_AD_IN_ICB:
  1919. {
  1920. if (UDF_I_LENALLOC(inode) == 0)
  1921. return -1;
  1922. etype = (EXT_RECORDED_ALLOCATED >> 30);
  1923. *eloc = UDF_I_LOCATION(inode);
  1924. *elen = UDF_I_LENALLOC(inode);
  1925. break;
  1926. }
  1927. default:
  1928. {
  1929. udf_debug("alloc_type = %d unsupportedn", UDF_I_ALLOCTYPE(inode));
  1930. return -1;
  1931. }
  1932. }
  1933. if (*elen)
  1934. return etype;
  1936. udf_debug("Empty Extent, inode=%ld, alloctype=%d, eloc=%d, elen=%d, etype=%d, extoffset=%dn",
  1937. inode->i_ino, UDF_I_ALLOCTYPE(inode), eloc->logicalBlockNum, *elen, etype, *extoffset);
  1938. if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_SHORT)
  1939. *extoffset -= sizeof(short_ad);
  1940. else if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_LONG)
  1941. *extoffset -= sizeof(long_ad);
  1942. return -1;
  1943. }
  1945. int8_t udf_current_aext(struct inode *inode, lb_addr *bloc, int *extoffset,
  1946. lb_addr *eloc, uint32_t *elen, struct buffer_head **bh, int inc)
  1947. {
  1948. int pos, alen;
  1949. int8_t etype;
  1951. if (!(*bh))
  1952. {
  1953. if (!(*bh = udf_tread(inode->i_sb,
  1954. udf_get_lb_pblock(inode->i_sb, *bloc, 0))))
  1955. {
  1956. udf_debug("reading block %d failed!n",
  1957. udf_get_lb_pblock(inode->i_sb, *bloc, 0));
  1958. return -1;
  1959. }
  1960. }
  1962. if (!memcmp(&UDF_I_LOCATION(inode), bloc, sizeof(lb_addr)))
  1963. {
  1964. if (!(UDF_I_EXTENDED_FE(inode)))
  1965. pos = sizeof(struct fileEntry) + UDF_I_LENEATTR(inode);
  1966. else
  1967. pos = sizeof(struct extendedFileEntry) + UDF_I_LENEATTR(inode);
  1968. alen = UDF_I_LENALLOC(inode) + pos;
  1969. }
  1970. else
  1971. {
  1972. struct allocExtDesc *aed = (struct allocExtDesc *)(*bh)->b_data;
  1974. pos = sizeof(struct allocExtDesc);
  1975. alen = le32_to_cpu(aed->lengthAllocDescs) + pos;
  1976. }
  1978. if (!(*extoffset))
  1979. *extoffset = pos;
  1981. switch (UDF_I_ALLOCTYPE(inode))
  1982. {
  1983. case ICBTAG_FLAG_AD_SHORT:
  1984. {
  1985. short_ad *sad;
  1987. if (!(sad = udf_get_fileshortad((*bh)->b_data, alen, extoffset, inc)))
  1988. return -1;
  1990. etype = le32_to_cpu(sad->extLength) >> 30;
  1991. eloc->logicalBlockNum = le32_to_cpu(sad->extPosition);
  1992. eloc->partitionReferenceNum = UDF_I_LOCATION(inode).partitionReferenceNum;
  1993. *elen = le32_to_cpu(sad->extLength) & UDF_EXTENT_LENGTH_MASK;
  1994. break;
  1995. }
  1996. case ICBTAG_FLAG_AD_LONG:
  1997. {
  1998. long_ad *lad;
  2000. if (!(lad = udf_get_filelongad((*bh)->b_data, alen, extoffset, inc)))
  2001. return -1;
  2003. etype = le32_to_cpu(lad->extLength) >> 30;
  2004. *eloc = lelb_to_cpu(lad->extLocation);
  2005. *elen = le32_to_cpu(lad->extLength) & UDF_EXTENT_LENGTH_MASK;
  2006. break;
  2007. }
  2008. default:
  2009. {
  2010. udf_debug("alloc_type = %d unsupportedn", UDF_I_ALLOCTYPE(inode));
  2011. return -1;
  2012. }
  2013. }
  2014. if (*elen)
  2015. return etype;
  2017. udf_debug("Empty Extent!n");
  2018. if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_SHORT)
  2019. *extoffset -= sizeof(short_ad);
  2020. else if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_LONG)
  2021. *extoffset -= sizeof(long_ad);
  2022. return -1;
  2023. }
  2025. int8_t udf_insert_aext(struct inode *inode, lb_addr bloc, int extoffset,
  2026. lb_addr neloc, uint32_t nelen, struct buffer_head *bh)
  2027. {
  2028. lb_addr oeloc;
  2029. uint32_t oelen;
  2030. int8_t etype;
  2032. if (!bh)
  2033. {
  2034. if (!(bh = udf_tread(inode->i_sb,
  2035. udf_get_lb_pblock(inode->i_sb, bloc, 0))))
  2036. {
  2037. udf_debug("reading block %d failed!n",
  2038. udf_get_lb_pblock(inode->i_sb, bloc, 0));
  2039. return -1;
  2040. }
  2041. }
  2042. else
  2043. atomic_inc(&bh->b_count);
  2045. while ((etype = udf_next_aext(inode, &bloc, &extoffset, &oeloc, &oelen, &bh, 0)) != -1)
  2046. {
  2047. udf_write_aext(inode, bloc, &extoffset, neloc, nelen, bh, 1);
  2049. neloc = oeloc;
  2050. nelen = (etype << 30) | oelen;
  2051. }
  2052. udf_add_aext(inode, &bloc, &extoffset, neloc, nelen, &bh, 1);
  2053. udf_release_data(bh);
  2054. return (nelen >> 30);
  2055. }
  2057. int8_t udf_delete_aext(struct inode *inode, lb_addr nbloc, int nextoffset,
  2058. lb_addr eloc, uint32_t elen, struct buffer_head *nbh)
  2059. {
  2060. struct buffer_head *obh;
  2061. lb_addr obloc;
  2062. int oextoffset, adsize;
  2063. int8_t etype;
  2064. struct allocExtDesc *aed;
  2066. if (!(nbh))
  2067. {
  2068. if (!(nbh = udf_tread(inode->i_sb,
  2069. udf_get_lb_pblock(inode->i_sb, nbloc, 0))))
  2070. {
  2071. udf_debug("reading block %d failed!n",
  2072. udf_get_lb_pblock(inode->i_sb, nbloc, 0));
  2073. return -1;
  2074. }
  2075. }
  2076. else
  2077. atomic_inc(&nbh->b_count);
  2078. atomic_inc(&nbh->b_count);
  2080. if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_SHORT)
  2081. adsize = sizeof(short_ad);
  2082. else if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_LONG)
  2083. adsize = sizeof(long_ad);
  2084. else
  2085. adsize = 0;
  2087. obh = nbh;
  2088. obloc = nbloc;
  2089. oextoffset = nextoffset;
  2091. if (udf_next_aext(inode, &nbloc, &nextoffset, &eloc, &elen, &nbh, 1) == -1)
  2092. return -1;
  2094. while ((etype = udf_next_aext(inode, &nbloc, &nextoffset, &eloc, &elen, &nbh, 1)) != -1)
  2095. {
  2096. udf_write_aext(inode, obloc, &oextoffset, eloc, (etype << 30) | elen, obh, 1);
  2097. if (memcmp(&nbloc, &obloc, sizeof(lb_addr)))
  2098. {
  2099. obloc = nbloc;
  2100. udf_release_data(obh);
  2101. atomic_inc(&nbh->b_count);
  2102. obh = nbh;
  2103. oextoffset = nextoffset - adsize;
  2104. }
  2105. }
  2106. memset(&eloc, 0x00, sizeof(lb_addr));
  2107. elen = 0;
  2109. if (memcmp(&nbloc, &obloc, sizeof(lb_addr)))
  2110. {
  2111. udf_free_blocks(inode->i_sb, inode, nbloc, 0, 1);
  2112. udf_write_aext(inode, obloc, &oextoffset, eloc, elen, obh, 1);
  2113. udf_write_aext(inode, obloc, &oextoffset, eloc, elen, obh, 1);
  2114. if (!memcmp(&UDF_I_LOCATION(inode), &obloc, sizeof(lb_addr)))
  2115. {
  2116. UDF_I_LENALLOC(inode) -= (adsize * 2);
  2117. mark_inode_dirty(inode);
  2118. }
  2119. else
  2120. {
  2121. aed = (struct allocExtDesc *)(obh)->b_data;
  2122. aed->lengthAllocDescs =
  2123. cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) - (2*adsize));
  2124. if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) || UDF_SB_UDFREV(inode->i_sb) >= 0x0201)
  2125. udf_update_tag((obh)->b_data, oextoffset - (2*adsize));
  2126. else
  2127. udf_update_tag((obh)->b_data, sizeof(struct allocExtDesc));
  2128. mark_buffer_dirty_inode(obh, inode);
  2129. }
  2130. }
  2131. else
  2132. {
  2133. udf_write_aext(inode, obloc, &oextoffset, eloc, elen, obh, 1);
  2134. if (!memcmp(&UDF_I_LOCATION(inode), &obloc, sizeof(lb_addr)))
  2135. {
  2136. UDF_I_LENALLOC(inode) -= adsize;
  2137. mark_inode_dirty(inode);
  2138. }
  2139. else
  2140. {
  2141. aed = (struct allocExtDesc *)(obh)->b_data;
  2142. aed->lengthAllocDescs =
  2143. cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) - adsize);
  2144. if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) || UDF_SB_UDFREV(inode->i_sb) >= 0x0201)
  2145. udf_update_tag((obh)->b_data, oextoffset - adsize);
  2146. else
  2147. udf_update_tag((obh)->b_data, sizeof(struct allocExtDesc));
  2148. mark_buffer_dirty_inode(obh, inode);
  2149. }
  2150. }
  2152. udf_release_data(nbh);
  2153. udf_release_data(obh);
  2154. return (elen >> 30);
  2155. }
  2157. int8_t inode_bmap(struct inode *inode, int block, lb_addr *bloc, uint32_t *extoffset,
  2158. lb_addr *eloc, uint32_t *elen, uint32_t *offset, struct buffer_head **bh)
  2159. {
  2160. uint64_t lbcount = 0, bcount = (uint64_t)block << inode->i_sb->s_blocksize_bits;
  2161. int8_t etype;
  2163. if (block < 0)
  2164. {
  2165. printk(KERN_ERR "udf: inode_bmap: block < 0n");
  2166. return -1;
  2167. }
  2168. if (!inode)
  2169. {
  2170. printk(KERN_ERR "udf: inode_bmap: NULL inoden");
  2171. return -1;
  2172. }
  2174. *extoffset = 0;
  2175. *elen = 0;
  2176. *bloc = UDF_I_LOCATION(inode);
  2178. do
  2179. {
  2180. if ((etype = udf_next_aext(inode, bloc, extoffset, eloc, elen, bh, 1)) == -1)
  2181. {
  2182. *offset = bcount - lbcount;
  2183. UDF_I_LENEXTENTS(inode) = lbcount;
  2184. return -1;
  2185. }
  2186. lbcount += *elen;
  2187. } while (lbcount <= bcount);
  2189. *offset = bcount + *elen - lbcount;
  2191. return etype;
  2192. }
  2194. long udf_block_map(struct inode *inode, long block)
  2195. {
  2196. lb_addr eloc, bloc;
  2197. uint32_t offset, extoffset, elen;
  2198. struct buffer_head *bh = NULL;
  2199. int ret;
  2201. lock_kernel();
  2203. if (inode_bmap(inode, block, &bloc, &extoffset, &eloc, &elen, &offset, &bh) == (EXT_RECORDED_ALLOCATED >> 30))
  2204. ret = udf_get_lb_pblock(inode->i_sb, eloc, offset >> inode->i_sb->s_blocksize_bits);
  2205. else
  2206. ret = 0;
  2208. unlock_kernel();
  2210. if (bh)
  2211. udf_release_data(bh);
  2213. if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_VARCONV))
  2214. return udf_fixed_to_variable(ret);
  2215. else
  2216. return ret;
  2217. }