super.c 51 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872
  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. * COPYRIGHT
  18. * This file is distributed under the terms of the GNU General Public
  19. * License (GPL). Copies of the GPL can be obtained from:
  20. * ftp://prep.ai.mit.edu/pub/gnu/GPL
  21. * Each contributing author retains all rights to their own work.
  22. *
  23. * (C) 1998 Dave Boynton
  24. * (C) 1998-2004 Ben Fennema
  25. * (C) 2000 Stelias Computing Inc
  26. *
  27. * HISTORY
  28. *
  29. * 09/24/98 dgb changed to allow compiling outside of kernel, and
  30. * added some debugging.
  31. * 10/01/98 dgb updated to allow (some) possibility of compiling w/2.0.34
  32. * 10/16/98 attempting some multi-session support
  33. * 10/17/98 added freespace count for "df"
  34. * 11/11/98 gr added novrs option
  35. * 11/26/98 dgb added fileset,anchor mount options
  36. * 12/06/98 blf really hosed things royally. vat/sparing support. sequenced
  37. * vol descs. rewrote option handling based on isofs
  38. * 12/20/98 find the free space bitmap (if it exists)
  39. */
  40. #include "udfdecl.h"
  41. #include <linux/blkdev.h>
  42. #include <linux/slab.h>
  43. #include <linux/kernel.h>
  44. #include <linux/module.h>
  45. #include <linux/parser.h>
  46. #include <linux/stat.h>
  47. #include <linux/cdrom.h>
  48. #include <linux/nls.h>
  49. #include <linux/smp_lock.h>
  50. #include <linux/buffer_head.h>
  51. #include <linux/vfs.h>
  52. #include <linux/vmalloc.h>
  53. #include <asm/byteorder.h>
  54. #include <linux/udf_fs.h>
  55. #include "udf_sb.h"
  56. #include "udf_i.h"
  57. #include <linux/init.h>
  58. #include <asm/uaccess.h>
  59. #define VDS_POS_PRIMARY_VOL_DESC 0
  60. #define VDS_POS_UNALLOC_SPACE_DESC 1
  61. #define VDS_POS_LOGICAL_VOL_DESC 2
  62. #define VDS_POS_PARTITION_DESC 3
  63. #define VDS_POS_IMP_USE_VOL_DESC 4
  64. #define VDS_POS_VOL_DESC_PTR 5
  65. #define VDS_POS_TERMINATING_DESC 6
  66. #define VDS_POS_LENGTH 7
  67. static char error_buf[1024];
  68. /* These are the "meat" - everything else is stuffing */
  69. static int udf_fill_super(struct super_block *, void *, int);
  70. static void udf_put_super(struct super_block *);
  71. static void udf_write_super(struct super_block *);
  72. static int udf_remount_fs(struct super_block *, int *, char *);
  73. static int udf_check_valid(struct super_block *, int, int);
  74. static int udf_vrs(struct super_block *sb, int silent);
  75. static int udf_load_partition(struct super_block *, kernel_lb_addr *);
  76. static int udf_load_logicalvol(struct super_block *, struct buffer_head *,
  77. kernel_lb_addr *);
  78. static void udf_load_logicalvolint(struct super_block *, kernel_extent_ad);
  79. static void udf_find_anchor(struct super_block *);
  80. static int udf_find_fileset(struct super_block *, kernel_lb_addr *,
  81. kernel_lb_addr *);
  82. static void udf_load_pvoldesc(struct super_block *, struct buffer_head *);
  83. static void udf_load_fileset(struct super_block *, struct buffer_head *,
  84. kernel_lb_addr *);
  85. static int udf_load_partdesc(struct super_block *, struct buffer_head *);
  86. static void udf_open_lvid(struct super_block *);
  87. static void udf_close_lvid(struct super_block *);
  88. static unsigned int udf_count_free(struct super_block *);
  89. static int udf_statfs(struct dentry *, struct kstatfs *);
  90. /* UDF filesystem type */
  91. static int udf_get_sb(struct file_system_type *fs_type,
  92. int flags, const char *dev_name, void *data,
  93. struct vfsmount *mnt)
  94. {
  95. return get_sb_bdev(fs_type, flags, dev_name, data, udf_fill_super, mnt);
  96. }
  97. static struct file_system_type udf_fstype = {
  98. .owner = THIS_MODULE,
  99. .name = "udf",
  100. .get_sb = udf_get_sb,
  101. .kill_sb = kill_block_super,
  102. .fs_flags = FS_REQUIRES_DEV,
  103. };
  104. static struct kmem_cache *udf_inode_cachep;
  105. static struct inode *udf_alloc_inode(struct super_block *sb)
  106. {
  107. struct udf_inode_info *ei;
  108. ei = kmem_cache_alloc(udf_inode_cachep, GFP_KERNEL);
  109. if (!ei)
  110. return NULL;
  111. ei->i_unique = 0;
  112. ei->i_lenExtents = 0;
  113. ei->i_next_alloc_block = 0;
  114. ei->i_next_alloc_goal = 0;
  115. ei->i_strat4096 = 0;
  116. return &ei->vfs_inode;
  117. }
  118. static void udf_destroy_inode(struct inode *inode)
  119. {
  120. kmem_cache_free(udf_inode_cachep, UDF_I(inode));
  121. }
  122. static void init_once(struct kmem_cache *cachep, void *foo)
  123. {
  124. struct udf_inode_info *ei = (struct udf_inode_info *)foo;
  125. ei->i_ext.i_data = NULL;
  126. inode_init_once(&ei->vfs_inode);
  127. }
  128. static int init_inodecache(void)
  129. {
  130. udf_inode_cachep = kmem_cache_create("udf_inode_cache",
  131. sizeof(struct udf_inode_info),
  132. 0, (SLAB_RECLAIM_ACCOUNT |
  133. SLAB_MEM_SPREAD),
  134. init_once);
  135. if (!udf_inode_cachep)
  136. return -ENOMEM;
  137. return 0;
  138. }
  139. static void destroy_inodecache(void)
  140. {
  141. kmem_cache_destroy(udf_inode_cachep);
  142. }
  143. /* Superblock operations */
  144. static const struct super_operations udf_sb_ops = {
  145. .alloc_inode = udf_alloc_inode,
  146. .destroy_inode = udf_destroy_inode,
  147. .write_inode = udf_write_inode,
  148. .delete_inode = udf_delete_inode,
  149. .clear_inode = udf_clear_inode,
  150. .put_super = udf_put_super,
  151. .write_super = udf_write_super,
  152. .statfs = udf_statfs,
  153. .remount_fs = udf_remount_fs,
  154. };
  155. struct udf_options {
  156. unsigned char novrs;
  157. unsigned int blocksize;
  158. unsigned int session;
  159. unsigned int lastblock;
  160. unsigned int anchor;
  161. unsigned int volume;
  162. unsigned short partition;
  163. unsigned int fileset;
  164. unsigned int rootdir;
  165. unsigned int flags;
  166. mode_t umask;
  167. gid_t gid;
  168. uid_t uid;
  169. struct nls_table *nls_map;
  170. };
  171. static int __init init_udf_fs(void)
  172. {
  173. int err;
  174. err = init_inodecache();
  175. if (err)
  176. goto out1;
  177. err = register_filesystem(&udf_fstype);
  178. if (err)
  179. goto out;
  180. return 0;
  181. out:
  182. destroy_inodecache();
  183. out1:
  184. return err;
  185. }
  186. static void __exit exit_udf_fs(void)
  187. {
  188. unregister_filesystem(&udf_fstype);
  189. destroy_inodecache();
  190. }
  191. module_init(init_udf_fs)
  192. module_exit(exit_udf_fs)
  193. /*
  194. * udf_parse_options
  195. *
  196. * PURPOSE
  197. * Parse mount options.
  198. *
  199. * DESCRIPTION
  200. * The following mount options are supported:
  201. *
  202. * gid= Set the default group.
  203. * umask= Set the default umask.
  204. * uid= Set the default user.
  205. * bs= Set the block size.
  206. * unhide Show otherwise hidden files.
  207. * undelete Show deleted files in lists.
  208. * adinicb Embed data in the inode (default)
  209. * noadinicb Don't embed data in the inode
  210. * shortad Use short ad's
  211. * longad Use long ad's (default)
  212. * nostrict Unset strict conformance
  213. * iocharset= Set the NLS character set
  214. *
  215. * The remaining are for debugging and disaster recovery:
  216. *
  217. * novrs Skip volume sequence recognition
  218. *
  219. * The following expect a offset from 0.
  220. *
  221. * session= Set the CDROM session (default= last session)
  222. * anchor= Override standard anchor location. (default= 256)
  223. * volume= Override the VolumeDesc location. (unused)
  224. * partition= Override the PartitionDesc location. (unused)
  225. * lastblock= Set the last block of the filesystem/
  226. *
  227. * The following expect a offset from the partition root.
  228. *
  229. * fileset= Override the fileset block location. (unused)
  230. * rootdir= Override the root directory location. (unused)
  231. * WARNING: overriding the rootdir to a non-directory may
  232. * yield highly unpredictable results.
  233. *
  234. * PRE-CONDITIONS
  235. * options Pointer to mount options string.
  236. * uopts Pointer to mount options variable.
  237. *
  238. * POST-CONDITIONS
  239. * <return> 1 Mount options parsed okay.
  240. * <return> 0 Error parsing mount options.
  241. *
  242. * HISTORY
  243. * July 1, 1997 - Andrew E. Mileski
  244. * Written, tested, and released.
  245. */
  246. enum {
  247. Opt_novrs, Opt_nostrict, Opt_bs, Opt_unhide, Opt_undelete,
  248. Opt_noadinicb, Opt_adinicb, Opt_shortad, Opt_longad,
  249. Opt_gid, Opt_uid, Opt_umask, Opt_session, Opt_lastblock,
  250. Opt_anchor, Opt_volume, Opt_partition, Opt_fileset,
  251. Opt_rootdir, Opt_utf8, Opt_iocharset,
  252. Opt_err, Opt_uforget, Opt_uignore, Opt_gforget, Opt_gignore
  253. };
  254. static match_table_t tokens = {
  255. {Opt_novrs, "novrs"},
  256. {Opt_nostrict, "nostrict"},
  257. {Opt_bs, "bs=%u"},
  258. {Opt_unhide, "unhide"},
  259. {Opt_undelete, "undelete"},
  260. {Opt_noadinicb, "noadinicb"},
  261. {Opt_adinicb, "adinicb"},
  262. {Opt_shortad, "shortad"},
  263. {Opt_longad, "longad"},
  264. {Opt_uforget, "uid=forget"},
  265. {Opt_uignore, "uid=ignore"},
  266. {Opt_gforget, "gid=forget"},
  267. {Opt_gignore, "gid=ignore"},
  268. {Opt_gid, "gid=%u"},
  269. {Opt_uid, "uid=%u"},
  270. {Opt_umask, "umask=%o"},
  271. {Opt_session, "session=%u"},
  272. {Opt_lastblock, "lastblock=%u"},
  273. {Opt_anchor, "anchor=%u"},
  274. {Opt_volume, "volume=%u"},
  275. {Opt_partition, "partition=%u"},
  276. {Opt_fileset, "fileset=%u"},
  277. {Opt_rootdir, "rootdir=%u"},
  278. {Opt_utf8, "utf8"},
  279. {Opt_iocharset, "iocharset=%s"},
  280. {Opt_err, NULL}
  281. };
  282. static int udf_parse_options(char *options, struct udf_options *uopt)
  283. {
  284. char *p;
  285. int option;
  286. uopt->novrs = 0;
  287. uopt->blocksize = 2048;
  288. uopt->partition = 0xFFFF;
  289. uopt->session = 0xFFFFFFFF;
  290. uopt->lastblock = 0;
  291. uopt->anchor = 0;
  292. uopt->volume = 0xFFFFFFFF;
  293. uopt->rootdir = 0xFFFFFFFF;
  294. uopt->fileset = 0xFFFFFFFF;
  295. uopt->nls_map = NULL;
  296. if (!options)
  297. return 1;
  298. while ((p = strsep(&options, ",")) != NULL) {
  299. substring_t args[MAX_OPT_ARGS];
  300. int token;
  301. if (!*p)
  302. continue;
  303. token = match_token(p, tokens, args);
  304. switch (token) {
  305. case Opt_novrs:
  306. uopt->novrs = 1;
  307. case Opt_bs:
  308. if (match_int(&args[0], &option))
  309. return 0;
  310. uopt->blocksize = option;
  311. break;
  312. case Opt_unhide:
  313. uopt->flags |= (1 << UDF_FLAG_UNHIDE);
  314. break;
  315. case Opt_undelete:
  316. uopt->flags |= (1 << UDF_FLAG_UNDELETE);
  317. break;
  318. case Opt_noadinicb:
  319. uopt->flags &= ~(1 << UDF_FLAG_USE_AD_IN_ICB);
  320. break;
  321. case Opt_adinicb:
  322. uopt->flags |= (1 << UDF_FLAG_USE_AD_IN_ICB);
  323. break;
  324. case Opt_shortad:
  325. uopt->flags |= (1 << UDF_FLAG_USE_SHORT_AD);
  326. break;
  327. case Opt_longad:
  328. uopt->flags &= ~(1 << UDF_FLAG_USE_SHORT_AD);
  329. break;
  330. case Opt_gid:
  331. if (match_int(args, &option))
  332. return 0;
  333. uopt->gid = option;
  334. uopt->flags |= (1 << UDF_FLAG_GID_SET);
  335. break;
  336. case Opt_uid:
  337. if (match_int(args, &option))
  338. return 0;
  339. uopt->uid = option;
  340. uopt->flags |= (1 << UDF_FLAG_UID_SET);
  341. break;
  342. case Opt_umask:
  343. if (match_octal(args, &option))
  344. return 0;
  345. uopt->umask = option;
  346. break;
  347. case Opt_nostrict:
  348. uopt->flags &= ~(1 << UDF_FLAG_STRICT);
  349. break;
  350. case Opt_session:
  351. if (match_int(args, &option))
  352. return 0;
  353. uopt->session = option;
  354. break;
  355. case Opt_lastblock:
  356. if (match_int(args, &option))
  357. return 0;
  358. uopt->lastblock = option;
  359. break;
  360. case Opt_anchor:
  361. if (match_int(args, &option))
  362. return 0;
  363. uopt->anchor = option;
  364. break;
  365. case Opt_volume:
  366. if (match_int(args, &option))
  367. return 0;
  368. uopt->volume = option;
  369. break;
  370. case Opt_partition:
  371. if (match_int(args, &option))
  372. return 0;
  373. uopt->partition = option;
  374. break;
  375. case Opt_fileset:
  376. if (match_int(args, &option))
  377. return 0;
  378. uopt->fileset = option;
  379. break;
  380. case Opt_rootdir:
  381. if (match_int(args, &option))
  382. return 0;
  383. uopt->rootdir = option;
  384. break;
  385. case Opt_utf8:
  386. uopt->flags |= (1 << UDF_FLAG_UTF8);
  387. break;
  388. #ifdef CONFIG_UDF_NLS
  389. case Opt_iocharset:
  390. uopt->nls_map = load_nls(args[0].from);
  391. uopt->flags |= (1 << UDF_FLAG_NLS_MAP);
  392. break;
  393. #endif
  394. case Opt_uignore:
  395. uopt->flags |= (1 << UDF_FLAG_UID_IGNORE);
  396. break;
  397. case Opt_uforget:
  398. uopt->flags |= (1 << UDF_FLAG_UID_FORGET);
  399. break;
  400. case Opt_gignore:
  401. uopt->flags |= (1 << UDF_FLAG_GID_IGNORE);
  402. break;
  403. case Opt_gforget:
  404. uopt->flags |= (1 << UDF_FLAG_GID_FORGET);
  405. break;
  406. default:
  407. printk(KERN_ERR "udf: bad mount option \"%s\" "
  408. "or missing value\n", p);
  409. return 0;
  410. }
  411. }
  412. return 1;
  413. }
  414. void udf_write_super(struct super_block *sb)
  415. {
  416. lock_kernel();
  417. if (!(sb->s_flags & MS_RDONLY))
  418. udf_open_lvid(sb);
  419. sb->s_dirt = 0;
  420. unlock_kernel();
  421. }
  422. static int udf_remount_fs(struct super_block *sb, int *flags, char *options)
  423. {
  424. struct udf_options uopt;
  425. uopt.flags = UDF_SB(sb)->s_flags;
  426. uopt.uid = UDF_SB(sb)->s_uid;
  427. uopt.gid = UDF_SB(sb)->s_gid;
  428. uopt.umask = UDF_SB(sb)->s_umask;
  429. if (!udf_parse_options(options, &uopt))
  430. return -EINVAL;
  431. UDF_SB(sb)->s_flags = uopt.flags;
  432. UDF_SB(sb)->s_uid = uopt.uid;
  433. UDF_SB(sb)->s_gid = uopt.gid;
  434. UDF_SB(sb)->s_umask = uopt.umask;
  435. if (UDF_SB_LVIDBH(sb)) {
  436. int write_rev = le16_to_cpu(UDF_SB_LVIDIU(sb)->minUDFWriteRev);
  437. if (write_rev > UDF_MAX_WRITE_VERSION)
  438. *flags |= MS_RDONLY;
  439. }
  440. if ((*flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY))
  441. return 0;
  442. if (*flags & MS_RDONLY)
  443. udf_close_lvid(sb);
  444. else
  445. udf_open_lvid(sb);
  446. return 0;
  447. }
  448. /*
  449. * udf_set_blocksize
  450. *
  451. * PURPOSE
  452. * Set the block size to be used in all transfers.
  453. *
  454. * DESCRIPTION
  455. * To allow room for a DMA transfer, it is best to guess big when unsure.
  456. * This routine picks 2048 bytes as the blocksize when guessing. This
  457. * should be adequate until devices with larger block sizes become common.
  458. *
  459. * Note that the Linux kernel can currently only deal with blocksizes of
  460. * 512, 1024, 2048, 4096, and 8192 bytes.
  461. *
  462. * PRE-CONDITIONS
  463. * sb Pointer to _locked_ superblock.
  464. *
  465. * POST-CONDITIONS
  466. * sb->s_blocksize Blocksize.
  467. * sb->s_blocksize_bits log2 of blocksize.
  468. * <return> 0 Blocksize is valid.
  469. * <return> 1 Blocksize is invalid.
  470. *
  471. * HISTORY
  472. * July 1, 1997 - Andrew E. Mileski
  473. * Written, tested, and released.
  474. */
  475. static int udf_set_blocksize(struct super_block *sb, int bsize)
  476. {
  477. if (!sb_min_blocksize(sb, bsize)) {
  478. udf_debug("Bad block size (%d)\n", bsize);
  479. printk(KERN_ERR "udf: bad block size (%d)\n", bsize);
  480. return 0;
  481. }
  482. return sb->s_blocksize;
  483. }
  484. static int udf_vrs(struct super_block *sb, int silent)
  485. {
  486. struct volStructDesc *vsd = NULL;
  487. int sector = 32768;
  488. int sectorsize;
  489. struct buffer_head *bh = NULL;
  490. int iso9660 = 0;
  491. int nsr02 = 0;
  492. int nsr03 = 0;
  493. /* Block size must be a multiple of 512 */
  494. if (sb->s_blocksize & 511)
  495. return 0;
  496. if (sb->s_blocksize < sizeof(struct volStructDesc))
  497. sectorsize = sizeof(struct volStructDesc);
  498. else
  499. sectorsize = sb->s_blocksize;
  500. sector += (UDF_SB_SESSION(sb) << sb->s_blocksize_bits);
  501. udf_debug("Starting at sector %u (%ld byte sectors)\n",
  502. (sector >> sb->s_blocksize_bits), sb->s_blocksize);
  503. /* Process the sequence (if applicable) */
  504. for (; !nsr02 && !nsr03; sector += sectorsize) {
  505. /* Read a block */
  506. bh = udf_tread(sb, sector >> sb->s_blocksize_bits);
  507. if (!bh)
  508. break;
  509. /* Look for ISO descriptors */
  510. vsd = (struct volStructDesc *)(bh->b_data +
  511. (sector & (sb->s_blocksize - 1)));
  512. if (vsd->stdIdent[0] == 0) {
  513. brelse(bh);
  514. break;
  515. } else if (!strncmp(vsd->stdIdent, VSD_STD_ID_CD001,
  516. VSD_STD_ID_LEN)) {
  517. iso9660 = sector;
  518. switch (vsd->structType) {
  519. case 0:
  520. udf_debug("ISO9660 Boot Record found\n");
  521. break;
  522. case 1:
  523. udf_debug("ISO9660 Primary Volume Descriptor "
  524. "found\n");
  525. break;
  526. case 2:
  527. udf_debug("ISO9660 Supplementary Volume "
  528. "Descriptor found\n");
  529. break;
  530. case 3:
  531. udf_debug("ISO9660 Volume Partition Descriptor "
  532. "found\n");
  533. break;
  534. case 255:
  535. udf_debug("ISO9660 Volume Descriptor Set "
  536. "Terminator found\n");
  537. break;
  538. default:
  539. udf_debug("ISO9660 VRS (%u) found\n",
  540. vsd->structType);
  541. break;
  542. }
  543. } else if (!strncmp(vsd->stdIdent, VSD_STD_ID_BEA01,
  544. VSD_STD_ID_LEN))
  545. ; /* nothing */
  546. else if (!strncmp(vsd->stdIdent, VSD_STD_ID_TEA01,
  547. VSD_STD_ID_LEN)) {
  548. brelse(bh);
  549. break;
  550. } else if (!strncmp(vsd->stdIdent, VSD_STD_ID_NSR02,
  551. VSD_STD_ID_LEN))
  552. nsr02 = sector;
  553. else if (!strncmp(vsd->stdIdent, VSD_STD_ID_NSR03,
  554. VSD_STD_ID_LEN))
  555. nsr03 = sector;
  556. brelse(bh);
  557. }
  558. if (nsr03)
  559. return nsr03;
  560. else if (nsr02)
  561. return nsr02;
  562. else if (sector - (UDF_SB_SESSION(sb) << sb->s_blocksize_bits) == 32768)
  563. return -1;
  564. else
  565. return 0;
  566. }
  567. /*
  568. * udf_find_anchor
  569. *
  570. * PURPOSE
  571. * Find an anchor volume descriptor.
  572. *
  573. * PRE-CONDITIONS
  574. * sb Pointer to _locked_ superblock.
  575. * lastblock Last block on media.
  576. *
  577. * POST-CONDITIONS
  578. * <return> 1 if not found, 0 if ok
  579. *
  580. * HISTORY
  581. * July 1, 1997 - Andrew E. Mileski
  582. * Written, tested, and released.
  583. */
  584. static void udf_find_anchor(struct super_block *sb)
  585. {
  586. int lastblock = UDF_SB_LASTBLOCK(sb);
  587. struct buffer_head *bh = NULL;
  588. uint16_t ident;
  589. uint32_t location;
  590. int i;
  591. if (lastblock) {
  592. int varlastblock = udf_variable_to_fixed(lastblock);
  593. int last[] = { lastblock, lastblock - 2,
  594. lastblock - 150, lastblock - 152,
  595. varlastblock, varlastblock - 2,
  596. varlastblock - 150, varlastblock - 152 };
  597. lastblock = 0;
  598. /* Search for an anchor volume descriptor pointer */
  599. /* according to spec, anchor is in either:
  600. * block 256
  601. * lastblock-256
  602. * lastblock
  603. * however, if the disc isn't closed, it could be 512 */
  604. for (i = 0; !lastblock && i < ARRAY_SIZE(last); i++) {
  605. ident = location = 0;
  606. if (last[i] >= 0) {
  607. bh = sb_bread(sb, last[i]);
  608. if (bh) {
  609. tag *t = (tag *)bh->b_data;
  610. ident = le16_to_cpu(t->tagIdent);
  611. location = le32_to_cpu(t->tagLocation);
  612. brelse(bh);
  613. }
  614. }
  615. if (ident == TAG_IDENT_AVDP) {
  616. if (location == last[i] - UDF_SB_SESSION(sb)) {
  617. lastblock = last[i] - UDF_SB_SESSION(sb);
  618. UDF_SB_ANCHOR(sb)[0] = lastblock;
  619. UDF_SB_ANCHOR(sb)[1] = lastblock - 256;
  620. } else if (location == udf_variable_to_fixed(last[i]) - UDF_SB_SESSION(sb)) {
  621. UDF_SET_FLAG(sb, UDF_FLAG_VARCONV);
  622. lastblock = udf_variable_to_fixed(last[i]) - UDF_SB_SESSION(sb);
  623. UDF_SB_ANCHOR(sb)[0] = lastblock;
  624. UDF_SB_ANCHOR(sb)[1] = lastblock - 256 - UDF_SB_SESSION(sb);
  625. } else {
  626. udf_debug("Anchor found at block %d, location mismatch %d.\n",
  627. last[i], location);
  628. }
  629. } else if (ident == TAG_IDENT_FE || ident == TAG_IDENT_EFE) {
  630. lastblock = last[i];
  631. UDF_SB_ANCHOR(sb)[3] = 512;
  632. } else {
  633. ident = location = 0;
  634. if (last[i] >= 256) {
  635. bh = sb_bread(sb, last[i] - 256);
  636. if (bh) {
  637. tag *t = (tag *)bh->b_data;
  638. ident = le16_to_cpu(t->tagIdent);
  639. location = le32_to_cpu(t->tagLocation);
  640. brelse(bh);
  641. }
  642. }
  643. if (ident == TAG_IDENT_AVDP &&
  644. location == last[i] - 256 - UDF_SB_SESSION(sb)) {
  645. lastblock = last[i];
  646. UDF_SB_ANCHOR(sb)[1] = last[i] - 256;
  647. } else {
  648. ident = location = 0;
  649. if (last[i] >= 312 + UDF_SB_SESSION(sb)) {
  650. bh = sb_bread(sb, last[i] - 312 - UDF_SB_SESSION(sb));
  651. if (bh) {
  652. tag *t = (tag *)bh->b_data;
  653. ident = le16_to_cpu(t->tagIdent);
  654. location = le32_to_cpu(t->tagLocation);
  655. brelse(bh);
  656. }
  657. }
  658. if (ident == TAG_IDENT_AVDP &&
  659. location == udf_variable_to_fixed(last[i]) - 256) {
  660. UDF_SET_FLAG(sb, UDF_FLAG_VARCONV);
  661. lastblock = udf_variable_to_fixed(last[i]);
  662. UDF_SB_ANCHOR(sb)[1] = lastblock - 256;
  663. }
  664. }
  665. }
  666. }
  667. }
  668. if (!lastblock) {
  669. /* We haven't found the lastblock. check 312 */
  670. bh = sb_bread(sb, 312 + UDF_SB_SESSION(sb));
  671. if (bh) {
  672. tag *t = (tag *)bh->b_data;
  673. ident = le16_to_cpu(t->tagIdent);
  674. location = le32_to_cpu(t->tagLocation);
  675. brelse(bh);
  676. if (ident == TAG_IDENT_AVDP && location == 256)
  677. UDF_SET_FLAG(sb, UDF_FLAG_VARCONV);
  678. }
  679. }
  680. for (i = 0; i < ARRAY_SIZE(UDF_SB_ANCHOR(sb)); i++) {
  681. if (UDF_SB_ANCHOR(sb)[i]) {
  682. bh = udf_read_tagged(sb, UDF_SB_ANCHOR(sb)[i],
  683. UDF_SB_ANCHOR(sb)[i], &ident);
  684. if (!bh)
  685. UDF_SB_ANCHOR(sb)[i] = 0;
  686. else {
  687. brelse(bh);
  688. if ((ident != TAG_IDENT_AVDP) &&
  689. (i || (ident != TAG_IDENT_FE && ident != TAG_IDENT_EFE)))
  690. UDF_SB_ANCHOR(sb)[i] = 0;
  691. }
  692. }
  693. }
  694. UDF_SB_LASTBLOCK(sb) = lastblock;
  695. }
  696. static int udf_find_fileset(struct super_block *sb,
  697. kernel_lb_addr *fileset,
  698. kernel_lb_addr *root)
  699. {
  700. struct buffer_head *bh = NULL;
  701. long lastblock;
  702. uint16_t ident;
  703. if (fileset->logicalBlockNum != 0xFFFFFFFF ||
  704. fileset->partitionReferenceNum != 0xFFFF) {
  705. bh = udf_read_ptagged(sb, *fileset, 0, &ident);
  706. if (!bh) {
  707. return 1;
  708. } else if (ident != TAG_IDENT_FSD) {
  709. brelse(bh);
  710. return 1;
  711. }
  712. }
  713. if (!bh) {
  714. /* Search backwards through the partitions */
  715. kernel_lb_addr newfileset;
  716. /* --> cvg: FIXME - is it reasonable? */
  717. return 1;
  718. for (newfileset.partitionReferenceNum = UDF_SB_NUMPARTS(sb) - 1;
  719. (newfileset.partitionReferenceNum != 0xFFFF &&
  720. fileset->logicalBlockNum == 0xFFFFFFFF &&
  721. fileset->partitionReferenceNum == 0xFFFF);
  722. newfileset.partitionReferenceNum--) {
  723. lastblock = UDF_SB_PARTLEN(sb,
  724. newfileset.partitionReferenceNum);
  725. newfileset.logicalBlockNum = 0;
  726. do {
  727. bh = udf_read_ptagged(sb, newfileset, 0,
  728. &ident);
  729. if (!bh) {
  730. newfileset.logicalBlockNum++;
  731. continue;
  732. }
  733. switch (ident) {
  734. case TAG_IDENT_SBD:
  735. {
  736. struct spaceBitmapDesc *sp;
  737. sp = (struct spaceBitmapDesc *)bh->b_data;
  738. newfileset.logicalBlockNum += 1 +
  739. ((le32_to_cpu(sp->numOfBytes) +
  740. sizeof(struct spaceBitmapDesc) - 1)
  741. >> sb->s_blocksize_bits);
  742. brelse(bh);
  743. break;
  744. }
  745. case TAG_IDENT_FSD:
  746. *fileset = newfileset;
  747. break;
  748. default:
  749. newfileset.logicalBlockNum++;
  750. brelse(bh);
  751. bh = NULL;
  752. break;
  753. }
  754. } while (newfileset.logicalBlockNum < lastblock &&
  755. fileset->logicalBlockNum == 0xFFFFFFFF &&
  756. fileset->partitionReferenceNum == 0xFFFF);
  757. }
  758. }
  759. if ((fileset->logicalBlockNum != 0xFFFFFFFF ||
  760. fileset->partitionReferenceNum != 0xFFFF) && bh) {
  761. udf_debug("Fileset at block=%d, partition=%d\n",
  762. fileset->logicalBlockNum,
  763. fileset->partitionReferenceNum);
  764. UDF_SB_PARTITION(sb) = fileset->partitionReferenceNum;
  765. udf_load_fileset(sb, bh, root);
  766. brelse(bh);
  767. return 0;
  768. }
  769. return 1;
  770. }
  771. static void udf_load_pvoldesc(struct super_block *sb, struct buffer_head *bh)
  772. {
  773. struct primaryVolDesc *pvoldesc;
  774. time_t recording;
  775. long recording_usec;
  776. struct ustr instr;
  777. struct ustr outstr;
  778. pvoldesc = (struct primaryVolDesc *)bh->b_data;
  779. if (udf_stamp_to_time(&recording, &recording_usec,
  780. lets_to_cpu(pvoldesc->recordingDateAndTime))) {
  781. kernel_timestamp ts;
  782. ts = lets_to_cpu(pvoldesc->recordingDateAndTime);
  783. udf_debug("recording time %ld/%ld, %04u/%02u/%02u"
  784. " %02u:%02u (%x)\n",
  785. recording, recording_usec,
  786. ts.year, ts.month, ts.day, ts.hour,
  787. ts.minute, ts.typeAndTimezone);
  788. UDF_SB_RECORDTIME(sb).tv_sec = recording;
  789. UDF_SB_RECORDTIME(sb).tv_nsec = recording_usec * 1000;
  790. }
  791. if (!udf_build_ustr(&instr, pvoldesc->volIdent, 32)) {
  792. if (udf_CS0toUTF8(&outstr, &instr)) {
  793. strncpy(UDF_SB_VOLIDENT(sb), outstr.u_name,
  794. outstr.u_len > 31 ? 31 : outstr.u_len);
  795. udf_debug("volIdent[] = '%s'\n", UDF_SB_VOLIDENT(sb));
  796. }
  797. }
  798. if (!udf_build_ustr(&instr, pvoldesc->volSetIdent, 128)) {
  799. if (udf_CS0toUTF8(&outstr, &instr))
  800. udf_debug("volSetIdent[] = '%s'\n", outstr.u_name);
  801. }
  802. }
  803. static void udf_load_fileset(struct super_block *sb, struct buffer_head *bh,
  804. kernel_lb_addr *root)
  805. {
  806. struct fileSetDesc *fset;
  807. fset = (struct fileSetDesc *)bh->b_data;
  808. *root = lelb_to_cpu(fset->rootDirectoryICB.extLocation);
  809. UDF_SB_SERIALNUM(sb) = le16_to_cpu(fset->descTag.tagSerialNum);
  810. udf_debug("Rootdir at block=%d, partition=%d\n",
  811. root->logicalBlockNum, root->partitionReferenceNum);
  812. }
  813. static int udf_load_partdesc(struct super_block *sb, struct buffer_head *bh)
  814. {
  815. struct partitionDesc *p;
  816. int i;
  817. p = (struct partitionDesc *)bh->b_data;
  818. for (i = 0; i < UDF_SB_NUMPARTS(sb); i++) {
  819. udf_debug("Searching map: (%d == %d)\n",
  820. UDF_SB_PARTMAPS(sb)[i].s_partition_num, le16_to_cpu(p->partitionNumber));
  821. if (UDF_SB_PARTMAPS(sb)[i].s_partition_num == le16_to_cpu(p->partitionNumber)) {
  822. UDF_SB_PARTLEN(sb, i) = le32_to_cpu(p->partitionLength); /* blocks */
  823. UDF_SB_PARTROOT(sb, i) = le32_to_cpu(p->partitionStartingLocation);
  824. if (le32_to_cpu(p->accessType) == PD_ACCESS_TYPE_READ_ONLY)
  825. UDF_SB_PARTFLAGS(sb, i) |= UDF_PART_FLAG_READ_ONLY;
  826. if (le32_to_cpu(p->accessType) == PD_ACCESS_TYPE_WRITE_ONCE)
  827. UDF_SB_PARTFLAGS(sb, i) |= UDF_PART_FLAG_WRITE_ONCE;
  828. if (le32_to_cpu(p->accessType) == PD_ACCESS_TYPE_REWRITABLE)
  829. UDF_SB_PARTFLAGS(sb, i) |= UDF_PART_FLAG_REWRITABLE;
  830. if (le32_to_cpu(p->accessType) == PD_ACCESS_TYPE_OVERWRITABLE)
  831. UDF_SB_PARTFLAGS(sb, i) |= UDF_PART_FLAG_OVERWRITABLE;
  832. if (!strcmp(p->partitionContents.ident,
  833. PD_PARTITION_CONTENTS_NSR02) ||
  834. !strcmp(p->partitionContents.ident,
  835. PD_PARTITION_CONTENTS_NSR03)) {
  836. struct partitionHeaderDesc *phd;
  837. phd = (struct partitionHeaderDesc *)(p->partitionContentsUse);
  838. if (phd->unallocSpaceTable.extLength) {
  839. kernel_lb_addr loc = {
  840. .logicalBlockNum = le32_to_cpu(phd->unallocSpaceTable.extPosition),
  841. .partitionReferenceNum = i,
  842. };
  843. UDF_SB_PARTMAPS(sb)[i].s_uspace.s_table =
  844. udf_iget(sb, loc);
  845. if (!UDF_SB_PARTMAPS(sb)[i].s_uspace.s_table) {
  846. udf_debug("cannot load unallocSpaceTable (part %d)\n", i);
  847. return 1;
  848. }
  849. UDF_SB_PARTFLAGS(sb, i) |= UDF_PART_FLAG_UNALLOC_TABLE;
  850. udf_debug("unallocSpaceTable (part %d) @ %ld\n",
  851. i, UDF_SB_PARTMAPS(sb)[i].s_uspace.s_table->i_ino);
  852. }
  853. if (phd->unallocSpaceBitmap.extLength) {
  854. UDF_SB_ALLOC_BITMAP(sb, i, s_uspace);
  855. if (UDF_SB_PARTMAPS(sb)[i].s_uspace.s_bitmap != NULL) {
  856. UDF_SB_PARTMAPS(sb)[i].s_uspace.s_bitmap->s_extLength =
  857. le32_to_cpu(phd->unallocSpaceBitmap.extLength);
  858. UDF_SB_PARTMAPS(sb)[i].s_uspace.s_bitmap->s_extPosition =
  859. le32_to_cpu(phd->unallocSpaceBitmap.extPosition);
  860. UDF_SB_PARTFLAGS(sb, i) |= UDF_PART_FLAG_UNALLOC_BITMAP;
  861. udf_debug("unallocSpaceBitmap (part %d) @ %d\n",
  862. i, UDF_SB_PARTMAPS(sb)[i].s_uspace.s_bitmap->s_extPosition);
  863. }
  864. }
  865. if (phd->partitionIntegrityTable.extLength)
  866. udf_debug("partitionIntegrityTable (part %d)\n", i);
  867. if (phd->freedSpaceTable.extLength) {
  868. kernel_lb_addr loc = {
  869. .logicalBlockNum = le32_to_cpu(phd->freedSpaceTable.extPosition),
  870. .partitionReferenceNum = i,
  871. };
  872. UDF_SB_PARTMAPS(sb)[i].s_fspace.s_table =
  873. udf_iget(sb, loc);
  874. if (!UDF_SB_PARTMAPS(sb)[i].s_fspace.s_table) {
  875. udf_debug("cannot load freedSpaceTable (part %d)\n", i);
  876. return 1;
  877. }
  878. UDF_SB_PARTFLAGS(sb, i) |= UDF_PART_FLAG_FREED_TABLE;
  879. udf_debug("freedSpaceTable (part %d) @ %ld\n",
  880. i, UDF_SB_PARTMAPS(sb)[i].s_fspace.s_table->i_ino);
  881. }
  882. if (phd->freedSpaceBitmap.extLength) {
  883. UDF_SB_ALLOC_BITMAP(sb, i, s_fspace);
  884. if (UDF_SB_PARTMAPS(sb)[i].s_fspace.s_bitmap != NULL) {
  885. UDF_SB_PARTMAPS(sb)[i].s_fspace.s_bitmap->s_extLength =
  886. le32_to_cpu(phd->freedSpaceBitmap.extLength);
  887. UDF_SB_PARTMAPS(sb)[i].s_fspace.s_bitmap->s_extPosition =
  888. le32_to_cpu(phd->freedSpaceBitmap.extPosition);
  889. UDF_SB_PARTFLAGS(sb, i) |= UDF_PART_FLAG_FREED_BITMAP;
  890. udf_debug("freedSpaceBitmap (part %d) @ %d\n",
  891. i, UDF_SB_PARTMAPS(sb)[i].s_fspace.s_bitmap->s_extPosition);
  892. }
  893. }
  894. }
  895. break;
  896. }
  897. }
  898. if (i == UDF_SB_NUMPARTS(sb)) {
  899. udf_debug("Partition (%d) not found in partition map\n",
  900. le16_to_cpu(p->partitionNumber));
  901. } else {
  902. udf_debug("Partition (%d:%d type %x) starts at physical %d, "
  903. "block length %d\n",
  904. le16_to_cpu(p->partitionNumber), i,
  905. UDF_SB_PARTTYPE(sb, i), UDF_SB_PARTROOT(sb, i),
  906. UDF_SB_PARTLEN(sb, i));
  907. }
  908. return 0;
  909. }
  910. static int udf_load_logicalvol(struct super_block *sb, struct buffer_head *bh,
  911. kernel_lb_addr *fileset)
  912. {
  913. struct logicalVolDesc *lvd;
  914. int i, j, offset;
  915. uint8_t type;
  916. lvd = (struct logicalVolDesc *)bh->b_data;
  917. UDF_SB_ALLOC_PARTMAPS(sb, le32_to_cpu(lvd->numPartitionMaps));
  918. for (i = 0, offset = 0;
  919. i < UDF_SB_NUMPARTS(sb) && offset < le32_to_cpu(lvd->mapTableLength);
  920. i++, offset += ((struct genericPartitionMap *)&(lvd->partitionMaps[offset]))->partitionMapLength) {
  921. type = ((struct genericPartitionMap *)&(lvd->partitionMaps[offset]))->partitionMapType;
  922. if (type == 1) {
  923. struct genericPartitionMap1 *gpm1 = (struct genericPartitionMap1 *)&(lvd->partitionMaps[offset]);
  924. UDF_SB_PARTTYPE(sb, i) = UDF_TYPE1_MAP15;
  925. UDF_SB_PARTVSN(sb, i) = le16_to_cpu(gpm1->volSeqNum);
  926. UDF_SB_PARTNUM(sb, i) = le16_to_cpu(gpm1->partitionNum);
  927. UDF_SB_PARTFUNC(sb, i) = NULL;
  928. } else if (type == 2) {
  929. struct udfPartitionMap2 *upm2 = (struct udfPartitionMap2 *)&(lvd->partitionMaps[offset]);
  930. if (!strncmp(upm2->partIdent.ident, UDF_ID_VIRTUAL, strlen(UDF_ID_VIRTUAL))) {
  931. if (le16_to_cpu(((__le16 *)upm2->partIdent.identSuffix)[0]) == 0x0150) {
  932. UDF_SB_PARTTYPE(sb, i) = UDF_VIRTUAL_MAP15;
  933. UDF_SB_PARTFUNC(sb, i) = udf_get_pblock_virt15;
  934. } else if (le16_to_cpu(((__le16 *)upm2->partIdent.identSuffix)[0]) == 0x0200) {
  935. UDF_SB_PARTTYPE(sb, i) = UDF_VIRTUAL_MAP20;
  936. UDF_SB_PARTFUNC(sb, i) = udf_get_pblock_virt20;
  937. }
  938. } else if (!strncmp(upm2->partIdent.ident, UDF_ID_SPARABLE, strlen(UDF_ID_SPARABLE))) {
  939. uint32_t loc;
  940. uint16_t ident;
  941. struct sparingTable *st;
  942. struct sparablePartitionMap *spm = (struct sparablePartitionMap *)&(lvd->partitionMaps[offset]);
  943. UDF_SB_PARTTYPE(sb, i) = UDF_SPARABLE_MAP15;
  944. UDF_SB_TYPESPAR(sb, i).s_packet_len = le16_to_cpu(spm->packetLength);
  945. for (j = 0; j < spm->numSparingTables; j++) {
  946. loc = le32_to_cpu(spm->locSparingTable[j]);
  947. UDF_SB_TYPESPAR(sb, i).s_spar_map[j] =
  948. udf_read_tagged(sb, loc, loc, &ident);
  949. if (UDF_SB_TYPESPAR(sb, i).s_spar_map[j] != NULL) {
  950. st = (struct sparingTable *)UDF_SB_TYPESPAR(sb, i).s_spar_map[j]->b_data;
  951. if (ident != 0 ||
  952. strncmp(st->sparingIdent.ident, UDF_ID_SPARING, strlen(UDF_ID_SPARING))) {
  953. brelse(UDF_SB_TYPESPAR(sb, i).s_spar_map[j]);
  954. UDF_SB_TYPESPAR(sb, i).s_spar_map[j] = NULL;
  955. }
  956. }
  957. }
  958. UDF_SB_PARTFUNC(sb, i) = udf_get_pblock_spar15;
  959. } else {
  960. udf_debug("Unknown ident: %s\n",
  961. upm2->partIdent.ident);
  962. continue;
  963. }
  964. UDF_SB_PARTVSN(sb, i) = le16_to_cpu(upm2->volSeqNum);
  965. UDF_SB_PARTNUM(sb, i) = le16_to_cpu(upm2->partitionNum);
  966. }
  967. udf_debug("Partition (%d:%d) type %d on volume %d\n",
  968. i, UDF_SB_PARTNUM(sb, i), type,
  969. UDF_SB_PARTVSN(sb, i));
  970. }
  971. if (fileset) {
  972. long_ad *la = (long_ad *)&(lvd->logicalVolContentsUse[0]);
  973. *fileset = lelb_to_cpu(la->extLocation);
  974. udf_debug("FileSet found in LogicalVolDesc at block=%d, "
  975. "partition=%d\n", fileset->logicalBlockNum,
  976. fileset->partitionReferenceNum);
  977. }
  978. if (lvd->integritySeqExt.extLength)
  979. udf_load_logicalvolint(sb, leea_to_cpu(lvd->integritySeqExt));
  980. return 0;
  981. }
  982. /*
  983. * udf_load_logicalvolint
  984. *
  985. */
  986. static void udf_load_logicalvolint(struct super_block *sb, kernel_extent_ad loc)
  987. {
  988. struct buffer_head *bh = NULL;
  989. uint16_t ident;
  990. while (loc.extLength > 0 &&
  991. (bh = udf_read_tagged(sb, loc.extLocation,
  992. loc.extLocation, &ident)) &&
  993. ident == TAG_IDENT_LVID) {
  994. UDF_SB_LVIDBH(sb) = bh;
  995. if (UDF_SB_LVID(sb)->nextIntegrityExt.extLength)
  996. udf_load_logicalvolint(sb,
  997. leea_to_cpu(UDF_SB_LVID(sb)->nextIntegrityExt));
  998. if (UDF_SB_LVIDBH(sb) != bh)
  999. brelse(bh);
  1000. loc.extLength -= sb->s_blocksize;
  1001. loc.extLocation++;
  1002. }
  1003. if (UDF_SB_LVIDBH(sb) != bh)
  1004. brelse(bh);
  1005. }
  1006. /*
  1007. * udf_process_sequence
  1008. *
  1009. * PURPOSE
  1010. * Process a main/reserve volume descriptor sequence.
  1011. *
  1012. * PRE-CONDITIONS
  1013. * sb Pointer to _locked_ superblock.
  1014. * block First block of first extent of the sequence.
  1015. * lastblock Lastblock of first extent of the sequence.
  1016. *
  1017. * HISTORY
  1018. * July 1, 1997 - Andrew E. Mileski
  1019. * Written, tested, and released.
  1020. */
  1021. static int udf_process_sequence(struct super_block *sb, long block,
  1022. long lastblock, kernel_lb_addr *fileset)
  1023. {
  1024. struct buffer_head *bh = NULL;
  1025. struct udf_vds_record vds[VDS_POS_LENGTH];
  1026. struct generic_desc *gd;
  1027. struct volDescPtr *vdp;
  1028. int done = 0;
  1029. int i, j;
  1030. uint32_t vdsn;
  1031. uint16_t ident;
  1032. long next_s = 0, next_e = 0;
  1033. memset(vds, 0, sizeof(struct udf_vds_record) * VDS_POS_LENGTH);
  1034. /* Read the main descriptor sequence */
  1035. for (; (!done && block <= lastblock); block++) {
  1036. bh = udf_read_tagged(sb, block, block, &ident);
  1037. if (!bh)
  1038. break;
  1039. /* Process each descriptor (ISO 13346 3/8.3-8.4) */
  1040. gd = (struct generic_desc *)bh->b_data;
  1041. vdsn = le32_to_cpu(gd->volDescSeqNum);
  1042. switch (ident) {
  1043. case TAG_IDENT_PVD: /* ISO 13346 3/10.1 */
  1044. if (vdsn >= vds[VDS_POS_PRIMARY_VOL_DESC].volDescSeqNum) {
  1045. vds[VDS_POS_PRIMARY_VOL_DESC].volDescSeqNum = vdsn;
  1046. vds[VDS_POS_PRIMARY_VOL_DESC].block = block;
  1047. }
  1048. break;
  1049. case TAG_IDENT_VDP: /* ISO 13346 3/10.3 */
  1050. if (vdsn >= vds[VDS_POS_VOL_DESC_PTR].volDescSeqNum) {
  1051. vds[VDS_POS_VOL_DESC_PTR].volDescSeqNum = vdsn;
  1052. vds[VDS_POS_VOL_DESC_PTR].block = block;
  1053. vdp = (struct volDescPtr *)bh->b_data;
  1054. next_s = le32_to_cpu(vdp->nextVolDescSeqExt.extLocation);
  1055. next_e = le32_to_cpu(vdp->nextVolDescSeqExt.extLength);
  1056. next_e = next_e >> sb->s_blocksize_bits;
  1057. next_e += next_s;
  1058. }
  1059. break;
  1060. case TAG_IDENT_IUVD: /* ISO 13346 3/10.4 */
  1061. if (vdsn >= vds[VDS_POS_IMP_USE_VOL_DESC].volDescSeqNum) {
  1062. vds[VDS_POS_IMP_USE_VOL_DESC].volDescSeqNum = vdsn;
  1063. vds[VDS_POS_IMP_USE_VOL_DESC].block = block;
  1064. }
  1065. break;
  1066. case TAG_IDENT_PD: /* ISO 13346 3/10.5 */
  1067. if (!vds[VDS_POS_PARTITION_DESC].block)
  1068. vds[VDS_POS_PARTITION_DESC].block = block;
  1069. break;
  1070. case TAG_IDENT_LVD: /* ISO 13346 3/10.6 */
  1071. if (vdsn >= vds[VDS_POS_LOGICAL_VOL_DESC].volDescSeqNum) {
  1072. vds[VDS_POS_LOGICAL_VOL_DESC].volDescSeqNum = vdsn;
  1073. vds[VDS_POS_LOGICAL_VOL_DESC].block = block;
  1074. }
  1075. break;
  1076. case TAG_IDENT_USD: /* ISO 13346 3/10.8 */
  1077. if (vdsn >= vds[VDS_POS_UNALLOC_SPACE_DESC].volDescSeqNum) {
  1078. vds[VDS_POS_UNALLOC_SPACE_DESC].volDescSeqNum = vdsn;
  1079. vds[VDS_POS_UNALLOC_SPACE_DESC].block = block;
  1080. }
  1081. break;
  1082. case TAG_IDENT_TD: /* ISO 13346 3/10.9 */
  1083. vds[VDS_POS_TERMINATING_DESC].block = block;
  1084. if (next_e) {
  1085. block = next_s;
  1086. lastblock = next_e;
  1087. next_s = next_e = 0;
  1088. } else {
  1089. done = 1;
  1090. }
  1091. break;
  1092. }
  1093. brelse(bh);
  1094. }
  1095. for (i = 0; i < VDS_POS_LENGTH; i++) {
  1096. if (vds[i].block) {
  1097. bh = udf_read_tagged(sb, vds[i].block, vds[i].block,
  1098. &ident);
  1099. if (i == VDS_POS_PRIMARY_VOL_DESC) {
  1100. udf_load_pvoldesc(sb, bh);
  1101. } else if (i == VDS_POS_LOGICAL_VOL_DESC) {
  1102. udf_load_logicalvol(sb, bh, fileset);
  1103. } else if (i == VDS_POS_PARTITION_DESC) {
  1104. struct buffer_head *bh2 = NULL;
  1105. if (udf_load_partdesc(sb, bh)) {
  1106. brelse(bh);
  1107. return 1;
  1108. }
  1109. for (j = vds[i].block + 1;
  1110. j < vds[VDS_POS_TERMINATING_DESC].block;
  1111. j++) {
  1112. bh2 = udf_read_tagged(sb, j, j, &ident);
  1113. gd = (struct generic_desc *)bh2->b_data;
  1114. if (ident == TAG_IDENT_PD)
  1115. if (udf_load_partdesc(sb,
  1116. bh2)) {
  1117. brelse(bh);
  1118. brelse(bh2);
  1119. return 1;
  1120. }
  1121. brelse(bh2);
  1122. }
  1123. }
  1124. brelse(bh);
  1125. }
  1126. }
  1127. return 0;
  1128. }
  1129. /*
  1130. * udf_check_valid()
  1131. */
  1132. static int udf_check_valid(struct super_block *sb, int novrs, int silent)
  1133. {
  1134. long block;
  1135. if (novrs) {
  1136. udf_debug("Validity check skipped because of novrs option\n");
  1137. return 0;
  1138. }
  1139. /* Check that it is NSR02 compliant */
  1140. /* Process any "CD-ROM Volume Descriptor Set" (ECMA 167 2/8.3.1) */
  1141. else {
  1142. block = udf_vrs(sb, silent);
  1143. if (block == -1) {
  1144. udf_debug("Failed to read byte 32768. Assuming open "
  1145. "disc. Skipping validity check\n");
  1146. if (!UDF_SB_LASTBLOCK(sb))
  1147. UDF_SB_LASTBLOCK(sb) = udf_get_last_block(sb);
  1148. return 0;
  1149. } else
  1150. return !block;
  1151. }
  1152. }
  1153. static int udf_load_partition(struct super_block *sb, kernel_lb_addr *fileset)
  1154. {
  1155. struct anchorVolDescPtr *anchor;
  1156. uint16_t ident;
  1157. struct buffer_head *bh;
  1158. long main_s, main_e, reserve_s, reserve_e;
  1159. int i, j;
  1160. if (!sb)
  1161. return 1;
  1162. for (i = 0; i < ARRAY_SIZE(UDF_SB_ANCHOR(sb)); i++) {
  1163. if (UDF_SB_ANCHOR(sb)[i] &&
  1164. (bh = udf_read_tagged(sb, UDF_SB_ANCHOR(sb)[i],
  1165. UDF_SB_ANCHOR(sb)[i], &ident))) {
  1166. anchor = (struct anchorVolDescPtr *)bh->b_data;
  1167. /* Locate the main sequence */
  1168. main_s = le32_to_cpu(anchor->mainVolDescSeqExt.extLocation);
  1169. main_e = le32_to_cpu(anchor->mainVolDescSeqExt.extLength);
  1170. main_e = main_e >> sb->s_blocksize_bits;
  1171. main_e += main_s;
  1172. /* Locate the reserve sequence */
  1173. reserve_s = le32_to_cpu(anchor->reserveVolDescSeqExt.extLocation);
  1174. reserve_e = le32_to_cpu(anchor->reserveVolDescSeqExt.extLength);
  1175. reserve_e = reserve_e >> sb->s_blocksize_bits;
  1176. reserve_e += reserve_s;
  1177. brelse(bh);
  1178. /* Process the main & reserve sequences */
  1179. /* responsible for finding the PartitionDesc(s) */
  1180. if (!(udf_process_sequence(sb, main_s, main_e, fileset) &&
  1181. udf_process_sequence(sb, reserve_s, reserve_e, fileset)))
  1182. break;
  1183. }
  1184. }
  1185. if (i == ARRAY_SIZE(UDF_SB_ANCHOR(sb))) {
  1186. udf_debug("No Anchor block found\n");
  1187. return 1;
  1188. } else
  1189. udf_debug("Using anchor in block %d\n", UDF_SB_ANCHOR(sb)[i]);
  1190. for (i = 0; i < UDF_SB_NUMPARTS(sb); i++) {
  1191. kernel_lb_addr uninitialized_var(ino);
  1192. switch (UDF_SB_PARTTYPE(sb, i)) {
  1193. case UDF_VIRTUAL_MAP15:
  1194. case UDF_VIRTUAL_MAP20:
  1195. if (!UDF_SB_LASTBLOCK(sb)) {
  1196. UDF_SB_LASTBLOCK(sb) = udf_get_last_block(sb);
  1197. udf_find_anchor(sb);
  1198. }
  1199. if (!UDF_SB_LASTBLOCK(sb)) {
  1200. udf_debug("Unable to determine Lastblock (For "
  1201. "Virtual Partition)\n");
  1202. return 1;
  1203. }
  1204. for (j = 0; j < UDF_SB_NUMPARTS(sb); j++) {
  1205. if (j != i &&
  1206. UDF_SB_PARTVSN(sb, i) == UDF_SB_PARTVSN(sb, j) &&
  1207. UDF_SB_PARTNUM(sb, i) == UDF_SB_PARTNUM(sb, j)) {
  1208. ino.partitionReferenceNum = j;
  1209. ino.logicalBlockNum = UDF_SB_LASTBLOCK(sb) - UDF_SB_PARTROOT(sb, j);
  1210. break;
  1211. }
  1212. }
  1213. if (j == UDF_SB_NUMPARTS(sb))
  1214. return 1;
  1215. UDF_SB_VAT(sb) = udf_iget(sb, ino);
  1216. if (!UDF_SB_VAT(sb))
  1217. return 1;
  1218. if (UDF_SB_PARTTYPE(sb, i) == UDF_VIRTUAL_MAP15) {
  1219. UDF_SB_TYPEVIRT(sb, i).s_start_offset =
  1220. udf_ext0_offset(UDF_SB_VAT(sb));
  1221. UDF_SB_TYPEVIRT(sb, i).s_num_entries =
  1222. (UDF_SB_VAT(sb)->i_size - 36) >> 2;
  1223. } else if (UDF_SB_PARTTYPE(sb, i) == UDF_VIRTUAL_MAP20) {
  1224. struct buffer_head *bh = NULL;
  1225. uint32_t pos;
  1226. pos = udf_block_map(UDF_SB_VAT(sb), 0);
  1227. bh = sb_bread(sb, pos);
  1228. if (!bh)
  1229. return 1;
  1230. UDF_SB_TYPEVIRT(sb, i).s_start_offset =
  1231. le16_to_cpu(((struct virtualAllocationTable20 *)bh->b_data +
  1232. udf_ext0_offset(UDF_SB_VAT(sb)))->lengthHeader) +
  1233. udf_ext0_offset(UDF_SB_VAT(sb));
  1234. UDF_SB_TYPEVIRT(sb, i).s_num_entries = (UDF_SB_VAT(sb)->i_size -
  1235. UDF_SB_TYPEVIRT(sb, i).s_start_offset) >> 2;
  1236. brelse(bh);
  1237. }
  1238. UDF_SB_PARTROOT(sb, i) = udf_get_pblock(sb, 0, i, 0);
  1239. UDF_SB_PARTLEN(sb, i) = UDF_SB_PARTLEN(sb, ino.partitionReferenceNum);
  1240. }
  1241. }
  1242. return 0;
  1243. }
  1244. static void udf_open_lvid(struct super_block *sb)
  1245. {
  1246. if (UDF_SB_LVIDBH(sb)) {
  1247. int i;
  1248. kernel_timestamp cpu_time;
  1249. UDF_SB_LVIDIU(sb)->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX;
  1250. UDF_SB_LVIDIU(sb)->impIdent.identSuffix[1] = UDF_OS_ID_LINUX;
  1251. if (udf_time_to_stamp(&cpu_time, CURRENT_TIME))
  1252. UDF_SB_LVID(sb)->recordingDateAndTime = cpu_to_lets(cpu_time);
  1253. UDF_SB_LVID(sb)->integrityType = LVID_INTEGRITY_TYPE_OPEN;
  1254. UDF_SB_LVID(sb)->descTag.descCRC = cpu_to_le16(udf_crc((char *)UDF_SB_LVID(sb) + sizeof(tag),
  1255. le16_to_cpu(UDF_SB_LVID(sb)->descTag.descCRCLength), 0));
  1256. UDF_SB_LVID(sb)->descTag.tagChecksum = 0;
  1257. for (i = 0; i < 16; i++)
  1258. if (i != 4)
  1259. UDF_SB_LVID(sb)->descTag.tagChecksum +=
  1260. ((uint8_t *) &(UDF_SB_LVID(sb)->descTag))[i];
  1261. mark_buffer_dirty(UDF_SB_LVIDBH(sb));
  1262. }
  1263. }
  1264. static void udf_close_lvid(struct super_block *sb)
  1265. {
  1266. kernel_timestamp cpu_time;
  1267. int i;
  1268. if (UDF_SB_LVIDBH(sb) &&
  1269. UDF_SB_LVID(sb)->integrityType == LVID_INTEGRITY_TYPE_OPEN) {
  1270. UDF_SB_LVIDIU(sb)->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX;
  1271. UDF_SB_LVIDIU(sb)->impIdent.identSuffix[1] = UDF_OS_ID_LINUX;
  1272. if (udf_time_to_stamp(&cpu_time, CURRENT_TIME))
  1273. UDF_SB_LVID(sb)->recordingDateAndTime = cpu_to_lets(cpu_time);
  1274. if (UDF_MAX_WRITE_VERSION > le16_to_cpu(UDF_SB_LVIDIU(sb)->maxUDFWriteRev))
  1275. UDF_SB_LVIDIU(sb)->maxUDFWriteRev = cpu_to_le16(UDF_MAX_WRITE_VERSION);
  1276. if (UDF_SB_UDFREV(sb) > le16_to_cpu(UDF_SB_LVIDIU(sb)->minUDFReadRev))
  1277. UDF_SB_LVIDIU(sb)->minUDFReadRev = cpu_to_le16(UDF_SB_UDFREV(sb));
  1278. if (UDF_SB_UDFREV(sb) > le16_to_cpu(UDF_SB_LVIDIU(sb)->minUDFWriteRev))
  1279. UDF_SB_LVIDIU(sb)->minUDFWriteRev = cpu_to_le16(UDF_SB_UDFREV(sb));
  1280. UDF_SB_LVID(sb)->integrityType = cpu_to_le32(LVID_INTEGRITY_TYPE_CLOSE);
  1281. UDF_SB_LVID(sb)->descTag.descCRC =
  1282. cpu_to_le16(udf_crc((char *)UDF_SB_LVID(sb) + sizeof(tag),
  1283. le16_to_cpu(UDF_SB_LVID(sb)->descTag.descCRCLength), 0));
  1284. UDF_SB_LVID(sb)->descTag.tagChecksum = 0;
  1285. for (i = 0; i < 16; i++)
  1286. if (i != 4)
  1287. UDF_SB_LVID(sb)->descTag.tagChecksum +=
  1288. ((uint8_t *)&(UDF_SB_LVID(sb)->descTag))[i];
  1289. mark_buffer_dirty(UDF_SB_LVIDBH(sb));
  1290. }
  1291. }
  1292. /*
  1293. * udf_read_super
  1294. *
  1295. * PURPOSE
  1296. * Complete the specified super block.
  1297. *
  1298. * PRE-CONDITIONS
  1299. * sb Pointer to superblock to complete - never NULL.
  1300. * sb->s_dev Device to read suberblock from.
  1301. * options Pointer to mount options.
  1302. * silent Silent flag.
  1303. *
  1304. * HISTORY
  1305. * July 1, 1997 - Andrew E. Mileski
  1306. * Written, tested, and released.
  1307. */
  1308. static int udf_fill_super(struct super_block *sb, void *options, int silent)
  1309. {
  1310. int i;
  1311. struct inode *inode = NULL;
  1312. struct udf_options uopt;
  1313. kernel_lb_addr rootdir, fileset;
  1314. struct udf_sb_info *sbi;
  1315. uopt.flags = (1 << UDF_FLAG_USE_AD_IN_ICB) | (1 << UDF_FLAG_STRICT);
  1316. uopt.uid = -1;
  1317. uopt.gid = -1;
  1318. uopt.umask = 0;
  1319. sbi = kmalloc(sizeof(struct udf_sb_info), GFP_KERNEL);
  1320. if (!sbi)
  1321. return -ENOMEM;
  1322. sb->s_fs_info = sbi;
  1323. memset(UDF_SB(sb), 0x00, sizeof(struct udf_sb_info));
  1324. mutex_init(&sbi->s_alloc_mutex);
  1325. if (!udf_parse_options((char *)options, &uopt))
  1326. goto error_out;
  1327. if (uopt.flags & (1 << UDF_FLAG_UTF8) &&
  1328. uopt.flags & (1 << UDF_FLAG_NLS_MAP)) {
  1329. udf_error(sb, "udf_read_super",
  1330. "utf8 cannot be combined with iocharset\n");
  1331. goto error_out;
  1332. }
  1333. #ifdef CONFIG_UDF_NLS
  1334. if ((uopt.flags & (1 << UDF_FLAG_NLS_MAP)) && !uopt.nls_map) {
  1335. uopt.nls_map = load_nls_default();
  1336. if (!uopt.nls_map)
  1337. uopt.flags &= ~(1 << UDF_FLAG_NLS_MAP);
  1338. else
  1339. udf_debug("Using default NLS map\n");
  1340. }
  1341. #endif
  1342. if (!(uopt.flags & (1 << UDF_FLAG_NLS_MAP)))
  1343. uopt.flags |= (1 << UDF_FLAG_UTF8);
  1344. fileset.logicalBlockNum = 0xFFFFFFFF;
  1345. fileset.partitionReferenceNum = 0xFFFF;
  1346. UDF_SB(sb)->s_flags = uopt.flags;
  1347. UDF_SB(sb)->s_uid = uopt.uid;
  1348. UDF_SB(sb)->s_gid = uopt.gid;
  1349. UDF_SB(sb)->s_umask = uopt.umask;
  1350. UDF_SB(sb)->s_nls_map = uopt.nls_map;
  1351. /* Set the block size for all transfers */
  1352. if (!udf_set_blocksize(sb, uopt.blocksize))
  1353. goto error_out;
  1354. if (uopt.session == 0xFFFFFFFF)
  1355. UDF_SB_SESSION(sb) = udf_get_last_session(sb);
  1356. else
  1357. UDF_SB_SESSION(sb) = uopt.session;
  1358. udf_debug("Multi-session=%d\n", UDF_SB_SESSION(sb));
  1359. UDF_SB_LASTBLOCK(sb) = uopt.lastblock;
  1360. UDF_SB_ANCHOR(sb)[0] = UDF_SB_ANCHOR(sb)[1] = 0;
  1361. UDF_SB_ANCHOR(sb)[2] = uopt.anchor;
  1362. UDF_SB_ANCHOR(sb)[3] = 256;
  1363. if (udf_check_valid(sb, uopt.novrs, silent)) {
  1364. /* read volume recognition sequences */
  1365. printk(KERN_WARNING "UDF-fs: No VRS found\n");
  1366. goto error_out;
  1367. }
  1368. udf_find_anchor(sb);
  1369. /* Fill in the rest of the superblock */
  1370. sb->s_op = &udf_sb_ops;
  1371. sb->dq_op = NULL;
  1372. sb->s_dirt = 0;
  1373. sb->s_magic = UDF_SUPER_MAGIC;
  1374. sb->s_time_gran = 1000;
  1375. if (udf_load_partition(sb, &fileset)) {
  1376. printk(KERN_WARNING "UDF-fs: No partition found (1)\n");
  1377. goto error_out;
  1378. }
  1379. udf_debug("Lastblock=%d\n", UDF_SB_LASTBLOCK(sb));
  1380. if (UDF_SB_LVIDBH(sb)) {
  1381. uint16_t minUDFReadRev = le16_to_cpu(UDF_SB_LVIDIU(sb)->minUDFReadRev);
  1382. uint16_t minUDFWriteRev = le16_to_cpu(UDF_SB_LVIDIU(sb)->minUDFWriteRev);
  1383. /* uint16_t maxUDFWriteRev = le16_to_cpu(UDF_SB_LVIDIU(sb)->maxUDFWriteRev); */
  1384. if (minUDFReadRev > UDF_MAX_READ_VERSION) {
  1385. printk(KERN_ERR "UDF-fs: minUDFReadRev=%x (max is %x)\n",
  1386. le16_to_cpu(UDF_SB_LVIDIU(sb)->minUDFReadRev),
  1387. UDF_MAX_READ_VERSION);
  1388. goto error_out;
  1389. } else if (minUDFWriteRev > UDF_MAX_WRITE_VERSION) {
  1390. sb->s_flags |= MS_RDONLY;
  1391. }
  1392. UDF_SB_UDFREV(sb) = minUDFWriteRev;
  1393. if (minUDFReadRev >= UDF_VERS_USE_EXTENDED_FE)
  1394. UDF_SET_FLAG(sb, UDF_FLAG_USE_EXTENDED_FE);
  1395. if (minUDFReadRev >= UDF_VERS_USE_STREAMS)
  1396. UDF_SET_FLAG(sb, UDF_FLAG_USE_STREAMS);
  1397. }
  1398. if (!UDF_SB_NUMPARTS(sb)) {
  1399. printk(KERN_WARNING "UDF-fs: No partition found (2)\n");
  1400. goto error_out;
  1401. }
  1402. if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_READ_ONLY) {
  1403. printk(KERN_NOTICE "UDF-fs: Partition marked readonly; forcing readonly mount\n");
  1404. sb->s_flags |= MS_RDONLY;
  1405. }
  1406. if (udf_find_fileset(sb, &fileset, &rootdir)) {
  1407. printk(KERN_WARNING "UDF-fs: No fileset found\n");
  1408. goto error_out;
  1409. }
  1410. if (!silent) {
  1411. kernel_timestamp ts;
  1412. udf_time_to_stamp(&ts, UDF_SB_RECORDTIME(sb));
  1413. udf_info("UDF %s (%s) Mounting volume '%s', "
  1414. "timestamp %04u/%02u/%02u %02u:%02u (%x)\n",
  1415. UDFFS_VERSION, UDFFS_DATE,
  1416. UDF_SB_VOLIDENT(sb), ts.year, ts.month, ts.day, ts.hour, ts.minute,
  1417. ts.typeAndTimezone);
  1418. }
  1419. if (!(sb->s_flags & MS_RDONLY))
  1420. udf_open_lvid(sb);
  1421. /* Assign the root inode */
  1422. /* assign inodes by physical block number */
  1423. /* perhaps it's not extensible enough, but for now ... */
  1424. inode = udf_iget(sb, rootdir);
  1425. if (!inode) {
  1426. printk(KERN_ERR "UDF-fs: Error in udf_iget, block=%d, partition=%d\n",
  1427. rootdir.logicalBlockNum, rootdir.partitionReferenceNum);
  1428. goto error_out;
  1429. }
  1430. /* Allocate a dentry for the root inode */
  1431. sb->s_root = d_alloc_root(inode);
  1432. if (!sb->s_root) {
  1433. printk(KERN_ERR "UDF-fs: Couldn't allocate root dentry\n");
  1434. iput(inode);
  1435. goto error_out;
  1436. }
  1437. sb->s_maxbytes = MAX_LFS_FILESIZE;
  1438. return 0;
  1439. error_out:
  1440. if (UDF_SB_VAT(sb))
  1441. iput(UDF_SB_VAT(sb));
  1442. if (UDF_SB_NUMPARTS(sb)) {
  1443. if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_UNALLOC_TABLE)
  1444. iput(UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_uspace.s_table);
  1445. if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_FREED_TABLE)
  1446. iput(UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_fspace.s_table);
  1447. if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_UNALLOC_BITMAP)
  1448. UDF_SB_FREE_BITMAP(sb, UDF_SB_PARTITION(sb), s_uspace);
  1449. if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_FREED_BITMAP)
  1450. UDF_SB_FREE_BITMAP(sb, UDF_SB_PARTITION(sb), s_fspace);
  1451. if (UDF_SB_PARTTYPE(sb, UDF_SB_PARTITION(sb)) == UDF_SPARABLE_MAP15) {
  1452. for (i = 0; i < 4; i++)
  1453. brelse(UDF_SB_TYPESPAR(sb, UDF_SB_PARTITION(sb)).s_spar_map[i]);
  1454. }
  1455. }
  1456. #ifdef CONFIG_UDF_NLS
  1457. if (UDF_QUERY_FLAG(sb, UDF_FLAG_NLS_MAP))
  1458. unload_nls(UDF_SB(sb)->s_nls_map);
  1459. #endif
  1460. if (!(sb->s_flags & MS_RDONLY))
  1461. udf_close_lvid(sb);
  1462. brelse(UDF_SB_LVIDBH(sb));
  1463. UDF_SB_FREE(sb);
  1464. kfree(sbi);
  1465. sb->s_fs_info = NULL;
  1466. return -EINVAL;
  1467. }
  1468. void udf_error(struct super_block *sb, const char *function,
  1469. const char *fmt, ...)
  1470. {
  1471. va_list args;
  1472. if (!(sb->s_flags & MS_RDONLY)) {
  1473. /* mark sb error */
  1474. sb->s_dirt = 1;
  1475. }
  1476. va_start(args, fmt);
  1477. vsnprintf(error_buf, sizeof(error_buf), fmt, args);
  1478. va_end(args);
  1479. printk(KERN_CRIT "UDF-fs error (device %s): %s: %s\n",
  1480. sb->s_id, function, error_buf);
  1481. }
  1482. void udf_warning(struct super_block *sb, const char *function,
  1483. const char *fmt, ...)
  1484. {
  1485. va_list args;
  1486. va_start(args, fmt);
  1487. vsnprintf(error_buf, sizeof(error_buf), fmt, args);
  1488. va_end(args);
  1489. printk(KERN_WARNING "UDF-fs warning (device %s): %s: %s\n",
  1490. sb->s_id, function, error_buf);
  1491. }
  1492. /*
  1493. * udf_put_super
  1494. *
  1495. * PURPOSE
  1496. * Prepare for destruction of the superblock.
  1497. *
  1498. * DESCRIPTION
  1499. * Called before the filesystem is unmounted.
  1500. *
  1501. * HISTORY
  1502. * July 1, 1997 - Andrew E. Mileski
  1503. * Written, tested, and released.
  1504. */
  1505. static void udf_put_super(struct super_block *sb)
  1506. {
  1507. int i;
  1508. if (UDF_SB_VAT(sb))
  1509. iput(UDF_SB_VAT(sb));
  1510. if (UDF_SB_NUMPARTS(sb)) {
  1511. if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_UNALLOC_TABLE)
  1512. iput(UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_uspace.s_table);
  1513. if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_FREED_TABLE)
  1514. iput(UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_fspace.s_table);
  1515. if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_UNALLOC_BITMAP)
  1516. UDF_SB_FREE_BITMAP(sb, UDF_SB_PARTITION(sb), s_uspace);
  1517. if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_FREED_BITMAP)
  1518. UDF_SB_FREE_BITMAP(sb, UDF_SB_PARTITION(sb), s_fspace);
  1519. if (UDF_SB_PARTTYPE(sb, UDF_SB_PARTITION(sb)) == UDF_SPARABLE_MAP15) {
  1520. for (i = 0; i < 4; i++)
  1521. brelse(UDF_SB_TYPESPAR(sb, UDF_SB_PARTITION(sb)).s_spar_map[i]);
  1522. }
  1523. }
  1524. #ifdef CONFIG_UDF_NLS
  1525. if (UDF_QUERY_FLAG(sb, UDF_FLAG_NLS_MAP))
  1526. unload_nls(UDF_SB(sb)->s_nls_map);
  1527. #endif
  1528. if (!(sb->s_flags & MS_RDONLY))
  1529. udf_close_lvid(sb);
  1530. brelse(UDF_SB_LVIDBH(sb));
  1531. UDF_SB_FREE(sb);
  1532. kfree(sb->s_fs_info);
  1533. sb->s_fs_info = NULL;
  1534. }
  1535. /*
  1536. * udf_stat_fs
  1537. *
  1538. * PURPOSE
  1539. * Return info about the filesystem.
  1540. *
  1541. * DESCRIPTION
  1542. * Called by sys_statfs()
  1543. *
  1544. * HISTORY
  1545. * July 1, 1997 - Andrew E. Mileski
  1546. * Written, tested, and released.
  1547. */
  1548. static int udf_statfs(struct dentry *dentry, struct kstatfs *buf)
  1549. {
  1550. struct super_block *sb = dentry->d_sb;
  1551. buf->f_type = UDF_SUPER_MAGIC;
  1552. buf->f_bsize = sb->s_blocksize;
  1553. buf->f_blocks = UDF_SB_PARTLEN(sb, UDF_SB_PARTITION(sb));
  1554. buf->f_bfree = udf_count_free(sb);
  1555. buf->f_bavail = buf->f_bfree;
  1556. buf->f_files = (UDF_SB_LVIDBH(sb) ?
  1557. (le32_to_cpu(UDF_SB_LVIDIU(sb)->numFiles) +
  1558. le32_to_cpu(UDF_SB_LVIDIU(sb)->numDirs)) : 0) + buf->f_bfree;
  1559. buf->f_ffree = buf->f_bfree;
  1560. /* __kernel_fsid_t f_fsid */
  1561. buf->f_namelen = UDF_NAME_LEN - 2;
  1562. return 0;
  1563. }
  1564. static unsigned char udf_bitmap_lookup[16] = {
  1565. 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4
  1566. };
  1567. static unsigned int udf_count_free_bitmap(struct super_block *sb, struct udf_bitmap *bitmap)
  1568. {
  1569. struct buffer_head *bh = NULL;
  1570. unsigned int accum = 0;
  1571. int index;
  1572. int block = 0, newblock;
  1573. kernel_lb_addr loc;
  1574. uint32_t bytes;
  1575. uint8_t value;
  1576. uint8_t *ptr;
  1577. uint16_t ident;
  1578. struct spaceBitmapDesc *bm;
  1579. lock_kernel();
  1580. loc.logicalBlockNum = bitmap->s_extPosition;
  1581. loc.partitionReferenceNum = UDF_SB_PARTITION(sb);
  1582. bh = udf_read_ptagged(sb, loc, 0, &ident);
  1583. if (!bh) {
  1584. printk(KERN_ERR "udf: udf_count_free failed\n");
  1585. goto out;
  1586. } else if (ident != TAG_IDENT_SBD) {
  1587. brelse(bh);
  1588. printk(KERN_ERR "udf: udf_count_free failed\n");
  1589. goto out;
  1590. }
  1591. bm = (struct spaceBitmapDesc *)bh->b_data;
  1592. bytes = le32_to_cpu(bm->numOfBytes);
  1593. index = sizeof(struct spaceBitmapDesc); /* offset in first block only */
  1594. ptr = (uint8_t *)bh->b_data;
  1595. while (bytes > 0) {
  1596. while ((bytes > 0) && (index < sb->s_blocksize)) {
  1597. value = ptr[index];
  1598. accum += udf_bitmap_lookup[value & 0x0f];
  1599. accum += udf_bitmap_lookup[value >> 4];
  1600. index++;
  1601. bytes--;
  1602. }
  1603. if (bytes) {
  1604. brelse(bh);
  1605. newblock = udf_get_lb_pblock(sb, loc, ++block);
  1606. bh = udf_tread(sb, newblock);
  1607. if (!bh) {
  1608. udf_debug("read failed\n");
  1609. goto out;
  1610. }
  1611. index = 0;
  1612. ptr = (uint8_t *)bh->b_data;
  1613. }
  1614. }
  1615. brelse(bh);
  1616. out:
  1617. unlock_kernel();
  1618. return accum;
  1619. }
  1620. static unsigned int udf_count_free_table(struct super_block *sb, struct inode *table)
  1621. {
  1622. unsigned int accum = 0;
  1623. uint32_t elen;
  1624. kernel_lb_addr eloc;
  1625. int8_t etype;
  1626. struct extent_position epos;
  1627. lock_kernel();
  1628. epos.block = UDF_I_LOCATION(table);
  1629. epos.offset = sizeof(struct unallocSpaceEntry);
  1630. epos.bh = NULL;
  1631. while ((etype = udf_next_aext(table, &epos, &eloc, &elen, 1)) != -1)
  1632. accum += (elen >> table->i_sb->s_blocksize_bits);
  1633. brelse(epos.bh);
  1634. unlock_kernel();
  1635. return accum;
  1636. }
  1637. static unsigned int udf_count_free(struct super_block *sb)
  1638. {
  1639. unsigned int accum = 0;
  1640. if (UDF_SB_LVIDBH(sb)) {
  1641. if (le32_to_cpu(UDF_SB_LVID(sb)->numOfPartitions) > UDF_SB_PARTITION(sb)) {
  1642. accum = le32_to_cpu(UDF_SB_LVID(sb)->freeSpaceTable[UDF_SB_PARTITION(sb)]);
  1643. if (accum == 0xFFFFFFFF)
  1644. accum = 0;
  1645. }
  1646. }
  1647. if (accum)
  1648. return accum;
  1649. if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_UNALLOC_BITMAP) {
  1650. accum += udf_count_free_bitmap(sb,
  1651. UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_uspace.s_bitmap);
  1652. }
  1653. if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_FREED_BITMAP) {
  1654. accum += udf_count_free_bitmap(sb,
  1655. UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_fspace.s_bitmap);
  1656. }
  1657. if (accum)
  1658. return accum;
  1659. if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_UNALLOC_TABLE) {
  1660. accum += udf_count_free_table(sb,
  1661. UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_uspace.s_table);
  1662. }
  1663. if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_FREED_TABLE) {
  1664. accum += udf_count_free_table(sb,
  1665. UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_fspace.s_table);
  1666. }
  1667. return accum;
  1668. }