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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
super.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：48k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

super.c：源码内容
  1. /*
  2.  * super.c
  3.  *
  4.  * PURPOSE
  5.  *  Super block routines for the OSTA-UDF(tm) filesystem.
  6.  *
  7.  * DESCRIPTION
  8.  *  OSTA-UDF(tm) = Optical Storage Technology Association
  9.  *  Universal Disk Format.
  10.  *
  11.  *  This code is based on version 2.00 of the UDF specification,
  12.  *  and revision 3 of the ECMA 167 standard [equivalent to ISO 13346].
  13.  *    http://www.osta.org/
  14.  *    http://www.ecma.ch/
  15.  *    http://www.iso.org/
  16.  *
  17.  * CONTACTS
  18.  *  E-mail regarding any portion of the Linux UDF file system should be
  19.  *  directed to the development team mailing list (run by majordomo):
  20.  *   linux_udf@hpesjro.fc.hp.com
  21.  *
  22.  * COPYRIGHT
  23.  *  This file is distributed under the terms of the GNU General Public
  24.  *  License (GPL). Copies of the GPL can be obtained from:
  25.  *    ftp://prep.ai.mit.edu/pub/gnu/GPL
  26.  *  Each contributing author retains all rights to their own work.
  27.  *
  28.  *  (C) 1998 Dave Boynton
  29.  *  (C) 1998-2000 Ben Fennema
  30.  *  (C) 2000 Stelias Computing Inc
  31.  *
  32.  * HISTORY
  33.  *
  34.  *  09/24/98 dgb  changed to allow compiling outside of kernel, and
  35.  *                added some debugging.
  36.  *  10/01/98 dgb  updated to allow (some) possibility of compiling w/2.0.34
  37.  *  10/16/98      attempting some multi-session support
  38.  *  10/17/98      added freespace count for "df"
  39.  *  11/11/98 gr   added novrs option
  40.  *  11/26/98 dgb  added fileset,anchor mount options
  41.  *  12/06/98 blf  really hosed things royally. vat/sparing support. sequenced vol descs
  42.  *                rewrote option handling based on isofs
  43.  *  12/20/98      find the free space bitmap (if it exists)
  44.  */
  46. #include "udfdecl.h"    
  48. #include <linux/config.h>
  49. #include <linux/version.h>
  50. #include <linux/blkdev.h>
  51. #include <linux/slab.h>
  52. #include <linux/kernel.h>
  53. #include <linux/locks.h>
  54. #include <linux/module.h>
  55. #include <linux/stat.h>
  56. #include <linux/cdrom.h>
  57. #include <linux/nls.h>
  58. #include <asm/byteorder.h>
  60. #include <linux/udf_fs.h>
  61. #include "udf_sb.h"
  62. #include "udf_i.h"
  64. #include <linux/init.h>
  65. #include <asm/uaccess.h>
  67. #define VDS_POS_PRIMARY_VOL_DESC 0
  68. #define VDS_POS_UNALLOC_SPACE_DESC 1
  69. #define VDS_POS_LOGICAL_VOL_DESC 2
  70. #define VDS_POS_PARTITION_DESC 3
  71. #define VDS_POS_IMP_USE_VOL_DESC 4
  72. #define VDS_POS_VOL_DESC_PTR 5
  73. #define VDS_POS_TERMINATING_DESC 6
  74. #define VDS_POS_LENGTH 7
  76. static char error_buf[1024];
  78. /* These are the "meat" - everything else is stuffing */
  79. static struct super_block *udf_read_super(struct super_block *, void *, int);
  80. static void udf_put_super(struct super_block *);
  81. static void udf_write_super(struct super_block *);
  82. static int udf_remount_fs(struct super_block *, int *, char *);
  83. static int udf_check_valid(struct super_block *, int, int);
  84. static int udf_vrs(struct super_block *sb, int silent);
  85. static int udf_load_partition(struct super_block *, lb_addr *);
  86. static int udf_load_logicalvol(struct super_block *, struct buffer_head *, lb_addr *);
  87. static void udf_load_logicalvolint(struct super_block *, extent_ad);
  88. static void udf_find_anchor(struct super_block *);
  89. static int udf_find_fileset(struct super_block *, lb_addr *, lb_addr *);
  90. static void udf_load_pvoldesc(struct super_block *, struct buffer_head *);
  91. static void udf_load_fileset(struct super_block *, struct buffer_head *, lb_addr *);
  92. static void udf_load_partdesc(struct super_block *, struct buffer_head *);
  93. static void udf_open_lvid(struct super_block *);
  94. static void udf_close_lvid(struct super_block *);
  95. static unsigned int udf_count_free(struct super_block *);
  96. static int udf_statfs(struct super_block *, struct statfs *);
  98. /* UDF filesystem type */
  99. static DECLARE_FSTYPE_DEV(udf_fstype, "udf", udf_read_super);
  101. /* Superblock operations */
  102. static struct super_operations udf_sb_ops = {
  103. read_inode: udf_read_inode,
  104. write_inode: udf_write_inode,
  105. put_inode: udf_put_inode,
  106. delete_inode: udf_delete_inode,
  107. put_super: udf_put_super,
  108. write_super: udf_write_super,
  109. statfs: udf_statfs,
  110. remount_fs: udf_remount_fs,
  111. };
  113. struct udf_options
  114. {
  115. unsigned char novrs;
  116. unsigned int blocksize;
  117. unsigned int session;
  118. unsigned int lastblock;
  119. unsigned int anchor;
  120. unsigned int volume;
  121. unsigned short partition;
  122. unsigned int fileset;
  123. unsigned int rootdir;
  124. unsigned int flags;
  125. mode_t umask;
  126. gid_t gid;
  127. uid_t uid;
  128. struct nls_table *nls_map;
  129. };
  131. static int __init init_udf_fs(void)
  132. {
  133. printk(KERN_NOTICE "udf: registering filesystemn");
  134. return register_filesystem(&udf_fstype);
  135. }
  137. static void __exit exit_udf_fs(void)
  138. {
  139. printk(KERN_NOTICE "udf: unregistering filesystemn");
  140. unregister_filesystem(&udf_fstype);
  141. }
  143. EXPORT_NO_SYMBOLS;
  145. module_init(init_udf_fs)
  146. module_exit(exit_udf_fs)
  148. /*
  149.  * udf_parse_options
  150.  *
  151.  * PURPOSE
  152.  * Parse mount options.
  153.  *
  154.  * DESCRIPTION
  155.  * The following mount options are supported:
  156.  *
  157.  * gid= Set the default group.
  158.  * umask= Set the default umask.
  159.  * uid= Set the default user.
  160.  * bs= Set the block size.
  161.  * unhide Show otherwise hidden files.
  162.  * undelete Show deleted files in lists.
  163.  * adinicb Embed data in the inode (default)
  164.  * noadinicb Don't embed data in the inode
  165.  * shortad Use short ad's
  166.  * longad Use long ad's (default)
  167.  * nostrict Unset strict conformance
  168.  * iocharset= Set the NLS character set
  169.  *
  170.  * The remaining are for debugging and disaster recovery:
  171.  *
  172.  * novrs Skip volume sequence recognition 
  173.  *
  174.  * The following expect a offset from 0.
  175.  *
  176.  * session= Set the CDROM session (default= last session)
  177.  * anchor= Override standard anchor location. (default= 256)
  178.  * volume= Override the VolumeDesc location. (unused)
  179.  * partition= Override the PartitionDesc location. (unused)
  180.  * lastblock= Set the last block of the filesystem/
  181.  *
  182.  * The following expect a offset from the partition root.
  183.  *
  184.  * fileset= Override the fileset block location. (unused)
  185.  * rootdir= Override the root directory location. (unused)
  186.  * WARNING: overriding the rootdir to a non-directory may
  187.  * yield highly unpredictable results.
  188.  *
  189.  * PRE-CONDITIONS
  190.  * options Pointer to mount options string.
  191.  * uopts Pointer to mount options variable.
  192.  *
  193.  * POST-CONDITIONS
  194.  * <return> 0 Mount options parsed okay.
  195.  * <return> -1 Error parsing mount options.
  196.  *
  197.  * HISTORY
  198.  * July 1, 1997 - Andrew E. Mileski
  199.  * Written, tested, and released.
  200.  */
  202. static int
  203. udf_parse_options(char *options, struct udf_options *uopt)
  204. {
  205. char *opt, *val;
  207. uopt->novrs = 0;
  208. uopt->blocksize = 2048;
  209. uopt->partition = 0xFFFF;
  210. uopt->session = 0xFFFFFFFF;
  211. uopt->lastblock = 0;
  212. uopt->anchor = 0;
  213. uopt->volume = 0xFFFFFFFF;
  214. uopt->rootdir = 0xFFFFFFFF;
  215. uopt->fileset = 0xFFFFFFFF;
  216. uopt->nls_map = NULL;
  218. if (!options)
  219. return 1;
  221. for (opt = strtok(options, ","); opt; opt = strtok(NULL, ","))
  222. {
  223. /* Make "opt=val" into two strings */
  224. val = strchr(opt, '=');
  225. if (val)
  226. *(val++) = 0;
  227. if (!strcmp(opt, "novrs") && !val)
  228. uopt->novrs = 1;
  229. else if (!strcmp(opt, "bs") && val)
  230. uopt->blocksize = simple_strtoul(val, NULL, 0);
  231. else if (!strcmp(opt, "unhide") && !val)
  232. uopt->flags |= (1 << UDF_FLAG_UNHIDE);
  233. else if (!strcmp(opt, "undelete") && !val)
  234. uopt->flags |= (1 << UDF_FLAG_UNDELETE);
  235. else if (!strcmp(opt, "noadinicb") && !val)
  236. uopt->flags &= ~(1 << UDF_FLAG_USE_AD_IN_ICB);
  237. else if (!strcmp(opt, "adinicb") && !val)
  238. uopt->flags |= (1 << UDF_FLAG_USE_AD_IN_ICB);
  239. else if (!strcmp(opt, "shortad") && !val)
  240. uopt->flags |= (1 << UDF_FLAG_USE_SHORT_AD);
  241. else if (!strcmp(opt, "longad") && !val)
  242. uopt->flags &= ~(1 << UDF_FLAG_USE_SHORT_AD);
  243. else if (!strcmp(opt, "gid") && val)
  244. uopt->gid = simple_strtoul(val, NULL, 0);
  245. else if (!strcmp(opt, "umask") && val)
  246. uopt->umask = simple_strtoul(val, NULL, 0);
  247. else if (!strcmp(opt, "nostrict") && !val)
  248. uopt->flags &= ~(1 << UDF_FLAG_STRICT);
  249. else if (!strcmp(opt, "uid") && val)
  250. uopt->uid = simple_strtoul(val, NULL, 0);
  251. else if (!strcmp(opt, "session") && val)
  252. uopt->session = simple_strtoul(val, NULL, 0);
  253. else if (!strcmp(opt, "lastblock") && val)
  254. uopt->lastblock = simple_strtoul(val, NULL, 0);
  255. else if (!strcmp(opt, "anchor") && val)
  256. uopt->anchor = simple_strtoul(val, NULL, 0);
  257. else if (!strcmp(opt, "volume") && val)
  258. uopt->volume = simple_strtoul(val, NULL, 0);
  259. else if (!strcmp(opt, "partition") && val)
  260. uopt->partition = simple_strtoul(val, NULL, 0);
  261. else if (!strcmp(opt, "fileset") && val)
  262. uopt->fileset = simple_strtoul(val, NULL, 0);
  263. else if (!strcmp(opt, "rootdir") && val)
  264. uopt->rootdir = simple_strtoul(val, NULL, 0);
  265. #ifdef CONFIG_NLS
  266. else if (!strcmp(opt, "iocharset") && val)
  267. {
  268. uopt->nls_map = load_nls(val);
  269. uopt->flags |= (1 << UDF_FLAG_NLS_MAP);
  270. }
  271. #endif
  272. else if (!strcmp(opt, "utf8") && !val)
  273. uopt->flags |= (1 << UDF_FLAG_UTF8);
  274. else if (val)
  275. {
  276. printk(KERN_ERR "udf: bad mount option "%s=%s"n",
  277. opt, val);
  278. return 0;
  279. }
  280. else
  281. {
  282. printk(KERN_ERR "udf: bad mount option "%s"n",
  283. opt);
  284. return 0;
  285. }
  286. }
  287. return 1;
  288. }
  290. void
  291. udf_write_super(struct super_block *sb)
  292. {
  293. if (!(sb->s_flags & MS_RDONLY))
  294. udf_open_lvid(sb);
  295. sb->s_dirt = 0;
  296. }
  298. static int
  299. udf_remount_fs(struct super_block *sb, int *flags, char *options)
  300. {
  301. struct udf_options uopt;
  303. uopt.flags = UDF_SB(sb)->s_flags ;
  304. uopt.uid   = UDF_SB(sb)->s_uid ;
  305. uopt.gid   = UDF_SB(sb)->s_gid ;
  306. uopt.umask = UDF_SB(sb)->s_umask ;
  308. if ( !udf_parse_options(options, &uopt) )
  309. return -EINVAL;
  311. UDF_SB(sb)->s_flags = uopt.flags;
  312. UDF_SB(sb)->s_uid   = uopt.uid;
  313. UDF_SB(sb)->s_gid   = uopt.gid;
  314. UDF_SB(sb)->s_umask = uopt.umask;
  316. #if UDFFS_RW != 1
  317. *flags |= MS_RDONLY;
  318. #endif
  320. if ((*flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY))
  321. return 0;
  322. if (*flags & MS_RDONLY)
  323. udf_close_lvid(sb);
  324. else
  325. udf_open_lvid(sb);
  327. return 0;
  328. }
  330. /*
  331.  * udf_set_blocksize
  332.  *
  333.  * PURPOSE
  334.  * Set the block size to be used in all transfers.
  335.  *
  336.  * DESCRIPTION
  337.  * To allow room for a DMA transfer, it is best to guess big when unsure.
  338.  * This routine picks 2048 bytes as the blocksize when guessing. This
  339.  * should be adequate until devices with larger block sizes become common.
  340.  *
  341.  * Note that the Linux kernel can currently only deal with blocksizes of
  342.  * 512, 1024, 2048, 4096, and 8192 bytes.
  343.  *
  344.  * PRE-CONDITIONS
  345.  * sb Pointer to _locked_ superblock.
  346.  *
  347.  * POST-CONDITIONS
  348.  * sb->s_blocksize Blocksize.
  349.  * sb->s_blocksize_bits log2 of blocksize.
  350.  * <return> 0 Blocksize is valid.
  351.  * <return> 1 Blocksize is invalid.
  352.  *
  353.  * HISTORY
  354.  * July 1, 1997 - Andrew E. Mileski
  355.  * Written, tested, and released.
  356.  */
  357. static  int
  358. udf_set_blocksize(struct super_block *sb, int bsize)
  359. {
  360. /* Use specified block size if specified */
  361. if (bsize)
  362. sb->s_blocksize = bsize;
  363. if (get_hardsect_size(sb->s_dev) > sb->s_blocksize)
  364. sb->s_blocksize = get_hardsect_size(sb->s_dev); 
  366. /* Block size must be an even multiple of 512 */
  367. switch (sb->s_blocksize)
  368. {
  369. case 512: sb->s_blocksize_bits = 9; break;
  370. case 1024: sb->s_blocksize_bits = 10; break;
  371. case 2048: sb->s_blocksize_bits = 11; break;
  372. case 4096: sb->s_blocksize_bits = 12; break;
  373. case 8192: sb->s_blocksize_bits = 13; break;
  374. default:
  375. {
  376. udf_debug("Bad block size (%ld)n", sb->s_blocksize);
  377. printk(KERN_ERR "udf: bad block size (%ld)n", sb->s_blocksize);
  378. return 0;
  379. }
  380. }
  382. /* Set the block size */
  383. set_blocksize(sb->s_dev, sb->s_blocksize);
  384. return sb->s_blocksize;
  385. }
  387. static int
  388. udf_vrs(struct super_block *sb, int silent)
  389. {
  390. struct VolStructDesc *vsd = NULL;
  391. int sector = 32768;
  392. int sectorsize;
  393. struct buffer_head *bh = NULL;
  394. int iso9660=0;
  395. int nsr02=0;
  396. int nsr03=0;
  398. /* Block size must be a multiple of 512 */
  399. if (sb->s_blocksize & 511)
  400. return 0;
  402. if (sb->s_blocksize < sizeof(struct VolStructDesc))
  403. sectorsize = sizeof(struct VolStructDesc);
  404. else
  405. sectorsize = sb->s_blocksize;
  407. sector += (UDF_SB_SESSION(sb) << sb->s_blocksize_bits);
  409. udf_debug("Starting at sector %u (%ld byte sectors)n",
  410. (sector >> sb->s_blocksize_bits), sb->s_blocksize);
  411. /* Process the sequence (if applicable) */
  412. for (;!nsr02 && !nsr03; sector += sectorsize)
  413. {
  414. /* Read a block */
  415. bh = udf_tread(sb, sector >> sb->s_blocksize_bits);
  416. if (!bh)
  417. break;
  419. /* Look for ISO  descriptors */
  420. vsd = (struct VolStructDesc *)(bh->b_data +
  421. (sector & (sb->s_blocksize - 1)));
  423. if (vsd->stdIdent[0] == 0)
  424. {
  425. udf_release_data(bh);
  426. break;
  427. }
  428. else if (!strncmp(vsd->stdIdent, STD_ID_CD001, STD_ID_LEN))
  429. {
  430. iso9660 = sector;
  431. switch (vsd->structType)
  432. {
  433. case 0: 
  434. udf_debug("ISO9660 Boot Record foundn");
  435. break;
  436. case 1: 
  437. udf_debug("ISO9660 Primary Volume Descriptor foundn");
  438. break;
  439. case 2: 
  440. udf_debug("ISO9660 Supplementary Volume Descriptor foundn");
  441. break;
  442. case 3: 
  443. udf_debug("ISO9660 Volume Partition Descriptor foundn");
  444. break;
  445. case 255: 
  446. udf_debug("ISO9660 Volume Descriptor Set Terminator foundn");
  447. break;
  448. default: 
  449. udf_debug("ISO9660 VRS (%u) foundn", vsd->structType);
  450. break;
  451. }
  452. }
  453. else if (!strncmp(vsd->stdIdent, STD_ID_BEA01, STD_ID_LEN))
  454. {
  455. }
  456. else if (!strncmp(vsd->stdIdent, STD_ID_TEA01, STD_ID_LEN))
  457. {
  458. udf_release_data(bh);
  459. break;
  460. }
  461. else if (!strncmp(vsd->stdIdent, STD_ID_NSR02, STD_ID_LEN))
  462. {
  463. nsr02 = sector;
  464. }
  465. else if (!strncmp(vsd->stdIdent, STD_ID_NSR03, STD_ID_LEN))
  466. {
  467. nsr03 = sector;
  468. }
  469. udf_release_data(bh);
  470. }
  472. if (nsr03)
  473. return nsr03;
  474. else if (nsr02)
  475. return nsr02;
  476. else if (sector - (UDF_SB_SESSION(sb) << sb->s_blocksize_bits) == 32768)
  477. return -1;
  478. else
  479. return 0;
  480. }
  482. /*
  483.  * udf_find_anchor
  484.  *
  485.  * PURPOSE
  486.  * Find an anchor volume descriptor.
  487.  *
  488.  * PRE-CONDITIONS
  489.  * sb Pointer to _locked_ superblock.
  490.  * lastblock Last block on media.
  491.  *
  492.  * POST-CONDITIONS
  493.  * <return> 1 if not found, 0 if ok
  494.  *
  495.  * HISTORY
  496.  * July 1, 1997 - Andrew E. Mileski
  497.  * Written, tested, and released.
  498.  */
  499. static void
  500. udf_find_anchor(struct super_block *sb)
  501. {
  502. int lastblock = UDF_SB_LASTBLOCK(sb);
  503. struct buffer_head *bh = NULL;
  504. Uint16 ident;
  505. Uint32 location;
  506. int i;
  508. if (lastblock)
  509. {
  510. int varlastblock = udf_variable_to_fixed(lastblock);
  511. int last[] =  { lastblock, lastblock - 2,
  512. lastblock - 150, lastblock - 152,
  513. varlastblock, varlastblock - 2,
  514. varlastblock - 150, varlastblock - 152 };
  516. lastblock = 0;
  518. /* Search for an anchor volume descriptor pointer */
  520. /*  according to spec, anchor is in either:
  521.  *     block 256
  522.  *     lastblock-256
  523.  *     lastblock
  524.  *  however, if the disc isn't closed, it could be 512 */
  526. for (i=0; (!lastblock && i<sizeof(last)/sizeof(int)); i++)
  527. {
  528. if (last[i] < 0 || !(bh = sb_bread(sb, last[i])))
  529. {
  530. ident = location = 0;
  531. }
  532. else
  533. {
  534. ident = le16_to_cpu(((tag *)bh->b_data)->tagIdent);
  535. location = le32_to_cpu(((tag *)bh->b_data)->tagLocation);
  536. udf_release_data(bh);
  537. }
  539. if (ident == TID_ANCHOR_VOL_DESC_PTR)
  540. {
  541. if (location == last[i] - UDF_SB_SESSION(sb))
  542. {
  543. lastblock = UDF_SB_ANCHOR(sb)[0] = last[i];
  544. UDF_SB_ANCHOR(sb)[1] = last[i] - 256;
  545. }
  546. else if (location == udf_variable_to_fixed(last[i]) - UDF_SB_SESSION(sb))
  547. {
  548. UDF_SET_FLAG(sb, UDF_FLAG_VARCONV);
  549. lastblock = UDF_SB_ANCHOR(sb)[0] = udf_variable_to_fixed(last[i]);
  550. UDF_SB_ANCHOR(sb)[1] = lastblock - 256;
  551. }
  552. else
  553. udf_debug("Anchor found at block %d, location mismatch %d.n",
  554. last[i], location);
  555. }
  556. else if (ident == TID_FILE_ENTRY || ident == TID_EXTENDED_FILE_ENTRY)
  557. {
  558. lastblock = last[i];
  559. UDF_SB_ANCHOR(sb)[3] = 512 + UDF_SB_SESSION(sb);
  560. }
  561. else
  562. {
  563. if (last[i] < 256 || !(bh = sb_bread(sb, last[i] - 256)))
  564. {
  565. ident = location = 0;
  566. }
  567. else
  568. {
  569. ident = le16_to_cpu(((tag *)bh->b_data)->tagIdent);
  570. location = le32_to_cpu(((tag *)bh->b_data)->tagLocation);
  571. udf_release_data(bh);
  572. }
  574. if (ident == TID_ANCHOR_VOL_DESC_PTR &&
  575. location == last[i] - 256 - UDF_SB_SESSION(sb))
  576. {
  577. lastblock = last[i];
  578. UDF_SB_ANCHOR(sb)[1] = last[i] - 256;
  579. }
  580. else
  581. {
  582. if (last[i] < 312 + UDF_SB_SESSION(sb) || !(bh = sb_bread(sb, last[i] - 312 - UDF_SB_SESSION(sb))))
  583. {
  584. ident = location = 0;
  585. }
  586. else
  587. {
  588. ident = le16_to_cpu(((tag *)bh->b_data)->tagIdent);
  589. location = le32_to_cpu(((tag *)bh->b_data)->tagLocation);
  590. udf_release_data(bh);
  591. }
  593. if (ident == TID_ANCHOR_VOL_DESC_PTR &&
  594. location == udf_variable_to_fixed(last[i]) - 256)
  595. {
  596. UDF_SET_FLAG(sb, UDF_FLAG_VARCONV);
  597. lastblock = udf_variable_to_fixed(last[i]);
  598. UDF_SB_ANCHOR(sb)[1] = lastblock - 256;
  599. }
  600. }
  601. }
  602. }
  603. }
  605. if (!lastblock)
  606. {
  607. /* We havn't found the lastblock. check 312 */
  608. if ((bh = sb_bread(sb, 312 + UDF_SB_SESSION(sb))))
  609. {
  610. ident = le16_to_cpu(((tag *)bh->b_data)->tagIdent);
  611. location = le32_to_cpu(((tag *)bh->b_data)->tagLocation);
  612. udf_release_data(bh);
  614. if (ident == TID_ANCHOR_VOL_DESC_PTR && location == 256)
  615. UDF_SET_FLAG(sb, UDF_FLAG_VARCONV);
  616. }
  617. }
  619. for (i=0; i<sizeof(UDF_SB_ANCHOR(sb))/sizeof(int); i++)
  620. {
  621. if (UDF_SB_ANCHOR(sb)[i])
  622. {
  623. if (!(bh = udf_read_tagged(sb,
  624. UDF_SB_ANCHOR(sb)[i], UDF_SB_ANCHOR(sb)[i], &ident)))
  625. {
  626. UDF_SB_ANCHOR(sb)[i] = 0;
  627. }
  628. else
  629. {
  630. udf_release_data(bh);
  631. if ((ident != TID_ANCHOR_VOL_DESC_PTR) && (i ||
  632. (ident != TID_FILE_ENTRY && ident != TID_EXTENDED_FILE_ENTRY)))
  633. {
  634. UDF_SB_ANCHOR(sb)[i] = 0;
  635. }
  636. }
  637. }
  638. }
  640. UDF_SB_LASTBLOCK(sb) = lastblock;
  641. }
  643. static int 
  644. udf_find_fileset(struct super_block *sb, lb_addr *fileset, lb_addr *root)
  645. {
  646. struct buffer_head *bh = NULL;
  647. long lastblock;
  648. Uint16 ident;
  650. if (fileset->logicalBlockNum != 0xFFFFFFFF ||
  651. fileset->partitionReferenceNum != 0xFFFF)
  652. {
  653. bh = udf_read_ptagged(sb, *fileset, 0, &ident);
  655. if (!bh)
  656. return 1;
  657. else if (ident != TID_FILE_SET_DESC)
  658. {
  659. udf_release_data(bh);
  660. return 1;
  661. }
  663. }
  665. if (!bh) /* Search backwards through the partitions */
  666. {
  667. lb_addr newfileset;
  669. return 1;
  671. for (newfileset.partitionReferenceNum=UDF_SB_NUMPARTS(sb)-1;
  672. (newfileset.partitionReferenceNum != 0xFFFF &&
  673. fileset->logicalBlockNum == 0xFFFFFFFF &&
  674. fileset->partitionReferenceNum == 0xFFFF);
  675. newfileset.partitionReferenceNum--)
  676. {
  677. lastblock = UDF_SB_PARTLEN(sb, newfileset.partitionReferenceNum);
  678. newfileset.logicalBlockNum = 0;
  680. do
  681. {
  682. bh = udf_read_ptagged(sb, newfileset, 0, &ident);
  683. if (!bh)
  684. {
  685. newfileset.logicalBlockNum ++;
  686. continue;
  687. }
  689. switch (ident)
  690. {
  691. case TID_SPACE_BITMAP_DESC:
  692. {
  693. struct SpaceBitmapDesc *sp;
  694. sp = (struct SpaceBitmapDesc *)bh->b_data;
  695. newfileset.logicalBlockNum += 1 +
  696. ((le32_to_cpu(sp->numOfBytes) + sizeof(struct SpaceBitmapDesc) - 1)
  697. >> sb->s_blocksize_bits);
  698. udf_release_data(bh);
  699. break;
  700. }
  701. case TID_FILE_SET_DESC:
  702. {
  703. *fileset = newfileset;
  704. break;
  705. }
  706. default:
  707. {
  708. newfileset.logicalBlockNum ++;
  709. udf_release_data(bh);
  710. bh = NULL;
  711. break;
  712. }
  713. }
  714. }
  715. while (newfileset.logicalBlockNum < lastblock &&
  716. fileset->logicalBlockNum == 0xFFFFFFFF &&
  717. fileset->partitionReferenceNum == 0xFFFF);
  718. }
  719. }
  721. if ((fileset->logicalBlockNum != 0xFFFFFFFF ||
  722. fileset->partitionReferenceNum != 0xFFFF) && bh)
  723. {
  724. udf_debug("Fileset at block=%d, partition=%dn",
  725. fileset->logicalBlockNum, fileset->partitionReferenceNum);
  727. UDF_SB_PARTITION(sb) = fileset->partitionReferenceNum;
  728. udf_load_fileset(sb, bh, root);
  729. udf_release_data(bh);
  730. return 0;
  731. }
  732. return 1;
  733. }
  735. static void 
  736. udf_load_pvoldesc(struct super_block *sb, struct buffer_head *bh)
  737. {
  738. struct PrimaryVolDesc *pvoldesc;
  739. time_t recording;
  740. long recording_usec;
  741. struct ustr instr;
  742. struct ustr outstr;
  744. pvoldesc = (struct PrimaryVolDesc *)bh->b_data;
  746. if ( udf_stamp_to_time(&recording, &recording_usec,
  747. lets_to_cpu(pvoldesc->recordingDateAndTime)) )
  748. {
  749. timestamp ts;
  750. ts = lets_to_cpu(pvoldesc->recordingDateAndTime);
  751. udf_debug("recording time %ld/%ld, %04u/%02u/%02u %02u:%02u (%x)n",
  752. recording, recording_usec,
  753. ts.year, ts.month, ts.day, ts.hour, ts.minute, ts.typeAndTimezone);
  754. UDF_SB_RECORDTIME(sb) = recording;
  755. }
  757. if ( !udf_build_ustr(&instr, pvoldesc->volIdent, 32) )
  758. {
  759. if (udf_CS0toUTF8(&outstr, &instr))
  760. {
  761. strncpy( UDF_SB_VOLIDENT(sb), outstr.u_name,
  762. outstr.u_len > 31 ? 31 : outstr.u_len);
  763. udf_debug("volIdent[] = '%s'n", UDF_SB_VOLIDENT(sb));
  764. }
  765. }
  767. if ( !udf_build_ustr(&instr, pvoldesc->volSetIdent, 128) )
  768. {
  769. if (udf_CS0toUTF8(&outstr, &instr))
  770. udf_debug("volSetIdent[] = '%s'n", outstr.u_name);
  771. }
  772. }
  774. static void 
  775. udf_load_fileset(struct super_block *sb, struct buffer_head *bh, lb_addr *root)
  776. {
  777. struct FileSetDesc *fset;
  779. fset = (struct FileSetDesc *)bh->b_data;
  781. *root = lelb_to_cpu(fset->rootDirectoryICB.extLocation);
  783. UDF_SB_SERIALNUM(sb) = le16_to_cpu(fset->descTag.tagSerialNum);
  785. udf_debug("Rootdir at block=%d, partition=%dn", 
  786. root->logicalBlockNum, root->partitionReferenceNum);
  787. }
  789. static void 
  790. udf_load_partdesc(struct super_block *sb, struct buffer_head *bh)
  791. {
  792. struct PartitionDesc *p;
  793. int i;
  795. p = (struct PartitionDesc *)bh->b_data;
  797. for (i=0; i<UDF_SB_NUMPARTS(sb); i++)
  798. {
  799. udf_debug("Searching map: (%d == %d)n", 
  800. UDF_SB_PARTMAPS(sb)[i].s_partition_num, le16_to_cpu(p->partitionNumber));
  801. if (UDF_SB_PARTMAPS(sb)[i].s_partition_num == le16_to_cpu(p->partitionNumber))
  802. {
  803. UDF_SB_PARTLEN(sb,i) = le32_to_cpu(p->partitionLength); /* blocks */
  804. UDF_SB_PARTROOT(sb,i) = le32_to_cpu(p->partitionStartingLocation) + UDF_SB_SESSION(sb);
  806. if (!strcmp(p->partitionContents.ident, PARTITION_CONTENTS_NSR02) ||
  807. !strcmp(p->partitionContents.ident, PARTITION_CONTENTS_NSR03))
  808. {
  809. struct PartitionHeaderDesc *phd;
  811. phd = (struct PartitionHeaderDesc *)(p->partitionContentsUse);
  812. if (phd->unallocatedSpaceTable.extLength)
  813. {
  814. lb_addr loc = { le32_to_cpu(phd->unallocatedSpaceTable.extPosition), i };
  816. UDF_SB_PARTMAPS(sb)[i].s_uspace.s_table =
  817. udf_iget(sb, loc);
  818. UDF_SB_PARTFLAGS(sb,i) |= UDF_PART_FLAG_UNALLOC_TABLE;
  819. udf_debug("unallocatedSpaceTable (part %d) @ %ldn",
  820. i, UDF_SB_PARTMAPS(sb)[i].s_uspace.s_table->i_ino);
  821. }
  822. if (phd->unallocatedSpaceBitmap.extLength)
  823. {
  824. UDF_SB_ALLOC_BITMAP(sb, i, s_uspace);
  825. if (UDF_SB_PARTMAPS(sb)[i].s_uspace.s_bitmap != NULL)
  826. {
  827. UDF_SB_PARTMAPS(sb)[i].s_uspace.s_bitmap->s_extLength =
  828. le32_to_cpu(phd->unallocatedSpaceBitmap.extLength);
  829. UDF_SB_PARTMAPS(sb)[i].s_uspace.s_bitmap->s_extPosition =
  830. le32_to_cpu(phd->unallocatedSpaceBitmap.extPosition);
  831. UDF_SB_PARTFLAGS(sb,i) |= UDF_PART_FLAG_UNALLOC_BITMAP;
  832. udf_debug("unallocatedSpaceBitmap (part %d) @ %dn",
  833. i, UDF_SB_PARTMAPS(sb)[i].s_uspace.s_bitmap->s_extPosition);
  834. }
  835. }
  836. if (phd->partitionIntegrityTable.extLength)
  837. udf_debug("partitionIntegrityTable (part %d)n", i);
  838. if (phd->freedSpaceTable.extLength)
  839. {
  840. lb_addr loc = { le32_to_cpu(phd->freedSpaceTable.extPosition), i };
  842. UDF_SB_PARTMAPS(sb)[i].s_fspace.s_table =
  843. udf_iget(sb, loc);
  844. UDF_SB_PARTFLAGS(sb,i) |= UDF_PART_FLAG_FREED_TABLE;
  845. udf_debug("freedSpaceTable (part %d) @ %ldn",
  846. i, UDF_SB_PARTMAPS(sb)[i].s_fspace.s_table->i_ino);
  847. }
  848. if (phd->freedSpaceBitmap.extLength)
  849. {
  850. UDF_SB_ALLOC_BITMAP(sb, i, s_fspace);
  851. if (UDF_SB_PARTMAPS(sb)[i].s_fspace.s_bitmap != NULL)
  852. {
  853. UDF_SB_PARTMAPS(sb)[i].s_fspace.s_bitmap->s_extLength =
  854. le32_to_cpu(phd->freedSpaceBitmap.extLength);
  855. UDF_SB_PARTMAPS(sb)[i].s_fspace.s_bitmap->s_extPosition =
  856. le32_to_cpu(phd->freedSpaceBitmap.extPosition);
  857. UDF_SB_PARTFLAGS(sb,i) |= UDF_PART_FLAG_FREED_BITMAP;
  858. udf_debug("freedSpaceBitmap (part %d) @ %dn",
  859. i, UDF_SB_PARTMAPS(sb)[i].s_fspace.s_bitmap->s_extPosition);
  860. }
  861. }
  862. }
  863. break;
  864. }
  865. }
  866. if (i == UDF_SB_NUMPARTS(sb))
  867. {
  868. udf_debug("Partition (%d) not found in partition mapn", le16_to_cpu(p->partitionNumber));
  869. }
  870. else
  871. {
  872. udf_debug("Partition (%d:%d type %x) starts at physical %d, block length %dn",
  873. le16_to_cpu(p->partitionNumber), i, UDF_SB_PARTTYPE(sb,i),
  874. UDF_SB_PARTROOT(sb,i), UDF_SB_PARTLEN(sb,i));
  875. }
  876. }
  878. static int 
  879. udf_load_logicalvol(struct super_block *sb, struct buffer_head * bh, lb_addr *fileset)
  880. {
  881. struct LogicalVolDesc *lvd;
  882. int i, j, offset;
  883. Uint8 type;
  885. lvd = (struct LogicalVolDesc *)bh->b_data;
  887. UDF_SB_ALLOC_PARTMAPS(sb, le32_to_cpu(lvd->numPartitionMaps));
  889. for (i=0,offset=0;
  890.  i<UDF_SB_NUMPARTS(sb) && offset<le32_to_cpu(lvd->mapTableLength);
  891.  i++,offset+=((struct GenericPartitionMap *)&(lvd->partitionMaps[offset]))->partitionMapLength)
  892. {
  893. type = ((struct GenericPartitionMap *)&(lvd->partitionMaps[offset]))->partitionMapType;
  894. if (type == 1)
  895. {
  896. struct GenericPartitionMap1 *gpm1 = (struct GenericPartitionMap1 *)&(lvd->partitionMaps[offset]);
  897. UDF_SB_PARTTYPE(sb,i) = UDF_TYPE1_MAP15;
  898. UDF_SB_PARTVSN(sb,i) = le16_to_cpu(gpm1->volSeqNum);
  899. UDF_SB_PARTNUM(sb,i) = le16_to_cpu(gpm1->partitionNum);
  900. UDF_SB_PARTFUNC(sb,i) = NULL;
  901. }
  902. else if (type == 2)
  903. {
  904. struct UdfPartitionMap2 *upm2 = (struct UdfPartitionMap2 *)&(lvd->partitionMaps[offset]);
  905. if (!strncmp(upm2->partIdent.ident, UDF_ID_VIRTUAL, strlen(UDF_ID_VIRTUAL)))
  906. {
  907. if (le16_to_cpu(((Uint16 *)upm2->partIdent.identSuffix)[0]) == 0x0150)
  908. {
  909. UDF_SB_PARTTYPE(sb,i) = UDF_VIRTUAL_MAP15;
  910. UDF_SB_PARTFUNC(sb,i) = udf_get_pblock_virt15;
  911. }
  912. else if (le16_to_cpu(((Uint16 *)upm2->partIdent.identSuffix)[0]) == 0x0200)
  913. {
  914. UDF_SB_PARTTYPE(sb,i) = UDF_VIRTUAL_MAP20;
  915. UDF_SB_PARTFUNC(sb,i) = udf_get_pblock_virt20;
  916. }
  917. }
  918. else if (!strncmp(upm2->partIdent.ident, UDF_ID_SPARABLE, strlen(UDF_ID_SPARABLE)))
  919. {
  920. Uint32 loc;
  921. Uint16 ident;
  922. struct SparingTable *st;
  923. struct SparablePartitionMap *spm = (struct SparablePartitionMap *)&(lvd->partitionMaps[offset]);
  925. UDF_SB_PARTTYPE(sb,i) = UDF_SPARABLE_MAP15;
  926. UDF_SB_TYPESPAR(sb,i).s_packet_len = le16_to_cpu(spm->packetLength);
  927. for (j=0; j<spm->numSparingTables; j++)
  928. {
  929. loc = le32_to_cpu(spm->locSparingTable[j]);
  930. UDF_SB_TYPESPAR(sb,i).s_spar_map[j] =
  931. udf_read_tagged(sb, loc, loc, &ident);
  932. if (UDF_SB_TYPESPAR(sb,i).s_spar_map[j] != NULL)
  933. {
  934. st = (struct SparingTable *)UDF_SB_TYPESPAR(sb,i).s_spar_map[j]->b_data;
  935. if (ident != 0 ||
  936. strncmp(st->sparingIdent.ident, UDF_ID_SPARING, strlen(UDF_ID_SPARING)))
  937. {
  938. udf_release_data(UDF_SB_TYPESPAR(sb,i).s_spar_map[j]);
  939. UDF_SB_TYPESPAR(sb,i).s_spar_map[j] = NULL;
  940. }
  941. }
  942. }
  943. UDF_SB_PARTFUNC(sb,i) = udf_get_pblock_spar15;
  944. }
  945. else
  946. {
  947. udf_debug("Unknown ident: %sn", upm2->partIdent.ident);
  948. continue;
  949. }
  950. UDF_SB_PARTVSN(sb,i) = le16_to_cpu(upm2->volSeqNum);
  951. UDF_SB_PARTNUM(sb,i) = le16_to_cpu(upm2->partitionNum);
  952. }
  953. udf_debug("Partition (%d:%d) type %d on volume %dn",
  954. i, UDF_SB_PARTNUM(sb,i), type, UDF_SB_PARTVSN(sb,i));
  955. }
  957. if (fileset)
  958. {
  959. long_ad *la = (long_ad *)&(lvd->logicalVolContentsUse[0]);
  961. *fileset = lelb_to_cpu(la->extLocation);
  962. udf_debug("FileSet found in LogicalVolDesc at block=%d, partition=%dn",
  963. fileset->logicalBlockNum,
  964. fileset->partitionReferenceNum);
  965. }
  966. if (lvd->integritySeqExt.extLength)
  967. udf_load_logicalvolint(sb, leea_to_cpu(lvd->integritySeqExt));
  968. return 0;
  969. }
  971. /*
  972.  * udf_load_logicalvolint
  973.  *
  974.  */
  975. static void
  976. udf_load_logicalvolint(struct super_block *sb, extent_ad loc)
  977. {
  978. struct buffer_head *bh = NULL;
  979. Uint16 ident;
  981. while (loc.extLength > 0 &&
  982. (bh = udf_read_tagged(sb, loc.extLocation,
  983. loc.extLocation, &ident)) &&
  984. ident == TID_LOGICAL_VOL_INTEGRITY_DESC)
  985. {
  986. UDF_SB_LVIDBH(sb) = bh;
  988. if (UDF_SB_LVID(sb)->nextIntegrityExt.extLength)
  989. udf_load_logicalvolint(sb, leea_to_cpu(UDF_SB_LVID(sb)->nextIntegrityExt));
  991. if (UDF_SB_LVIDBH(sb) != bh)
  992. udf_release_data(bh);
  993. loc.extLength -= sb->s_blocksize;
  994. loc.extLocation ++;
  995. }
  996. if (UDF_SB_LVIDBH(sb) != bh)
  997. udf_release_data(bh);
  998. }
  1000. /*
  1001.  * udf_process_sequence
  1002.  *
  1003.  * PURPOSE
  1004.  * Process a main/reserve volume descriptor sequence.
  1005.  *
  1006.  * PRE-CONDITIONS
  1007.  * sb Pointer to _locked_ superblock.
  1008.  * block First block of first extent of the sequence.
  1009.  * lastblock Lastblock of first extent of the sequence.
  1010.  *
  1011.  * HISTORY
  1012.  * July 1, 1997 - Andrew E. Mileski
  1013.  * Written, tested, and released.
  1014.  */
  1015. static  int
  1016. udf_process_sequence(struct super_block *sb, long block, long lastblock, lb_addr *fileset)
  1017. {
  1018. struct buffer_head *bh = NULL;
  1019. struct udf_vds_record vds[VDS_POS_LENGTH];
  1020. struct GenericDesc *gd;
  1021. struct VolDescPtr *vdp;
  1022. int done=0;
  1023. int i,j;
  1024. Uint32 vdsn;
  1025. Uint16 ident;
  1026. long next_s = 0, next_e = 0;
  1028. memset(vds, 0, sizeof(struct udf_vds_record) * VDS_POS_LENGTH);
  1030. /* Read the main descriptor sequence */
  1031. for (;(!done && block <= lastblock); block++)
  1032. {
  1034. bh = udf_read_tagged(sb, block, block, &ident);
  1035. if (!bh) 
  1036. break;
  1038. /* Process each descriptor (ISO 13346 3/8.3-8.4) */
  1039. gd = (struct GenericDesc *)bh->b_data;
  1040. vdsn = le32_to_cpu(gd->volDescSeqNum);
  1041. switch (ident)
  1042. {
  1043. case TID_PRIMARY_VOL_DESC: /* ISO 13346 3/10.1 */
  1044. if (vdsn >= vds[VDS_POS_PRIMARY_VOL_DESC].volDescSeqNum)
  1045. {
  1046. vds[VDS_POS_PRIMARY_VOL_DESC].volDescSeqNum = vdsn;
  1047. vds[VDS_POS_PRIMARY_VOL_DESC].block = block;
  1048. }
  1049. break;
  1050. case TID_VOL_DESC_PTR: /* ISO 13346 3/10.3 */
  1051. if (vdsn >= vds[VDS_POS_VOL_DESC_PTR].volDescSeqNum)
  1052. {
  1053. vds[VDS_POS_VOL_DESC_PTR].volDescSeqNum = vdsn;
  1054. vds[VDS_POS_VOL_DESC_PTR].block = block;
  1056. vdp = (struct VolDescPtr *)bh->b_data;
  1057. next_s = le32_to_cpu(vdp->nextVolDescSeqExt.extLocation);
  1058. next_e = le32_to_cpu(vdp->nextVolDescSeqExt.extLength);
  1059. next_e = next_e >> sb->s_blocksize_bits;
  1060. next_e += next_s;
  1061. }
  1062. break;
  1063. case TID_IMP_USE_VOL_DESC: /* ISO 13346 3/10.4 */
  1064. if (vdsn >= vds[VDS_POS_IMP_USE_VOL_DESC].volDescSeqNum)
  1065. {
  1066. vds[VDS_POS_IMP_USE_VOL_DESC].volDescSeqNum = vdsn;
  1067. vds[VDS_POS_IMP_USE_VOL_DESC].block = block;
  1068. }
  1069. break;
  1070. case TID_PARTITION_DESC: /* ISO 13346 3/10.5 */
  1071. if (!vds[VDS_POS_PARTITION_DESC].block)
  1072. vds[VDS_POS_PARTITION_DESC].block = block;
  1073. break;
  1074. case TID_LOGICAL_VOL_DESC: /* ISO 13346 3/10.6 */
  1075. if (vdsn >= vds[VDS_POS_LOGICAL_VOL_DESC].volDescSeqNum)
  1076. {
  1077. vds[VDS_POS_LOGICAL_VOL_DESC].volDescSeqNum = vdsn;
  1078. vds[VDS_POS_LOGICAL_VOL_DESC].block = block;
  1079. }
  1080. break;
  1081. case TID_UNALLOC_SPACE_DESC: /* ISO 13346 3/10.8 */
  1082. if (vdsn >= vds[VDS_POS_UNALLOC_SPACE_DESC].volDescSeqNum)
  1083. {
  1084. vds[VDS_POS_UNALLOC_SPACE_DESC].volDescSeqNum = vdsn;
  1085. vds[VDS_POS_UNALLOC_SPACE_DESC].block = block;
  1086. }
  1087. break;
  1088. case TID_TERMINATING_DESC: /* ISO 13346 3/10.9 */
  1089. vds[VDS_POS_TERMINATING_DESC].block = block;
  1090. if (next_e)
  1091. {
  1092. block = next_s;
  1093. lastblock = next_e;
  1094. next_s = next_e = 0;
  1095. }
  1096. else
  1097. done = 1;
  1098. break;
  1099. }
  1100. udf_release_data(bh);
  1101. }
  1102. for (i=0; i<VDS_POS_LENGTH; i++)
  1103. {
  1104. if (vds[i].block)
  1105. {
  1106. bh = udf_read_tagged(sb, vds[i].block, vds[i].block, &ident);
  1108. if (i == VDS_POS_PRIMARY_VOL_DESC)
  1109. udf_load_pvoldesc(sb, bh);
  1110. else if (i == VDS_POS_LOGICAL_VOL_DESC)
  1111. udf_load_logicalvol(sb, bh, fileset);
  1112. else if (i == VDS_POS_PARTITION_DESC)
  1113. {
  1114. struct buffer_head *bh2 = NULL;
  1115. udf_load_partdesc(sb, bh);
  1116. for (j=vds[i].block+1; j<vds[VDS_POS_TERMINATING_DESC].block; j++)
  1117. {
  1118. bh2 = udf_read_tagged(sb, j, j, &ident);
  1119. gd = (struct GenericDesc *)bh2->b_data;
  1120. if (ident == TID_PARTITION_DESC)
  1121. udf_load_partdesc(sb, bh2);
  1122. udf_release_data(bh2);
  1123. }
  1124. }
  1125. udf_release_data(bh);
  1126. }
  1127. }
  1129. return 0;
  1130. }
  1132. /*
  1133.  * udf_check_valid()
  1134.  */
  1135. static int
  1136. udf_check_valid(struct super_block *sb, int novrs, int silent)
  1137. {
  1138. long block;
  1140. if (novrs)
  1141. {
  1142. udf_debug("Validity check skipped because of novrs optionn");
  1143. return 0;
  1144. }
  1145. /* Check that it is NSR02 compliant */
  1146. /* Process any "CD-ROM Volume Descriptor Set" (ECMA 167 2/8.3.1) */
  1147. else if ((block = udf_vrs(sb, silent)) == -1)
  1148. {
  1149. udf_debug("Failed to read byte 32768. Assuming open disc. Skipping validity checkn");
  1150. if (!UDF_SB_LASTBLOCK(sb))
  1151. UDF_SB_LASTBLOCK(sb) = udf_get_last_block(sb);
  1152. return 0;
  1153. }
  1154. else 
  1155. return !block;
  1156. }
  1158. static int
  1159. udf_load_partition(struct super_block *sb, lb_addr *fileset)
  1160. {
  1161. struct AnchorVolDescPtr *anchor;
  1162. Uint16 ident;
  1163. struct buffer_head *bh;
  1164. long main_s, main_e, reserve_s, reserve_e;
  1165. int i, j;
  1167. if (!sb)
  1168. return 1;
  1170. for (i=0; i<sizeof(UDF_SB_ANCHOR(sb))/sizeof(int); i++)
  1171. {
  1172. if (UDF_SB_ANCHOR(sb)[i] && (bh = udf_read_tagged(sb,
  1173. UDF_SB_ANCHOR(sb)[i], UDF_SB_ANCHOR(sb)[i], &ident)))
  1174. {
  1175. anchor = (struct AnchorVolDescPtr *)bh->b_data;
  1177. /* Locate the main sequence */
  1178. main_s = le32_to_cpu( anchor->mainVolDescSeqExt.extLocation );
  1179. main_e = le32_to_cpu( anchor->mainVolDescSeqExt.extLength );
  1180. main_e = main_e >> sb->s_blocksize_bits;
  1181. main_e += main_s;
  1183. /* Locate the reserve sequence */
  1184. reserve_s = le32_to_cpu(anchor->reserveVolDescSeqExt.extLocation);
  1185. reserve_e = le32_to_cpu(anchor->reserveVolDescSeqExt.extLength);
  1186. reserve_e = reserve_e >> sb->s_blocksize_bits;
  1187. reserve_e += reserve_s;
  1189. udf_release_data(bh);
  1191. /* Process the main & reserve sequences */
  1192. /* responsible for finding the PartitionDesc(s) */
  1193. if (!(udf_process_sequence(sb, main_s, main_e, fileset) &&
  1194. udf_process_sequence(sb, reserve_s, reserve_e, fileset)))
  1195. {
  1196. break;
  1197. }
  1198. }
  1199. }
  1201. if (i == sizeof(UDF_SB_ANCHOR(sb))/sizeof(int))
  1202. {
  1203. udf_debug("No Anchor block foundn");
  1204. return 1;
  1205. }
  1206. else
  1207. udf_debug("Using anchor in block %dn", UDF_SB_ANCHOR(sb)[i]);
  1209. for (i=0; i<UDF_SB_NUMPARTS(sb); i++)
  1210. {
  1211. switch UDF_SB_PARTTYPE(sb, i)
  1212. {
  1213. case UDF_VIRTUAL_MAP15:
  1214. case UDF_VIRTUAL_MAP20:
  1215. {
  1216. lb_addr ino;
  1218. if (!UDF_SB_LASTBLOCK(sb))
  1219. {
  1220. UDF_SB_LASTBLOCK(sb) = udf_get_last_block(sb);
  1221. udf_find_anchor(sb);
  1222. }
  1224. if (!UDF_SB_LASTBLOCK(sb))
  1225. {
  1226. udf_debug("Unable to determine Lastblock (For Virtual Partition)n");
  1227. return 1;
  1228. }
  1230. for (j=0; j<UDF_SB_NUMPARTS(sb); j++)
  1231. {
  1232. if (j != i &&
  1233. UDF_SB_PARTVSN(sb,i) == UDF_SB_PARTVSN(sb,j) &&
  1234. UDF_SB_PARTNUM(sb,i) == UDF_SB_PARTNUM(sb,j))
  1235. {
  1236. ino.partitionReferenceNum = j;
  1237. ino.logicalBlockNum = UDF_SB_LASTBLOCK(sb) -
  1238. UDF_SB_PARTROOT(sb,j);
  1239. break;
  1240. }
  1241. }
  1243. if (j == UDF_SB_NUMPARTS(sb))
  1244. return 1;
  1246. if (!(UDF_SB_VAT(sb) = udf_iget(sb, ino)))
  1247. return 1;
  1249. if (UDF_SB_PARTTYPE(sb,i) == UDF_VIRTUAL_MAP15)
  1250. {
  1251. UDF_SB_TYPEVIRT(sb,i).s_start_offset = udf_ext0_offset(UDF_SB_VAT(sb));
  1252. UDF_SB_TYPEVIRT(sb,i).s_num_entries = (UDF_SB_VAT(sb)->i_size - 36) >> 2;
  1253. }
  1254. else if (UDF_SB_PARTTYPE(sb,i) == UDF_VIRTUAL_MAP20)
  1255. {
  1256. struct buffer_head *bh = NULL;
  1257. Uint32 pos;
  1259. pos = udf_block_map(UDF_SB_VAT(sb), 0);
  1260. bh = sb_bread(sb, pos);
  1261. UDF_SB_TYPEVIRT(sb,i).s_start_offset =
  1262. le16_to_cpu(((struct VirtualAllocationTable20 *)bh->b_data + udf_ext0_offset(UDF_SB_VAT(sb)))->lengthHeader) +
  1263. udf_ext0_offset(UDF_SB_VAT(sb));
  1264. UDF_SB_TYPEVIRT(sb,i).s_num_entries = (UDF_SB_VAT(sb)->i_size -
  1265. UDF_SB_TYPEVIRT(sb,i).s_start_offset) >> 2;
  1266. udf_release_data(bh);
  1267. }
  1268. UDF_SB_PARTROOT(sb,i) = udf_get_pblock(sb, 0, i, 0);
  1269. UDF_SB_PARTLEN(sb,i) = UDF_SB_PARTLEN(sb,ino.partitionReferenceNum);
  1270. }
  1271. }
  1272. }
  1273. return 0;
  1274. }
  1276. static void udf_open_lvid(struct super_block *sb)
  1277. {
  1278. if (UDF_SB_LVIDBH(sb))
  1279. {
  1280. int i;
  1281. timestamp cpu_time;
  1283. UDF_SB_LVIDIU(sb)->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX;
  1284. UDF_SB_LVIDIU(sb)->impIdent.identSuffix[1] = UDF_OS_ID_LINUX;
  1285. if (udf_time_to_stamp(&cpu_time, CURRENT_TIME, CURRENT_UTIME))
  1286. UDF_SB_LVID(sb)->recordingDateAndTime = cpu_to_lets(cpu_time);
  1287. UDF_SB_LVID(sb)->integrityType = INTEGRITY_TYPE_OPEN;
  1289. UDF_SB_LVID(sb)->descTag.descCRC =
  1290. cpu_to_le16(udf_crc((char *)UDF_SB_LVID(sb) + sizeof(tag),
  1291. le16_to_cpu(UDF_SB_LVID(sb)->descTag.descCRCLength), 0));
  1293. UDF_SB_LVID(sb)->descTag.tagChecksum = 0;
  1294. for (i=0; i<16; i++)
  1295. if (i != 4)
  1296. UDF_SB_LVID(sb)->descTag.tagChecksum +=
  1297. ((Uint8 *)&(UDF_SB_LVID(sb)->descTag))[i];
  1299. mark_buffer_dirty(UDF_SB_LVIDBH(sb));
  1300. }
  1301. }
  1303. static void udf_close_lvid(struct super_block *sb)
  1304. {
  1305. if (UDF_SB_LVIDBH(sb) &&
  1306. UDF_SB_LVID(sb)->integrityType == INTEGRITY_TYPE_OPEN)
  1307. {
  1308. int i;
  1309. timestamp cpu_time;
  1311. UDF_SB_LVIDIU(sb)->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX;
  1312. UDF_SB_LVIDIU(sb)->impIdent.identSuffix[1] = UDF_OS_ID_LINUX;
  1313. if (udf_time_to_stamp(&cpu_time, CURRENT_TIME, CURRENT_UTIME))
  1314. UDF_SB_LVID(sb)->recordingDateAndTime = cpu_to_lets(cpu_time);
  1315. if (UDF_MAX_WRITE_VERSION > le16_to_cpu(UDF_SB_LVIDIU(sb)->maxUDFWriteRev))
  1316. UDF_SB_LVIDIU(sb)->maxUDFWriteRev = cpu_to_le16(UDF_MAX_WRITE_VERSION);
  1317. if (UDF_SB_UDFREV(sb) > le16_to_cpu(UDF_SB_LVIDIU(sb)->minUDFReadRev))
  1318. UDF_SB_LVIDIU(sb)->minUDFReadRev = cpu_to_le16(UDF_SB_UDFREV(sb));
  1319. if (UDF_SB_UDFREV(sb) > le16_to_cpu(UDF_SB_LVIDIU(sb)->minUDFWriteRev))
  1320. UDF_SB_LVIDIU(sb)->minUDFWriteRev = cpu_to_le16(UDF_SB_UDFREV(sb));
  1321. UDF_SB_LVID(sb)->integrityType = INTEGRITY_TYPE_CLOSE;
  1323. UDF_SB_LVID(sb)->descTag.descCRC =
  1324. cpu_to_le16(udf_crc((char *)UDF_SB_LVID(sb) + sizeof(tag),
  1325. le16_to_cpu(UDF_SB_LVID(sb)->descTag.descCRCLength), 0));
  1327. UDF_SB_LVID(sb)->descTag.tagChecksum = 0;
  1328. for (i=0; i<16; i++)
  1329. if (i != 4)
  1330. UDF_SB_LVID(sb)->descTag.tagChecksum +=
  1331. ((Uint8 *)&(UDF_SB_LVID(sb)->descTag))[i];
  1333. mark_buffer_dirty(UDF_SB_LVIDBH(sb));
  1334. }
  1335. }
  1337. /*
  1338.  * udf_read_super
  1339.  *
  1340.  * PURPOSE
  1341.  * Complete the specified super block.
  1342.  *
  1343.  * PRE-CONDITIONS
  1344.  * sb Pointer to superblock to complete - never NULL.
  1345.  * sb->s_dev Device to read suberblock from.
  1346.  * options Pointer to mount options.
  1347.  * silent Silent flag.
  1348.  *
  1349.  * HISTORY
  1350.  * July 1, 1997 - Andrew E. Mileski
  1351.  * Written, tested, and released.
  1352.  */
  1353. static struct super_block *
  1354. udf_read_super(struct super_block *sb, void *options, int silent)
  1355. {
  1356. int i;
  1357. struct inode *inode=NULL;
  1358. struct udf_options uopt;
  1359. lb_addr rootdir, fileset;
  1361. uopt.flags = (1 << UDF_FLAG_USE_AD_IN_ICB) | (1 << UDF_FLAG_STRICT);
  1362. uopt.uid = -1;
  1363. uopt.gid = -1;
  1364. uopt.umask = 0;
  1366. memset(UDF_SB(sb), 0x00, sizeof(struct udf_sb_info));
  1368. #if UDFFS_RW != 1
  1369. sb->s_flags |= MS_RDONLY;
  1370. #endif
  1372. if (!udf_parse_options((char *)options, &uopt))
  1373. goto error_out;
  1375. if (uopt.flags & (1 << UDF_FLAG_UTF8) &&
  1376.     uopt.flags & (1 << UDF_FLAG_NLS_MAP))
  1377. {
  1378. udf_error(sb, "udf_read_super",
  1379. "utf8 cannot be combined with iocharsetn");
  1380. goto error_out;
  1381. }
  1382. #ifdef CONFIG_NLS
  1383. if ((uopt.flags & (1 << UDF_FLAG_NLS_MAP)) && !uopt.nls_map)
  1384. {
  1385. uopt.nls_map = load_nls_default();
  1386. if (!uopt.nls_map)
  1387. uopt.flags &= ~(1 << UDF_FLAG_NLS_MAP);
  1388. else
  1389. udf_debug("Using default NLS mapn");
  1390. }
  1391. #endif
  1392. if (!(uopt.flags & (1 << UDF_FLAG_NLS_MAP)))
  1393. uopt.flags |= (1 << UDF_FLAG_UTF8);
  1395. fileset.logicalBlockNum = 0xFFFFFFFF;
  1396. fileset.partitionReferenceNum = 0xFFFF;
  1398. UDF_SB(sb)->s_flags = uopt.flags;
  1399. UDF_SB(sb)->s_uid = uopt.uid;
  1400. UDF_SB(sb)->s_gid = uopt.gid;
  1401. UDF_SB(sb)->s_umask = uopt.umask;
  1402. UDF_SB(sb)->s_nls_map = uopt.nls_map;
  1404. /* Set the block size for all transfers */
  1405. if (!udf_set_blocksize(sb, uopt.blocksize))
  1406. goto error_out;
  1408. if ( uopt.session == 0xFFFFFFFF )
  1409. UDF_SB_SESSION(sb) = udf_get_last_session(sb);
  1410. else
  1411. UDF_SB_SESSION(sb) = uopt.session;
  1413. udf_debug("Multi-session=%dn", UDF_SB_SESSION(sb));
  1415. UDF_SB_LASTBLOCK(sb) = uopt.lastblock;
  1416. UDF_SB_ANCHOR(sb)[0] = UDF_SB_ANCHOR(sb)[1] = 0;
  1417. UDF_SB_ANCHOR(sb)[2] = uopt.anchor;
  1418. UDF_SB_ANCHOR(sb)[3] = UDF_SB_SESSION(sb) + 256;
  1420. if (udf_check_valid(sb, uopt.novrs, silent)) /* read volume recognition sequences */
  1421. {
  1422. printk("UDF-fs: No VRS foundn");
  1423.   goto error_out;
  1424. }
  1426. udf_find_anchor(sb);
  1428. /* Fill in the rest of the superblock */
  1429. sb->s_op = &udf_sb_ops;
  1430. sb->dq_op = NULL;
  1431. sb->s_dirt = 0;
  1432. sb->s_magic = UDF_SUPER_MAGIC;
  1434. if (udf_load_partition(sb, &fileset))
  1435. {
  1436. printk("UDF-fs: No partition found (1)n");
  1437. goto error_out;
  1438. }
  1440. udf_debug("Lastblock=%dn", UDF_SB_LASTBLOCK(sb));
  1442. if ( UDF_SB_LVIDBH(sb) )
  1443. {
  1444. Uint16 minUDFReadRev = le16_to_cpu(UDF_SB_LVIDIU(sb)->minUDFReadRev);
  1445. Uint16 minUDFWriteRev = le16_to_cpu(UDF_SB_LVIDIU(sb)->minUDFWriteRev);
  1446. /* Uint16 maxUDFWriteRev = le16_to_cpu(UDF_SB_LVIDIU(sb)->maxUDFWriteRev); */
  1448. if (minUDFReadRev > UDF_MAX_READ_VERSION)
  1449. {
  1450. printk("UDF-fs: minUDFReadRev=%x (max is %x)n",
  1451. UDF_SB_LVIDIU(sb)->minUDFReadRev, UDF_MAX_READ_VERSION);
  1452. goto error_out;
  1453. }
  1454. else if (minUDFWriteRev > UDF_MAX_WRITE_VERSION)
  1455. {
  1456. sb->s_flags |= MS_RDONLY;
  1457. }
  1459. UDF_SB_UDFREV(sb) = minUDFWriteRev;
  1461. if (minUDFReadRev >= UDF_VERS_USE_EXTENDED_FE)
  1462. UDF_SET_FLAG(sb, UDF_FLAG_USE_EXTENDED_FE);
  1463. if (minUDFReadRev >= UDF_VERS_USE_STREAMS)
  1464. UDF_SET_FLAG(sb, UDF_FLAG_USE_STREAMS);
  1465. }
  1467. if ( !UDF_SB_NUMPARTS(sb) )
  1468. {
  1469. printk("UDF-fs: No partition found (2)n");
  1470. goto error_out;
  1471. }
  1473. if ( udf_find_fileset(sb, &fileset, &rootdir) )
  1474. {
  1475. printk("UDF-fs: No fileset foundn");
  1476. goto error_out;
  1477. }
  1479. if (!silent)
  1480. {
  1481. timestamp ts;
  1482. udf_time_to_stamp(&ts, UDF_SB_RECORDTIME(sb), 0);
  1483. udf_info("UDF %s-%s (%s) Mounting volume '%s', timestamp %04u/%02u/%02u %02u:%02u (%x)n",
  1484. UDFFS_VERSION, UDFFS_RW ? "rw" : "ro", UDFFS_DATE,
  1485. UDF_SB_VOLIDENT(sb), ts.year, ts.month, ts.day, ts.hour, ts.minute,
  1486. ts.typeAndTimezone);
  1487. }
  1488. if (!(sb->s_flags & MS_RDONLY))
  1489. udf_open_lvid(sb);
  1491. /* Assign the root inode */
  1492. /* assign inodes by physical block number */
  1493. /* perhaps it's not extensible enough, but for now ... */
  1494. inode = udf_iget(sb, rootdir); 
  1495. if (!inode)
  1496. {
  1497. printk("UDF-fs: Error in udf_iget, block=%d, partition=%dn",
  1498. rootdir.logicalBlockNum, rootdir.partitionReferenceNum);
  1499. goto error_out;
  1500. }
  1502. /* Allocate a dentry for the root inode */
  1503. sb->s_root = d_alloc_root(inode);
  1504. if (!sb->s_root)
  1505. {
  1506. printk("UDF-fs: Couldn't allocate root dentryn");
  1507. iput(inode);
  1508. goto error_out;
  1509. }
  1510. sb->s_maxbytes = ~0ULL;
  1511. return sb;
  1513. error_out:
  1514. if (UDF_SB_VAT(sb))
  1515. iput(UDF_SB_VAT(sb));
  1516. if (UDF_SB_NUMPARTS(sb))
  1517. {
  1518. if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_UNALLOC_TABLE)
  1519. iput(UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_uspace.s_table);
  1520. if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_FREED_TABLE)
  1521. iput(UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_fspace.s_table);
  1522. if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_UNALLOC_BITMAP)
  1523. {
  1524. for (i=0; i<UDF_SB_BITMAP_NR_GROUPS(sb,UDF_SB_PARTITION(sb),s_uspace); i++)
  1525. {
  1526. if (UDF_SB_BITMAP(sb,UDF_SB_PARTITION(sb),s_uspace,i))
  1527. udf_release_data(UDF_SB_BITMAP(sb,UDF_SB_PARTITION(sb),s_uspace,i));
  1528. }
  1529. kfree(UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_uspace.s_bitmap);
  1530. }
  1531. if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_FREED_BITMAP)
  1532. {
  1533. for (i=0; i<UDF_SB_BITMAP_NR_GROUPS(sb,UDF_SB_PARTITION(sb),s_fspace); i++)
  1534. {
  1535. if (UDF_SB_BITMAP(sb,UDF_SB_PARTITION(sb),s_fspace,i))
  1536. udf_release_data(UDF_SB_BITMAP(sb,UDF_SB_PARTITION(sb),s_fspace,i));
  1537. }
  1538. kfree(UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_fspace.s_bitmap);
  1539. }
  1540. if (UDF_SB_PARTTYPE(sb, UDF_SB_PARTITION(sb)) == UDF_SPARABLE_MAP15)
  1541. {
  1542. for (i=0; i<4; i++)
  1543. udf_release_data(UDF_SB_TYPESPAR(sb, UDF_SB_PARTITION(sb)).s_spar_map[i]);
  1544. }
  1545. }
  1546. #ifdef CONFIG_NLS
  1547. if (UDF_QUERY_FLAG(sb, UDF_FLAG_NLS_MAP))
  1548. unload_nls(UDF_SB(sb)->s_nls_map);
  1549. #endif
  1550. if (!(sb->s_flags & MS_RDONLY))
  1551. udf_close_lvid(sb);
  1552. udf_release_data(UDF_SB_LVIDBH(sb));
  1553. UDF_SB_FREE(sb);
  1554. return NULL;
  1555. }
  1557. void udf_error(struct super_block *sb, const char *function,
  1558. const char *fmt, ...)
  1559. {
  1560. va_list args;
  1562. if (!(sb->s_flags & MS_RDONLY))
  1563. {
  1564. /* mark sb error */
  1565. sb->s_dirt = 1;
  1566. }
  1567. va_start(args, fmt);
  1568. vsprintf(error_buf, fmt, args);
  1569. va_end(args);
  1570. printk (KERN_CRIT "UDF-fs error (device %s): %s: %sn",
  1571. bdevname(sb->s_dev), function, error_buf);
  1572. }
  1574. void udf_warning(struct super_block *sb, const char *function,
  1575. const char *fmt, ...)
  1576. {
  1577. va_list args;
  1579. va_start (args, fmt);
  1580. vsprintf(error_buf, fmt, args);
  1581. va_end(args);
  1582. printk(KERN_WARNING "UDF-fs warning (device %s): %s: %sn",
  1583. bdevname(sb->s_dev), function, error_buf);
  1584. }
  1586. /*
  1587.  * udf_put_super
  1588.  *
  1589.  * PURPOSE
  1590.  * Prepare for destruction of the superblock.
  1591.  *
  1592.  * DESCRIPTION
  1593.  * Called before the filesystem is unmounted.
  1594.  *
  1595.  * HISTORY
  1596.  * July 1, 1997 - Andrew E. Mileski
  1597.  * Written, tested, and released.
  1598.  */
  1599. static void
  1600. udf_put_super(struct super_block *sb)
  1601. {
  1602. int i;
  1604. if (UDF_SB_VAT(sb))
  1605. iput(UDF_SB_VAT(sb));
  1606. if (UDF_SB_NUMPARTS(sb))
  1607. {
  1608. if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_UNALLOC_TABLE)
  1609. iput(UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_uspace.s_table);
  1610. if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_FREED_TABLE)
  1611. iput(UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_fspace.s_table);
  1612. if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_UNALLOC_BITMAP)
  1613. {
  1614. for (i=0; i<UDF_SB_BITMAP_NR_GROUPS(sb,UDF_SB_PARTITION(sb),s_uspace); i++)
  1615. {
  1616. if (UDF_SB_BITMAP(sb,UDF_SB_PARTITION(sb),s_uspace,i))
  1617. udf_release_data(UDF_SB_BITMAP(sb,UDF_SB_PARTITION(sb),s_uspace,i));
  1618. }
  1619. kfree(UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_uspace.s_bitmap);
  1620. }
  1621. if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_FREED_BITMAP)
  1622. {
  1623. for (i=0; i<UDF_SB_BITMAP_NR_GROUPS(sb,UDF_SB_PARTITION(sb),s_fspace); i++)
  1624. {
  1625. if (UDF_SB_BITMAP(sb,UDF_SB_PARTITION(sb),s_fspace,i))
  1626. udf_release_data(UDF_SB_BITMAP(sb,UDF_SB_PARTITION(sb),s_fspace,i));
  1627. }
  1628. kfree(UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_fspace.s_bitmap);
  1629. }
  1630. if (UDF_SB_PARTTYPE(sb, UDF_SB_PARTITION(sb)) == UDF_SPARABLE_MAP15)
  1631. {
  1632. for (i=0; i<4; i++)
  1633. udf_release_data(UDF_SB_TYPESPAR(sb, UDF_SB_PARTITION(sb)).s_spar_map[i]);
  1634. }
  1635. }
  1636. #ifdef CONFIG_NLS
  1637. if (UDF_QUERY_FLAG(sb, UDF_FLAG_NLS_MAP))
  1638. unload_nls(UDF_SB(sb)->s_nls_map);
  1639. #endif
  1640. if (!(sb->s_flags & MS_RDONLY))
  1641. udf_close_lvid(sb);
  1642. udf_release_data(UDF_SB_LVIDBH(sb));
  1643. UDF_SB_FREE(sb);
  1644. }
  1646. /*
  1647.  * udf_stat_fs
  1648.  *
  1649.  * PURPOSE
  1650.  * Return info about the filesystem.
  1651.  *
  1652.  * DESCRIPTION
  1653.  * Called by sys_statfs()
  1654.  *
  1655.  * HISTORY
  1656.  * July 1, 1997 - Andrew E. Mileski
  1657.  * Written, tested, and released.
  1658.  */
  1659. static int
  1660. udf_statfs(struct super_block *sb, struct statfs *buf)
  1661. {
  1662. buf->f_type = UDF_SUPER_MAGIC;
  1663. buf->f_bsize = sb->s_blocksize;
  1664. buf->f_blocks = UDF_SB_PARTLEN(sb, UDF_SB_PARTITION(sb));
  1665. buf->f_bfree = udf_count_free(sb);
  1666. buf->f_bavail = buf->f_bfree;
  1667. buf->f_files = (UDF_SB_LVIDBH(sb) ?
  1668. (le32_to_cpu(UDF_SB_LVIDIU(sb)->numFiles) +
  1669. le32_to_cpu(UDF_SB_LVIDIU(sb)->numDirs)) : 0) + buf->f_bfree;
  1670. buf->f_ffree = buf->f_bfree;
  1671. /* __kernel_fsid_t f_fsid */
  1672. buf->f_namelen = UDF_NAME_LEN;
  1674. return 0;
  1675. }
  1677. static unsigned char udf_bitmap_lookup[16] = {
  1678. 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4
  1679. };
  1681. static unsigned int
  1682. udf_count_free_bitmap(struct super_block *sb, struct udf_bitmap *bitmap)
  1683. {
  1684. struct buffer_head *bh = NULL;
  1685. unsigned int accum = 0;
  1686. int index;
  1687. int block = 0, newblock;
  1688. lb_addr loc;
  1689. Uint32 bytes;
  1690. Uint8 value;
  1691. Uint8 *ptr;
  1692. Uint16 ident;
  1693. struct SpaceBitmapDesc *bm;
  1695. loc.logicalBlockNum = bitmap->s_extPosition;
  1696. loc.partitionReferenceNum = UDF_SB_PARTITION(sb);
  1697. bh = udf_read_ptagged(sb, loc, 0, &ident);
  1699. if (!bh)
  1700. {
  1701. printk(KERN_ERR "udf: udf_count_free failedn");
  1702. return 0;
  1703. }
  1704. else if (ident != TID_SPACE_BITMAP_DESC)
  1705. {
  1706. udf_release_data(bh);
  1707. printk(KERN_ERR "udf: udf_count_free failedn");
  1708. return 0;
  1709. }
  1711. bm = (struct SpaceBitmapDesc *)bh->b_data;
  1712. bytes = bm->numOfBytes;
  1713. index = sizeof(struct SpaceBitmapDesc); /* offset in first block only */
  1714. ptr = (Uint8 *)bh->b_data;
  1716. while ( bytes > 0 )
  1717. {
  1718. while ((bytes > 0) && (index < sb->s_blocksize))
  1719. {
  1720. value = ptr[index];
  1721. accum += udf_bitmap_lookup[ value & 0x0f ];
  1722. accum += udf_bitmap_lookup[ value >> 4 ];
  1723. index++;
  1724. bytes--;
  1725. }
  1726. if ( bytes )
  1727. {
  1728. udf_release_data(bh);
  1729. newblock = udf_get_lb_pblock(sb, loc, ++block);
  1730. bh = udf_tread(sb, newblock);
  1731. if (!bh)
  1732. {
  1733. udf_debug("read failedn");
  1734. return accum;
  1735. }
  1736. index = 0;
  1737. ptr = (Uint8 *)bh->b_data;
  1738. }
  1739. }
  1740. udf_release_data(bh);
  1741. return accum;
  1742. }
  1744. static unsigned int
  1745. udf_count_free_table(struct super_block *sb, struct inode * table)
  1746. {
  1747. unsigned int accum = 0;
  1748. Uint32 extoffset, elen;
  1749. lb_addr bloc, eloc;
  1750. Sint8 etype;
  1751. struct buffer_head *bh = NULL;
  1753. bloc = UDF_I_LOCATION(table);
  1754. extoffset = sizeof(struct UnallocatedSpaceEntry);
  1756. while ((etype = udf_next_aext(table, &bloc, &extoffset, &eloc, &elen, &bh, 1)) != -1)
  1757. {
  1758. accum += (elen >> table->i_sb->s_blocksize_bits);
  1759. }
  1760. udf_release_data(bh);
  1761. return accum;
  1762. }
  1764. static unsigned int
  1765. udf_count_free(struct super_block *sb)
  1766. {
  1767. unsigned int accum = 0;
  1769. if (UDF_SB_LVIDBH(sb))
  1770. {
  1771. if (le32_to_cpu(UDF_SB_LVID(sb)->numOfPartitions) > UDF_SB_PARTITION(sb))
  1772. {
  1773. accum = le32_to_cpu(UDF_SB_LVID(sb)->freeSpaceTable[UDF_SB_PARTITION(sb)]);
  1775. if (accum == 0xFFFFFFFF)
  1776. accum = 0;
  1777. }
  1778. }
  1780. if (accum)
  1781. return accum;
  1783. if (UDF_SB_PARTFLAGS(sb,UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_UNALLOC_BITMAP)
  1784. {
  1785. accum += udf_count_free_bitmap(sb,
  1786. UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_uspace.s_bitmap);
  1787. }
  1788. if (UDF_SB_PARTFLAGS(sb,UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_FREED_BITMAP)
  1789. {
  1790. accum += udf_count_free_bitmap(sb,
  1791. UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_fspace.s_bitmap);
  1792. }
  1793. if (accum)
  1794. return accum;
  1796. if (UDF_SB_PARTFLAGS(sb,UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_UNALLOC_TABLE)
  1797. {
  1798. accum += udf_count_free_table(sb,
  1799. UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_uspace.s_table);
  1800. }
  1801. if (UDF_SB_PARTFLAGS(sb,UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_FREED_TABLE)
  1802. {
  1803. accum += udf_count_free_table(sb,
  1804. UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_fspace.s_table);
  1805. }
  1807. return accum;
  1808. }