blob: f4cdd530c65ff9a48637138828a8009b07c356ce [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070017 * 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
Marcin Slusarz3a71fc52008-02-08 04:20:28 -080036 * 12/06/98 blf really hosed things royally. vat/sparing support. sequenced
37 * vol descs. rewrote option handling based on isofs
Linus Torvalds1da177e2005-04-16 15:20:36 -070038 * 12/20/98 find the free space bitmap (if it exists)
39 */
40
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -070041#include "udfdecl.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070042
Linus Torvalds1da177e2005-04-16 15:20:36 -070043#include <linux/blkdev.h>
44#include <linux/slab.h>
45#include <linux/kernel.h>
46#include <linux/module.h>
47#include <linux/parser.h>
48#include <linux/stat.h>
49#include <linux/cdrom.h>
50#include <linux/nls.h>
51#include <linux/smp_lock.h>
52#include <linux/buffer_head.h>
53#include <linux/vfs.h>
54#include <linux/vmalloc.h>
Marcin Slusarzdc5d39b2008-02-08 04:20:32 -080055#include <linux/errno.h>
Miklos Szeredi6da80892008-02-08 04:21:50 -080056#include <linux/mount.h>
57#include <linux/seq_file.h>
Marcin Slusarz01b954a2008-02-02 22:37:07 +010058#include <linux/bitmap.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070059#include <asm/byteorder.h>
60
Linus Torvalds1da177e2005-04-16 15:20:36 -070061#include "udf_sb.h"
62#include "udf_i.h"
63
64#include <linux/init.h>
65#include <asm/uaccess.h>
66
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
75
Miklos Szeredi6da80892008-02-08 04:21:50 -080076#define UDF_DEFAULT_BLOCKSIZE 2048
77
Linus Torvalds1da177e2005-04-16 15:20:36 -070078static char error_buf[1024];
79
80/* These are the "meat" - everything else is stuffing */
81static int udf_fill_super(struct super_block *, void *, int);
82static void udf_put_super(struct super_block *);
83static void udf_write_super(struct super_block *);
84static int udf_remount_fs(struct super_block *, int *, char *);
85static int udf_check_valid(struct super_block *, int, int);
86static int udf_vrs(struct super_block *sb, int silent);
87static int udf_load_partition(struct super_block *, kernel_lb_addr *);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -070088static int udf_load_logicalvol(struct super_block *, struct buffer_head *,
89 kernel_lb_addr *);
Linus Torvalds1da177e2005-04-16 15:20:36 -070090static void udf_load_logicalvolint(struct super_block *, kernel_extent_ad);
91static void udf_find_anchor(struct super_block *);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -070092static int udf_find_fileset(struct super_block *, kernel_lb_addr *,
93 kernel_lb_addr *);
Linus Torvalds1da177e2005-04-16 15:20:36 -070094static void udf_load_pvoldesc(struct super_block *, struct buffer_head *);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -070095static void udf_load_fileset(struct super_block *, struct buffer_head *,
96 kernel_lb_addr *);
Jan Karabcec4472007-08-30 23:56:22 -070097static int udf_load_partdesc(struct super_block *, struct buffer_head *);
Linus Torvalds1da177e2005-04-16 15:20:36 -070098static void udf_open_lvid(struct super_block *);
99static void udf_close_lvid(struct super_block *);
100static unsigned int udf_count_free(struct super_block *);
David Howells726c3342006-06-23 02:02:58 -0700101static int udf_statfs(struct dentry *, struct kstatfs *);
Miklos Szeredi6da80892008-02-08 04:21:50 -0800102static int udf_show_options(struct seq_file *, struct vfsmount *);
Adrian Bunkb8145a72008-02-17 10:19:55 +0200103static void udf_error(struct super_block *sb, const char *function,
104 const char *fmt, ...);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105
Marcin Slusarz6c79e982008-02-08 04:20:30 -0800106struct logicalVolIntegrityDescImpUse *udf_sb_lvidiu(struct udf_sb_info *sbi)
107{
Marcin Slusarz4b111112008-02-08 04:20:36 -0800108 struct logicalVolIntegrityDesc *lvid =
109 (struct logicalVolIntegrityDesc *)sbi->s_lvid_bh->b_data;
Marcin Slusarz6c79e982008-02-08 04:20:30 -0800110 __u32 number_of_partitions = le32_to_cpu(lvid->numOfPartitions);
Marcin Slusarz4b111112008-02-08 04:20:36 -0800111 __u32 offset = number_of_partitions * 2 *
112 sizeof(uint32_t)/sizeof(uint8_t);
Marcin Slusarz6c79e982008-02-08 04:20:30 -0800113 return (struct logicalVolIntegrityDescImpUse *)&(lvid->impUse[offset]);
114}
115
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116/* UDF filesystem type */
David Howells454e2392006-06-23 02:02:57 -0700117static int udf_get_sb(struct file_system_type *fs_type,
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700118 int flags, const char *dev_name, void *data,
119 struct vfsmount *mnt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120{
David Howells454e2392006-06-23 02:02:57 -0700121 return get_sb_bdev(fs_type, flags, dev_name, data, udf_fill_super, mnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122}
123
124static struct file_system_type udf_fstype = {
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700125 .owner = THIS_MODULE,
126 .name = "udf",
127 .get_sb = udf_get_sb,
128 .kill_sb = kill_block_super,
129 .fs_flags = FS_REQUIRES_DEV,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130};
131
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700132static struct kmem_cache *udf_inode_cachep;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133
134static struct inode *udf_alloc_inode(struct super_block *sb)
135{
136 struct udf_inode_info *ei;
Marcin Slusarz3a71fc52008-02-08 04:20:28 -0800137 ei = kmem_cache_alloc(udf_inode_cachep, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138 if (!ei)
139 return NULL;
Dan Bastone95f87972006-08-13 23:24:18 -0700140
141 ei->i_unique = 0;
142 ei->i_lenExtents = 0;
143 ei->i_next_alloc_block = 0;
144 ei->i_next_alloc_goal = 0;
145 ei->i_strat4096 = 0;
146
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147 return &ei->vfs_inode;
148}
149
150static void udf_destroy_inode(struct inode *inode)
151{
152 kmem_cache_free(udf_inode_cachep, UDF_I(inode));
153}
154
Christoph Lameter4ba9b9d2007-10-16 23:25:51 -0700155static void init_once(struct kmem_cache *cachep, void *foo)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156{
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700157 struct udf_inode_info *ei = (struct udf_inode_info *)foo;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158
Christoph Lametera35afb82007-05-16 22:10:57 -0700159 ei->i_ext.i_data = NULL;
160 inode_init_once(&ei->vfs_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161}
162
163static int init_inodecache(void)
164{
165 udf_inode_cachep = kmem_cache_create("udf_inode_cache",
166 sizeof(struct udf_inode_info),
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700167 0, (SLAB_RECLAIM_ACCOUNT |
168 SLAB_MEM_SPREAD),
Paul Mundt20c2df82007-07-20 10:11:58 +0900169 init_once);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700170 if (!udf_inode_cachep)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171 return -ENOMEM;
172 return 0;
173}
174
175static void destroy_inodecache(void)
176{
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -0700177 kmem_cache_destroy(udf_inode_cachep);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178}
179
180/* Superblock operations */
Josef 'Jeff' Sipekee9b6d62007-02-12 00:55:41 -0800181static const struct super_operations udf_sb_ops = {
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700182 .alloc_inode = udf_alloc_inode,
183 .destroy_inode = udf_destroy_inode,
184 .write_inode = udf_write_inode,
185 .delete_inode = udf_delete_inode,
186 .clear_inode = udf_clear_inode,
187 .put_super = udf_put_super,
188 .write_super = udf_write_super,
189 .statfs = udf_statfs,
190 .remount_fs = udf_remount_fs,
Miklos Szeredi6da80892008-02-08 04:21:50 -0800191 .show_options = udf_show_options,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192};
193
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700194struct udf_options {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195 unsigned char novrs;
196 unsigned int blocksize;
197 unsigned int session;
198 unsigned int lastblock;
199 unsigned int anchor;
200 unsigned int volume;
201 unsigned short partition;
202 unsigned int fileset;
203 unsigned int rootdir;
204 unsigned int flags;
205 mode_t umask;
206 gid_t gid;
207 uid_t uid;
208 struct nls_table *nls_map;
209};
210
211static int __init init_udf_fs(void)
212{
213 int err;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700214
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215 err = init_inodecache();
216 if (err)
217 goto out1;
218 err = register_filesystem(&udf_fstype);
219 if (err)
220 goto out;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700221
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222 return 0;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700223
224out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225 destroy_inodecache();
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700226
227out1:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228 return err;
229}
230
231static void __exit exit_udf_fs(void)
232{
233 unregister_filesystem(&udf_fstype);
234 destroy_inodecache();
235}
236
237module_init(init_udf_fs)
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700238module_exit(exit_udf_fs)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239
Marcin Slusarzdc5d39b2008-02-08 04:20:32 -0800240static int udf_sb_alloc_partition_maps(struct super_block *sb, u32 count)
241{
242 struct udf_sb_info *sbi = UDF_SB(sb);
243
244 sbi->s_partmaps = kcalloc(count, sizeof(struct udf_part_map),
245 GFP_KERNEL);
246 if (!sbi->s_partmaps) {
247 udf_error(sb, __FUNCTION__,
248 "Unable to allocate space for %d partition maps",
249 count);
250 sbi->s_partitions = 0;
251 return -ENOMEM;
252 }
253
254 sbi->s_partitions = count;
255 return 0;
256}
257
Miklos Szeredi6da80892008-02-08 04:21:50 -0800258static int udf_show_options(struct seq_file *seq, struct vfsmount *mnt)
259{
260 struct super_block *sb = mnt->mnt_sb;
261 struct udf_sb_info *sbi = UDF_SB(sb);
262
263 if (!UDF_QUERY_FLAG(sb, UDF_FLAG_STRICT))
264 seq_puts(seq, ",nostrict");
265 if (sb->s_blocksize != UDF_DEFAULT_BLOCKSIZE)
266 seq_printf(seq, ",bs=%lu", sb->s_blocksize);
267 if (UDF_QUERY_FLAG(sb, UDF_FLAG_UNHIDE))
268 seq_puts(seq, ",unhide");
269 if (UDF_QUERY_FLAG(sb, UDF_FLAG_UNDELETE))
270 seq_puts(seq, ",undelete");
271 if (!UDF_QUERY_FLAG(sb, UDF_FLAG_USE_AD_IN_ICB))
272 seq_puts(seq, ",noadinicb");
273 if (UDF_QUERY_FLAG(sb, UDF_FLAG_USE_SHORT_AD))
274 seq_puts(seq, ",shortad");
275 if (UDF_QUERY_FLAG(sb, UDF_FLAG_UID_FORGET))
276 seq_puts(seq, ",uid=forget");
277 if (UDF_QUERY_FLAG(sb, UDF_FLAG_UID_IGNORE))
278 seq_puts(seq, ",uid=ignore");
279 if (UDF_QUERY_FLAG(sb, UDF_FLAG_GID_FORGET))
280 seq_puts(seq, ",gid=forget");
281 if (UDF_QUERY_FLAG(sb, UDF_FLAG_GID_IGNORE))
282 seq_puts(seq, ",gid=ignore");
283 if (UDF_QUERY_FLAG(sb, UDF_FLAG_UID_SET))
284 seq_printf(seq, ",uid=%u", sbi->s_uid);
285 if (UDF_QUERY_FLAG(sb, UDF_FLAG_GID_SET))
286 seq_printf(seq, ",gid=%u", sbi->s_gid);
287 if (sbi->s_umask != 0)
288 seq_printf(seq, ",umask=%o", sbi->s_umask);
289 if (UDF_QUERY_FLAG(sb, UDF_FLAG_SESSION_SET))
290 seq_printf(seq, ",session=%u", sbi->s_session);
291 if (UDF_QUERY_FLAG(sb, UDF_FLAG_LASTBLOCK_SET))
292 seq_printf(seq, ",lastblock=%u", sbi->s_last_block);
293 /*
294 * s_anchor[2] could be zeroed out in case there is no anchor
295 * in the specified block, but then the "anchor=N" option
296 * originally given by the user wasn't effective, so it's OK
297 * if we don't show it.
298 */
299 if (sbi->s_anchor[2] != 0)
300 seq_printf(seq, ",anchor=%u", sbi->s_anchor[2]);
301 /*
302 * volume, partition, fileset and rootdir seem to be ignored
303 * currently
304 */
305 if (UDF_QUERY_FLAG(sb, UDF_FLAG_UTF8))
306 seq_puts(seq, ",utf8");
307 if (UDF_QUERY_FLAG(sb, UDF_FLAG_NLS_MAP) && sbi->s_nls_map)
308 seq_printf(seq, ",iocharset=%s", sbi->s_nls_map->charset);
309
310 return 0;
311}
312
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313/*
314 * udf_parse_options
315 *
316 * PURPOSE
317 * Parse mount options.
318 *
319 * DESCRIPTION
320 * The following mount options are supported:
321 *
322 * gid= Set the default group.
323 * umask= Set the default umask.
324 * uid= Set the default user.
325 * bs= Set the block size.
326 * unhide Show otherwise hidden files.
327 * undelete Show deleted files in lists.
328 * adinicb Embed data in the inode (default)
329 * noadinicb Don't embed data in the inode
330 * shortad Use short ad's
331 * longad Use long ad's (default)
332 * nostrict Unset strict conformance
333 * iocharset= Set the NLS character set
334 *
335 * The remaining are for debugging and disaster recovery:
336 *
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700337 * novrs Skip volume sequence recognition
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338 *
339 * The following expect a offset from 0.
340 *
341 * session= Set the CDROM session (default= last session)
342 * anchor= Override standard anchor location. (default= 256)
343 * volume= Override the VolumeDesc location. (unused)
344 * partition= Override the PartitionDesc location. (unused)
345 * lastblock= Set the last block of the filesystem/
346 *
347 * The following expect a offset from the partition root.
348 *
349 * fileset= Override the fileset block location. (unused)
350 * rootdir= Override the root directory location. (unused)
351 * WARNING: overriding the rootdir to a non-directory may
352 * yield highly unpredictable results.
353 *
354 * PRE-CONDITIONS
355 * options Pointer to mount options string.
356 * uopts Pointer to mount options variable.
357 *
358 * POST-CONDITIONS
359 * <return> 1 Mount options parsed okay.
360 * <return> 0 Error parsing mount options.
361 *
362 * HISTORY
363 * July 1, 1997 - Andrew E. Mileski
364 * Written, tested, and released.
365 */
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700366
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367enum {
368 Opt_novrs, Opt_nostrict, Opt_bs, Opt_unhide, Opt_undelete,
369 Opt_noadinicb, Opt_adinicb, Opt_shortad, Opt_longad,
370 Opt_gid, Opt_uid, Opt_umask, Opt_session, Opt_lastblock,
371 Opt_anchor, Opt_volume, Opt_partition, Opt_fileset,
372 Opt_rootdir, Opt_utf8, Opt_iocharset,
Phillip Susi4d6660e2006-03-07 21:55:24 -0800373 Opt_err, Opt_uforget, Opt_uignore, Opt_gforget, Opt_gignore
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374};
375
376static match_table_t tokens = {
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700377 {Opt_novrs, "novrs"},
378 {Opt_nostrict, "nostrict"},
379 {Opt_bs, "bs=%u"},
380 {Opt_unhide, "unhide"},
381 {Opt_undelete, "undelete"},
382 {Opt_noadinicb, "noadinicb"},
383 {Opt_adinicb, "adinicb"},
384 {Opt_shortad, "shortad"},
385 {Opt_longad, "longad"},
386 {Opt_uforget, "uid=forget"},
387 {Opt_uignore, "uid=ignore"},
388 {Opt_gforget, "gid=forget"},
389 {Opt_gignore, "gid=ignore"},
390 {Opt_gid, "gid=%u"},
391 {Opt_uid, "uid=%u"},
392 {Opt_umask, "umask=%o"},
393 {Opt_session, "session=%u"},
394 {Opt_lastblock, "lastblock=%u"},
395 {Opt_anchor, "anchor=%u"},
396 {Opt_volume, "volume=%u"},
397 {Opt_partition, "partition=%u"},
398 {Opt_fileset, "fileset=%u"},
399 {Opt_rootdir, "rootdir=%u"},
400 {Opt_utf8, "utf8"},
401 {Opt_iocharset, "iocharset=%s"},
402 {Opt_err, NULL}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403};
404
Miklos Szeredi6da80892008-02-08 04:21:50 -0800405static int udf_parse_options(char *options, struct udf_options *uopt,
406 bool remount)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407{
408 char *p;
409 int option;
410
411 uopt->novrs = 0;
Miklos Szeredi6da80892008-02-08 04:21:50 -0800412 uopt->blocksize = UDF_DEFAULT_BLOCKSIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413 uopt->partition = 0xFFFF;
414 uopt->session = 0xFFFFFFFF;
415 uopt->lastblock = 0;
416 uopt->anchor = 0;
417 uopt->volume = 0xFFFFFFFF;
418 uopt->rootdir = 0xFFFFFFFF;
419 uopt->fileset = 0xFFFFFFFF;
420 uopt->nls_map = NULL;
421
422 if (!options)
423 return 1;
424
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700425 while ((p = strsep(&options, ",")) != NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426 substring_t args[MAX_OPT_ARGS];
427 int token;
428 if (!*p)
429 continue;
430
431 token = match_token(p, tokens, args);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700432 switch (token) {
433 case Opt_novrs:
434 uopt->novrs = 1;
435 case Opt_bs:
436 if (match_int(&args[0], &option))
437 return 0;
438 uopt->blocksize = option;
439 break;
440 case Opt_unhide:
441 uopt->flags |= (1 << UDF_FLAG_UNHIDE);
442 break;
443 case Opt_undelete:
444 uopt->flags |= (1 << UDF_FLAG_UNDELETE);
445 break;
446 case Opt_noadinicb:
447 uopt->flags &= ~(1 << UDF_FLAG_USE_AD_IN_ICB);
448 break;
449 case Opt_adinicb:
450 uopt->flags |= (1 << UDF_FLAG_USE_AD_IN_ICB);
451 break;
452 case Opt_shortad:
453 uopt->flags |= (1 << UDF_FLAG_USE_SHORT_AD);
454 break;
455 case Opt_longad:
456 uopt->flags &= ~(1 << UDF_FLAG_USE_SHORT_AD);
457 break;
458 case Opt_gid:
459 if (match_int(args, &option))
460 return 0;
461 uopt->gid = option;
Cyrill Gorcunovca76d2d2007-07-31 00:39:40 -0700462 uopt->flags |= (1 << UDF_FLAG_GID_SET);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700463 break;
464 case Opt_uid:
465 if (match_int(args, &option))
466 return 0;
467 uopt->uid = option;
Cyrill Gorcunovca76d2d2007-07-31 00:39:40 -0700468 uopt->flags |= (1 << UDF_FLAG_UID_SET);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700469 break;
470 case Opt_umask:
471 if (match_octal(args, &option))
472 return 0;
473 uopt->umask = option;
474 break;
475 case Opt_nostrict:
476 uopt->flags &= ~(1 << UDF_FLAG_STRICT);
477 break;
478 case Opt_session:
479 if (match_int(args, &option))
480 return 0;
481 uopt->session = option;
Miklos Szeredi6da80892008-02-08 04:21:50 -0800482 if (!remount)
483 uopt->flags |= (1 << UDF_FLAG_SESSION_SET);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700484 break;
485 case Opt_lastblock:
486 if (match_int(args, &option))
487 return 0;
488 uopt->lastblock = option;
Miklos Szeredi6da80892008-02-08 04:21:50 -0800489 if (!remount)
490 uopt->flags |= (1 << UDF_FLAG_LASTBLOCK_SET);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700491 break;
492 case Opt_anchor:
493 if (match_int(args, &option))
494 return 0;
495 uopt->anchor = option;
496 break;
497 case Opt_volume:
498 if (match_int(args, &option))
499 return 0;
500 uopt->volume = option;
501 break;
502 case Opt_partition:
503 if (match_int(args, &option))
504 return 0;
505 uopt->partition = option;
506 break;
507 case Opt_fileset:
508 if (match_int(args, &option))
509 return 0;
510 uopt->fileset = option;
511 break;
512 case Opt_rootdir:
513 if (match_int(args, &option))
514 return 0;
515 uopt->rootdir = option;
516 break;
517 case Opt_utf8:
518 uopt->flags |= (1 << UDF_FLAG_UTF8);
519 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520#ifdef CONFIG_UDF_NLS
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700521 case Opt_iocharset:
522 uopt->nls_map = load_nls(args[0].from);
523 uopt->flags |= (1 << UDF_FLAG_NLS_MAP);
524 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525#endif
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700526 case Opt_uignore:
527 uopt->flags |= (1 << UDF_FLAG_UID_IGNORE);
528 break;
529 case Opt_uforget:
530 uopt->flags |= (1 << UDF_FLAG_UID_FORGET);
531 break;
532 case Opt_gignore:
533 uopt->flags |= (1 << UDF_FLAG_GID_IGNORE);
534 break;
535 case Opt_gforget:
536 uopt->flags |= (1 << UDF_FLAG_GID_FORGET);
537 break;
538 default:
539 printk(KERN_ERR "udf: bad mount option \"%s\" "
540 "or missing value\n", p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541 return 0;
542 }
543 }
544 return 1;
545}
546
Marcin Slusarzbd45a422008-02-08 04:20:35 -0800547static void udf_write_super(struct super_block *sb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548{
549 lock_kernel();
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700550
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551 if (!(sb->s_flags & MS_RDONLY))
552 udf_open_lvid(sb);
553 sb->s_dirt = 0;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700554
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555 unlock_kernel();
556}
557
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700558static int udf_remount_fs(struct super_block *sb, int *flags, char *options)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559{
560 struct udf_options uopt;
Marcin Slusarz6c79e982008-02-08 04:20:30 -0800561 struct udf_sb_info *sbi = UDF_SB(sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562
Marcin Slusarz6c79e982008-02-08 04:20:30 -0800563 uopt.flags = sbi->s_flags;
564 uopt.uid = sbi->s_uid;
565 uopt.gid = sbi->s_gid;
566 uopt.umask = sbi->s_umask;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567
Miklos Szeredi6da80892008-02-08 04:21:50 -0800568 if (!udf_parse_options(options, &uopt, true))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569 return -EINVAL;
570
Marcin Slusarz6c79e982008-02-08 04:20:30 -0800571 sbi->s_flags = uopt.flags;
572 sbi->s_uid = uopt.uid;
573 sbi->s_gid = uopt.gid;
574 sbi->s_umask = uopt.umask;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575
Marcin Slusarz6c79e982008-02-08 04:20:30 -0800576 if (sbi->s_lvid_bh) {
577 int write_rev = le16_to_cpu(udf_sb_lvidiu(sbi)->minUDFWriteRev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578 if (write_rev > UDF_MAX_WRITE_VERSION)
579 *flags |= MS_RDONLY;
580 }
581
582 if ((*flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY))
583 return 0;
584 if (*flags & MS_RDONLY)
585 udf_close_lvid(sb);
586 else
587 udf_open_lvid(sb);
588
589 return 0;
590}
591
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700592static int udf_vrs(struct super_block *sb, int silent)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593{
594 struct volStructDesc *vsd = NULL;
595 int sector = 32768;
596 int sectorsize;
597 struct buffer_head *bh = NULL;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700598 int iso9660 = 0;
599 int nsr02 = 0;
600 int nsr03 = 0;
Marcin Slusarz6c79e982008-02-08 04:20:30 -0800601 struct udf_sb_info *sbi;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602
603 /* Block size must be a multiple of 512 */
604 if (sb->s_blocksize & 511)
605 return 0;
Marcin Slusarz6c79e982008-02-08 04:20:30 -0800606 sbi = UDF_SB(sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607
608 if (sb->s_blocksize < sizeof(struct volStructDesc))
609 sectorsize = sizeof(struct volStructDesc);
610 else
611 sectorsize = sb->s_blocksize;
612
Marcin Slusarz6c79e982008-02-08 04:20:30 -0800613 sector += (sbi->s_session << sb->s_blocksize_bits);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614
615 udf_debug("Starting at sector %u (%ld byte sectors)\n",
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700616 (sector >> sb->s_blocksize_bits), sb->s_blocksize);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617 /* Process the sequence (if applicable) */
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700618 for (; !nsr02 && !nsr03; sector += sectorsize) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619 /* Read a block */
620 bh = udf_tread(sb, sector >> sb->s_blocksize_bits);
621 if (!bh)
622 break;
623
624 /* Look for ISO descriptors */
625 vsd = (struct volStructDesc *)(bh->b_data +
Marcin Slusarz3a71fc52008-02-08 04:20:28 -0800626 (sector & (sb->s_blocksize - 1)));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700628 if (vsd->stdIdent[0] == 0) {
Jan Kara3bf25cb2007-05-08 00:35:16 -0700629 brelse(bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630 break;
Marcin Slusarz3a71fc52008-02-08 04:20:28 -0800631 } else if (!strncmp(vsd->stdIdent, VSD_STD_ID_CD001,
632 VSD_STD_ID_LEN)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633 iso9660 = sector;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700634 switch (vsd->structType) {
635 case 0:
636 udf_debug("ISO9660 Boot Record found\n");
637 break;
638 case 1:
Marcin Slusarz3a71fc52008-02-08 04:20:28 -0800639 udf_debug("ISO9660 Primary Volume Descriptor "
640 "found\n");
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700641 break;
642 case 2:
Marcin Slusarz3a71fc52008-02-08 04:20:28 -0800643 udf_debug("ISO9660 Supplementary Volume "
644 "Descriptor found\n");
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700645 break;
646 case 3:
Marcin Slusarz3a71fc52008-02-08 04:20:28 -0800647 udf_debug("ISO9660 Volume Partition Descriptor "
648 "found\n");
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700649 break;
650 case 255:
Marcin Slusarz3a71fc52008-02-08 04:20:28 -0800651 udf_debug("ISO9660 Volume Descriptor Set "
652 "Terminator found\n");
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700653 break;
654 default:
655 udf_debug("ISO9660 VRS (%u) found\n",
656 vsd->structType);
657 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700658 }
Marcin Slusarz3a71fc52008-02-08 04:20:28 -0800659 } else if (!strncmp(vsd->stdIdent, VSD_STD_ID_BEA01,
660 VSD_STD_ID_LEN))
661 ; /* nothing */
662 else if (!strncmp(vsd->stdIdent, VSD_STD_ID_TEA01,
663 VSD_STD_ID_LEN)) {
Jan Kara3bf25cb2007-05-08 00:35:16 -0700664 brelse(bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665 break;
Marcin Slusarz3a71fc52008-02-08 04:20:28 -0800666 } else if (!strncmp(vsd->stdIdent, VSD_STD_ID_NSR02,
667 VSD_STD_ID_LEN))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700668 nsr02 = sector;
Marcin Slusarz3a71fc52008-02-08 04:20:28 -0800669 else if (!strncmp(vsd->stdIdent, VSD_STD_ID_NSR03,
670 VSD_STD_ID_LEN))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671 nsr03 = sector;
Jan Kara3bf25cb2007-05-08 00:35:16 -0700672 brelse(bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700673 }
674
675 if (nsr03)
676 return nsr03;
677 else if (nsr02)
678 return nsr02;
Marcin Slusarz6c79e982008-02-08 04:20:30 -0800679 else if (sector - (sbi->s_session << sb->s_blocksize_bits) == 32768)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680 return -1;
681 else
682 return 0;
683}
684
685/*
686 * udf_find_anchor
687 *
688 * PURPOSE
689 * Find an anchor volume descriptor.
690 *
691 * PRE-CONDITIONS
692 * sb Pointer to _locked_ superblock.
693 * lastblock Last block on media.
694 *
695 * POST-CONDITIONS
696 * <return> 1 if not found, 0 if ok
697 *
698 * HISTORY
699 * July 1, 1997 - Andrew E. Mileski
700 * Written, tested, and released.
701 */
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700702static void udf_find_anchor(struct super_block *sb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703{
Marcin Slusarz6c79e982008-02-08 04:20:30 -0800704 int lastblock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700705 struct buffer_head *bh = NULL;
706 uint16_t ident;
707 uint32_t location;
708 int i;
Marcin Slusarz6c79e982008-02-08 04:20:30 -0800709 struct udf_sb_info *sbi;
710
711 sbi = UDF_SB(sb);
712 lastblock = sbi->s_last_block;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700714 if (lastblock) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715 int varlastblock = udf_variable_to_fixed(lastblock);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700716 int last[] = { lastblock, lastblock - 2,
717 lastblock - 150, lastblock - 152,
718 varlastblock, varlastblock - 2,
719 varlastblock - 150, varlastblock - 152 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720
721 lastblock = 0;
722
723 /* Search for an anchor volume descriptor pointer */
724
725 /* according to spec, anchor is in either:
726 * block 256
727 * lastblock-256
728 * lastblock
729 * however, if the disc isn't closed, it could be 512 */
730
Tobias Klausere8c96f82006-03-24 03:15:34 -0800731 for (i = 0; !lastblock && i < ARRAY_SIZE(last); i++) {
Marcin Slusarz3a71fc52008-02-08 04:20:28 -0800732 ident = location = 0;
733 if (last[i] >= 0) {
734 bh = sb_bread(sb, last[i]);
735 if (bh) {
736 tag *t = (tag *)bh->b_data;
737 ident = le16_to_cpu(t->tagIdent);
738 location = le32_to_cpu(t->tagLocation);
739 brelse(bh);
740 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741 }
Tobias Klausere8c96f82006-03-24 03:15:34 -0800742
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700743 if (ident == TAG_IDENT_AVDP) {
Marcin Slusarz6c79e982008-02-08 04:20:30 -0800744 if (location == last[i] - sbi->s_session) {
745 lastblock = last[i] - sbi->s_session;
746 sbi->s_anchor[0] = lastblock;
747 sbi->s_anchor[1] = lastblock - 256;
Marcin Slusarz4b111112008-02-08 04:20:36 -0800748 } else if (location ==
749 udf_variable_to_fixed(last[i]) -
750 sbi->s_session) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751 UDF_SET_FLAG(sb, UDF_FLAG_VARCONV);
Marcin Slusarz4b111112008-02-08 04:20:36 -0800752 lastblock =
753 udf_variable_to_fixed(last[i]) -
754 sbi->s_session;
Marcin Slusarz6c79e982008-02-08 04:20:30 -0800755 sbi->s_anchor[0] = lastblock;
Marcin Slusarz4b111112008-02-08 04:20:36 -0800756 sbi->s_anchor[1] = lastblock - 256 -
757 sbi->s_session;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700758 } else {
Marcin Slusarz4b111112008-02-08 04:20:36 -0800759 udf_debug("Anchor found at block %d, "
760 "location mismatch %d.\n",
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700761 last[i], location);
762 }
Marcin Slusarz4b111112008-02-08 04:20:36 -0800763 } else if (ident == TAG_IDENT_FE ||
764 ident == TAG_IDENT_EFE) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765 lastblock = last[i];
Marcin Slusarz6c79e982008-02-08 04:20:30 -0800766 sbi->s_anchor[3] = 512;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700767 } else {
Marcin Slusarz3a71fc52008-02-08 04:20:28 -0800768 ident = location = 0;
769 if (last[i] >= 256) {
770 bh = sb_bread(sb, last[i] - 256);
771 if (bh) {
772 tag *t = (tag *)bh->b_data;
Marcin Slusarz4b111112008-02-08 04:20:36 -0800773 ident = le16_to_cpu(
774 t->tagIdent);
775 location = le32_to_cpu(
776 t->tagLocation);
Marcin Slusarz3a71fc52008-02-08 04:20:28 -0800777 brelse(bh);
778 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700779 }
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700780
Linus Torvalds1da177e2005-04-16 15:20:36 -0700781 if (ident == TAG_IDENT_AVDP &&
Marcin Slusarz4b111112008-02-08 04:20:36 -0800782 location == last[i] - 256 -
783 sbi->s_session) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784 lastblock = last[i];
Marcin Slusarz6c79e982008-02-08 04:20:30 -0800785 sbi->s_anchor[1] = last[i] - 256;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700786 } else {
Marcin Slusarz3a71fc52008-02-08 04:20:28 -0800787 ident = location = 0;
Marcin Slusarz6c79e982008-02-08 04:20:30 -0800788 if (last[i] >= 312 + sbi->s_session) {
Marcin Slusarz4b111112008-02-08 04:20:36 -0800789 bh = sb_bread(sb,
790 last[i] - 312 -
791 sbi->s_session);
Marcin Slusarz3a71fc52008-02-08 04:20:28 -0800792 if (bh) {
Marcin Slusarz4b111112008-02-08 04:20:36 -0800793 tag *t = (tag *)
794 bh->b_data;
795 ident = le16_to_cpu(
796 t->tagIdent);
797 location = le32_to_cpu(
798 t->tagLocation);
Marcin Slusarz3a71fc52008-02-08 04:20:28 -0800799 brelse(bh);
800 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801 }
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700802
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803 if (ident == TAG_IDENT_AVDP &&
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700804 location == udf_variable_to_fixed(last[i]) - 256) {
Marcin Slusarz4b111112008-02-08 04:20:36 -0800805 UDF_SET_FLAG(sb,
806 UDF_FLAG_VARCONV);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700807 lastblock = udf_variable_to_fixed(last[i]);
Marcin Slusarz6c79e982008-02-08 04:20:30 -0800808 sbi->s_anchor[1] = lastblock - 256;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700809 }
810 }
811 }
812 }
813 }
814
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700815 if (!lastblock) {
Marcin Slusarz3a71fc52008-02-08 04:20:28 -0800816 /* We haven't found the lastblock. check 312 */
Marcin Slusarz6c79e982008-02-08 04:20:30 -0800817 bh = sb_bread(sb, 312 + sbi->s_session);
Marcin Slusarz3a71fc52008-02-08 04:20:28 -0800818 if (bh) {
819 tag *t = (tag *)bh->b_data;
820 ident = le16_to_cpu(t->tagIdent);
821 location = le32_to_cpu(t->tagLocation);
Jan Kara3bf25cb2007-05-08 00:35:16 -0700822 brelse(bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700823
824 if (ident == TAG_IDENT_AVDP && location == 256)
825 UDF_SET_FLAG(sb, UDF_FLAG_VARCONV);
826 }
827 }
828
Marcin Slusarz6c79e982008-02-08 04:20:30 -0800829 for (i = 0; i < ARRAY_SIZE(sbi->s_anchor); i++) {
830 if (sbi->s_anchor[i]) {
831 bh = udf_read_tagged(sb, sbi->s_anchor[i],
832 sbi->s_anchor[i], &ident);
Marcin Slusarz3a71fc52008-02-08 04:20:28 -0800833 if (!bh)
Marcin Slusarz6c79e982008-02-08 04:20:30 -0800834 sbi->s_anchor[i] = 0;
Marcin Slusarz3a71fc52008-02-08 04:20:28 -0800835 else {
Jan Kara3bf25cb2007-05-08 00:35:16 -0700836 brelse(bh);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700837 if ((ident != TAG_IDENT_AVDP) &&
Marcin Slusarz4b111112008-02-08 04:20:36 -0800838 (i || (ident != TAG_IDENT_FE &&
839 ident != TAG_IDENT_EFE)))
Marcin Slusarz6c79e982008-02-08 04:20:30 -0800840 sbi->s_anchor[i] = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841 }
842 }
843 }
844
Marcin Slusarz6c79e982008-02-08 04:20:30 -0800845 sbi->s_last_block = lastblock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700846}
847
Marcin Slusarz3a71fc52008-02-08 04:20:28 -0800848static int udf_find_fileset(struct super_block *sb,
849 kernel_lb_addr *fileset,
850 kernel_lb_addr *root)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700851{
852 struct buffer_head *bh = NULL;
853 long lastblock;
854 uint16_t ident;
Marcin Slusarz6c79e982008-02-08 04:20:30 -0800855 struct udf_sb_info *sbi;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700856
857 if (fileset->logicalBlockNum != 0xFFFFFFFF ||
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700858 fileset->partitionReferenceNum != 0xFFFF) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700859 bh = udf_read_ptagged(sb, *fileset, 0, &ident);
860
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700861 if (!bh) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700862 return 1;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700863 } else if (ident != TAG_IDENT_FSD) {
Jan Kara3bf25cb2007-05-08 00:35:16 -0700864 brelse(bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865 return 1;
866 }
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700867
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868 }
869
Marcin Slusarz6c79e982008-02-08 04:20:30 -0800870 sbi = UDF_SB(sb);
Marcin Slusarz3a71fc52008-02-08 04:20:28 -0800871 if (!bh) {
872 /* Search backwards through the partitions */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700873 kernel_lb_addr newfileset;
874
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700875/* --> cvg: FIXME - is it reasonable? */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700876 return 1;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700877
Marcin Slusarz6c79e982008-02-08 04:20:30 -0800878 for (newfileset.partitionReferenceNum = sbi->s_partitions - 1;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700879 (newfileset.partitionReferenceNum != 0xFFFF &&
880 fileset->logicalBlockNum == 0xFFFFFFFF &&
881 fileset->partitionReferenceNum == 0xFFFF);
882 newfileset.partitionReferenceNum--) {
Marcin Slusarz6c79e982008-02-08 04:20:30 -0800883 lastblock = sbi->s_partmaps
884 [newfileset.partitionReferenceNum]
885 .s_partition_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700886 newfileset.logicalBlockNum = 0;
887
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700888 do {
Marcin Slusarz3a71fc52008-02-08 04:20:28 -0800889 bh = udf_read_ptagged(sb, newfileset, 0,
890 &ident);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700891 if (!bh) {
892 newfileset.logicalBlockNum++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700893 continue;
894 }
895
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700896 switch (ident) {
897 case TAG_IDENT_SBD:
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700898 {
899 struct spaceBitmapDesc *sp;
Marcin Slusarz4b111112008-02-08 04:20:36 -0800900 sp = (struct spaceBitmapDesc *)
901 bh->b_data;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700902 newfileset.logicalBlockNum += 1 +
903 ((le32_to_cpu(sp->numOfBytes) +
Marcin Slusarz4b111112008-02-08 04:20:36 -0800904 sizeof(struct spaceBitmapDesc)
905 - 1) >> sb->s_blocksize_bits);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700906 brelse(bh);
907 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700908 }
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700909 case TAG_IDENT_FSD:
910 *fileset = newfileset;
911 break;
912 default:
913 newfileset.logicalBlockNum++;
914 brelse(bh);
915 bh = NULL;
916 break;
917 }
918 } while (newfileset.logicalBlockNum < lastblock &&
919 fileset->logicalBlockNum == 0xFFFFFFFF &&
920 fileset->partitionReferenceNum == 0xFFFF);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700921 }
922 }
923
924 if ((fileset->logicalBlockNum != 0xFFFFFFFF ||
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700925 fileset->partitionReferenceNum != 0xFFFF) && bh) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700926 udf_debug("Fileset at block=%d, partition=%d\n",
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700927 fileset->logicalBlockNum,
928 fileset->partitionReferenceNum);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700929
Marcin Slusarz6c79e982008-02-08 04:20:30 -0800930 sbi->s_partition = fileset->partitionReferenceNum;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700931 udf_load_fileset(sb, bh, root);
Jan Kara3bf25cb2007-05-08 00:35:16 -0700932 brelse(bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700933 return 0;
934 }
935 return 1;
936}
937
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700938static void udf_load_pvoldesc(struct super_block *sb, struct buffer_head *bh)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700939{
940 struct primaryVolDesc *pvoldesc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700941 struct ustr instr;
942 struct ustr outstr;
943
944 pvoldesc = (struct primaryVolDesc *)bh->b_data;
945
marcin.slusarz@gmail.comcbf56762008-02-27 22:50:14 +0100946 if (udf_stamp_to_time(&UDF_SB(sb)->s_record_time,
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700947 lets_to_cpu(pvoldesc->recordingDateAndTime))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700948 kernel_timestamp ts;
949 ts = lets_to_cpu(pvoldesc->recordingDateAndTime);
marcin.slusarz@gmail.comcbf56762008-02-27 22:50:14 +0100950 udf_debug("recording time %04u/%02u/%02u"
Marcin Slusarz3a71fc52008-02-08 04:20:28 -0800951 " %02u:%02u (%x)\n",
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700952 ts.year, ts.month, ts.day, ts.hour,
953 ts.minute, ts.typeAndTimezone);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700954 }
955
Marcin Slusarz4b111112008-02-08 04:20:36 -0800956 if (!udf_build_ustr(&instr, pvoldesc->volIdent, 32))
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700957 if (udf_CS0toUTF8(&outstr, &instr)) {
Marcin Slusarz6c79e982008-02-08 04:20:30 -0800958 strncpy(UDF_SB(sb)->s_volume_ident, outstr.u_name,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700959 outstr.u_len > 31 ? 31 : outstr.u_len);
Marcin Slusarz4b111112008-02-08 04:20:36 -0800960 udf_debug("volIdent[] = '%s'\n",
961 UDF_SB(sb)->s_volume_ident);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700962 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700963
Marcin Slusarz4b111112008-02-08 04:20:36 -0800964 if (!udf_build_ustr(&instr, pvoldesc->volSetIdent, 128))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700965 if (udf_CS0toUTF8(&outstr, &instr))
966 udf_debug("volSetIdent[] = '%s'\n", outstr.u_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700967}
968
Cyrill Gorcunov28de7942007-07-21 04:37:18 -0700969static void udf_load_fileset(struct super_block *sb, struct buffer_head *bh,
970 kernel_lb_addr *root)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700971{
972 struct fileSetDesc *fset;
973
974 fset = (struct fileSetDesc *)bh->b_data;
975
976 *root = lelb_to_cpu(fset->rootDirectoryICB.extLocation);
977
Marcin Slusarz6c79e982008-02-08 04:20:30 -0800978 UDF_SB(sb)->s_serial_number = le16_to_cpu(fset->descTag.tagSerialNum);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700979
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -0700980 udf_debug("Rootdir at block=%d, partition=%d\n",
981 root->logicalBlockNum, root->partitionReferenceNum);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700982}
983
Marcin Slusarz883cb9d2008-02-08 04:20:34 -0800984int udf_compute_nr_groups(struct super_block *sb, u32 partition)
985{
986 struct udf_part_map *map = &UDF_SB(sb)->s_partmaps[partition];
Julia Lawall8dee00b2008-02-14 16:15:45 +0100987 return DIV_ROUND_UP(map->s_partition_len +
988 (sizeof(struct spaceBitmapDesc) << 3),
989 sb->s_blocksize * 8);
Marcin Slusarz883cb9d2008-02-08 04:20:34 -0800990}
991
Marcin Slusarz66e1da32008-02-08 04:20:33 -0800992static struct udf_bitmap *udf_sb_alloc_bitmap(struct super_block *sb, u32 index)
993{
Marcin Slusarz66e1da32008-02-08 04:20:33 -0800994 struct udf_bitmap *bitmap;
995 int nr_groups;
996 int size;
997
Marcin Slusarz883cb9d2008-02-08 04:20:34 -0800998 nr_groups = udf_compute_nr_groups(sb, index);
Marcin Slusarz66e1da32008-02-08 04:20:33 -0800999 size = sizeof(struct udf_bitmap) +
1000 (sizeof(struct buffer_head *) * nr_groups);
1001
1002 if (size <= PAGE_SIZE)
1003 bitmap = kmalloc(size, GFP_KERNEL);
1004 else
1005 bitmap = vmalloc(size); /* TODO: get rid of vmalloc */
1006
1007 if (bitmap == NULL) {
1008 udf_error(sb, __FUNCTION__,
1009 "Unable to allocate space for bitmap "
1010 "and %d buffer_head pointers", nr_groups);
1011 return NULL;
1012 }
1013
1014 memset(bitmap, 0x00, size);
1015 bitmap->s_block_bitmap = (struct buffer_head **)(bitmap + 1);
1016 bitmap->s_nr_groups = nr_groups;
1017 return bitmap;
1018}
1019
Jan Karabcec4472007-08-30 23:56:22 -07001020static int udf_load_partdesc(struct super_block *sb, struct buffer_head *bh)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001021{
1022 struct partitionDesc *p;
1023 int i;
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001024 struct udf_part_map *map;
1025 struct udf_sb_info *sbi;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001026
1027 p = (struct partitionDesc *)bh->b_data;
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001028 sbi = UDF_SB(sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001030 for (i = 0; i < sbi->s_partitions; i++) {
1031 map = &sbi->s_partmaps[i];
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001032 udf_debug("Searching map: (%d == %d)\n",
Marcin Slusarz4b111112008-02-08 04:20:36 -08001033 map->s_partition_num,
1034 le16_to_cpu(p->partitionNumber));
1035 if (map->s_partition_num ==
1036 le16_to_cpu(p->partitionNumber)) {
1037 map->s_partition_len =
1038 le32_to_cpu(p->partitionLength); /* blocks */
1039 map->s_partition_root =
1040 le32_to_cpu(p->partitionStartingLocation);
Marcin Slusarz5e0f0012008-02-08 04:20:41 -08001041 if (p->accessType ==
1042 cpu_to_le32(PD_ACCESS_TYPE_READ_ONLY))
Marcin Slusarz4b111112008-02-08 04:20:36 -08001043 map->s_partition_flags |=
1044 UDF_PART_FLAG_READ_ONLY;
Marcin Slusarz5e0f0012008-02-08 04:20:41 -08001045 if (p->accessType ==
1046 cpu_to_le32(PD_ACCESS_TYPE_WRITE_ONCE))
Marcin Slusarz4b111112008-02-08 04:20:36 -08001047 map->s_partition_flags |=
1048 UDF_PART_FLAG_WRITE_ONCE;
Marcin Slusarz5e0f0012008-02-08 04:20:41 -08001049 if (p->accessType ==
1050 cpu_to_le32(PD_ACCESS_TYPE_REWRITABLE))
Marcin Slusarz4b111112008-02-08 04:20:36 -08001051 map->s_partition_flags |=
1052 UDF_PART_FLAG_REWRITABLE;
Marcin Slusarz5e0f0012008-02-08 04:20:41 -08001053 if (p->accessType ==
1054 cpu_to_le32(PD_ACCESS_TYPE_OVERWRITABLE))
Marcin Slusarz4b111112008-02-08 04:20:36 -08001055 map->s_partition_flags |=
1056 UDF_PART_FLAG_OVERWRITABLE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001057
Marcin Slusarz3a71fc52008-02-08 04:20:28 -08001058 if (!strcmp(p->partitionContents.ident,
1059 PD_PARTITION_CONTENTS_NSR02) ||
1060 !strcmp(p->partitionContents.ident,
1061 PD_PARTITION_CONTENTS_NSR03)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001062 struct partitionHeaderDesc *phd;
1063
Marcin Slusarz4b111112008-02-08 04:20:36 -08001064 phd = (struct partitionHeaderDesc *)
1065 (p->partitionContentsUse);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001066 if (phd->unallocSpaceTable.extLength) {
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001067 kernel_lb_addr loc = {
1068 .logicalBlockNum = le32_to_cpu(phd->unallocSpaceTable.extPosition),
1069 .partitionReferenceNum = i,
1070 };
Linus Torvalds1da177e2005-04-16 15:20:36 -07001071
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001072 map->s_uspace.s_table =
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001073 udf_iget(sb, loc);
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001074 if (!map->s_uspace.s_table) {
Cyrill Gorcunovb1e7a4b12007-10-16 23:30:08 -07001075 udf_debug("cannot load unallocSpaceTable (part %d)\n", i);
Jan Karabcec4472007-08-30 23:56:22 -07001076 return 1;
1077 }
Marcin Slusarz4b111112008-02-08 04:20:36 -08001078 map->s_partition_flags |=
1079 UDF_PART_FLAG_UNALLOC_TABLE;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001080 udf_debug("unallocSpaceTable (part %d) @ %ld\n",
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001081 i, map->s_uspace.s_table->i_ino);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001082 }
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001083 if (phd->unallocSpaceBitmap.extLength) {
Marcin Slusarz4b111112008-02-08 04:20:36 -08001084 struct udf_bitmap *bitmap =
1085 udf_sb_alloc_bitmap(sb, i);
1086 map->s_uspace.s_bitmap = bitmap;
1087 if (bitmap != NULL) {
1088 bitmap->s_extLength =
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001089 le32_to_cpu(phd->unallocSpaceBitmap.extLength);
Marcin Slusarz4b111112008-02-08 04:20:36 -08001090 bitmap->s_extPosition =
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001091 le32_to_cpu(phd->unallocSpaceBitmap.extPosition);
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001092 map->s_partition_flags |= UDF_PART_FLAG_UNALLOC_BITMAP;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001093 udf_debug("unallocSpaceBitmap (part %d) @ %d\n",
Marcin Slusarz4b111112008-02-08 04:20:36 -08001094 i, bitmap->s_extPosition);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001095 }
1096 }
1097 if (phd->partitionIntegrityTable.extLength)
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001098 udf_debug("partitionIntegrityTable (part %d)\n", i);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001099 if (phd->freedSpaceTable.extLength) {
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001100 kernel_lb_addr loc = {
1101 .logicalBlockNum = le32_to_cpu(phd->freedSpaceTable.extPosition),
1102 .partitionReferenceNum = i,
1103 };
Linus Torvalds1da177e2005-04-16 15:20:36 -07001104
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001105 map->s_fspace.s_table =
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001106 udf_iget(sb, loc);
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001107 if (!map->s_fspace.s_table) {
Cyrill Gorcunovb1e7a4b12007-10-16 23:30:08 -07001108 udf_debug("cannot load freedSpaceTable (part %d)\n", i);
Jan Karabcec4472007-08-30 23:56:22 -07001109 return 1;
1110 }
Marcin Slusarz4b111112008-02-08 04:20:36 -08001111 map->s_partition_flags |=
1112 UDF_PART_FLAG_FREED_TABLE;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001113 udf_debug("freedSpaceTable (part %d) @ %ld\n",
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001114 i, map->s_fspace.s_table->i_ino);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001115 }
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001116 if (phd->freedSpaceBitmap.extLength) {
Marcin Slusarz4b111112008-02-08 04:20:36 -08001117 struct udf_bitmap *bitmap =
1118 udf_sb_alloc_bitmap(sb, i);
1119 map->s_fspace.s_bitmap = bitmap;
1120 if (bitmap != NULL) {
1121 bitmap->s_extLength =
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001122 le32_to_cpu(phd->freedSpaceBitmap.extLength);
Marcin Slusarz4b111112008-02-08 04:20:36 -08001123 bitmap->s_extPosition =
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001124 le32_to_cpu(phd->freedSpaceBitmap.extPosition);
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001125 map->s_partition_flags |= UDF_PART_FLAG_FREED_BITMAP;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001126 udf_debug("freedSpaceBitmap (part %d) @ %d\n",
Marcin Slusarz4b111112008-02-08 04:20:36 -08001127 i, bitmap->s_extPosition);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001128 }
1129 }
1130 }
1131 break;
1132 }
1133 }
Marcin Slusarz4b111112008-02-08 04:20:36 -08001134 if (i == sbi->s_partitions)
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001135 udf_debug("Partition (%d) not found in partition map\n",
1136 le16_to_cpu(p->partitionNumber));
Marcin Slusarz4b111112008-02-08 04:20:36 -08001137 else
Marcin Slusarz3a71fc52008-02-08 04:20:28 -08001138 udf_debug("Partition (%d:%d type %x) starts at physical %d, "
1139 "block length %d\n",
1140 le16_to_cpu(p->partitionNumber), i,
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001141 map->s_partition_type,
1142 map->s_partition_root,
1143 map->s_partition_len);
Jan Karabcec4472007-08-30 23:56:22 -07001144 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001145}
1146
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001147static int udf_load_logicalvol(struct super_block *sb, struct buffer_head *bh,
1148 kernel_lb_addr *fileset)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001149{
1150 struct logicalVolDesc *lvd;
1151 int i, j, offset;
1152 uint8_t type;
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001153 struct udf_sb_info *sbi = UDF_SB(sb);
Marcin Slusarz4b111112008-02-08 04:20:36 -08001154 struct genericPartitionMap *gpm;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001155
1156 lvd = (struct logicalVolDesc *)bh->b_data;
1157
Marcin Slusarzdc5d39b2008-02-08 04:20:32 -08001158 i = udf_sb_alloc_partition_maps(sb, le32_to_cpu(lvd->numPartitionMaps));
1159 if (i != 0)
1160 return i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001161
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001162 for (i = 0, offset = 0;
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001163 i < sbi->s_partitions && offset < le32_to_cpu(lvd->mapTableLength);
Marcin Slusarz4b111112008-02-08 04:20:36 -08001164 i++, offset += gpm->partitionMapLength) {
1165 struct udf_part_map *map = &sbi->s_partmaps[i];
1166 gpm = (struct genericPartitionMap *)
1167 &(lvd->partitionMaps[offset]);
1168 type = gpm->partitionMapType;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001169 if (type == 1) {
Marcin Slusarz4b111112008-02-08 04:20:36 -08001170 struct genericPartitionMap1 *gpm1 =
1171 (struct genericPartitionMap1 *)gpm;
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001172 map->s_partition_type = UDF_TYPE1_MAP15;
1173 map->s_volumeseqnum = le16_to_cpu(gpm1->volSeqNum);
1174 map->s_partition_num = le16_to_cpu(gpm1->partitionNum);
1175 map->s_partition_func = NULL;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001176 } else if (type == 2) {
Marcin Slusarz4b111112008-02-08 04:20:36 -08001177 struct udfPartitionMap2 *upm2 =
1178 (struct udfPartitionMap2 *)gpm;
1179 if (!strncmp(upm2->partIdent.ident, UDF_ID_VIRTUAL,
1180 strlen(UDF_ID_VIRTUAL))) {
1181 u16 suf =
1182 le16_to_cpu(((__le16 *)upm2->partIdent.
1183 identSuffix)[0]);
1184 if (suf == 0x0150) {
1185 map->s_partition_type =
1186 UDF_VIRTUAL_MAP15;
1187 map->s_partition_func =
1188 udf_get_pblock_virt15;
1189 } else if (suf == 0x0200) {
1190 map->s_partition_type =
1191 UDF_VIRTUAL_MAP20;
1192 map->s_partition_func =
1193 udf_get_pblock_virt20;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001194 }
Marcin Slusarz4b111112008-02-08 04:20:36 -08001195 } else if (!strncmp(upm2->partIdent.ident,
1196 UDF_ID_SPARABLE,
1197 strlen(UDF_ID_SPARABLE))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001198 uint32_t loc;
1199 uint16_t ident;
1200 struct sparingTable *st;
Marcin Slusarz4b111112008-02-08 04:20:36 -08001201 struct sparablePartitionMap *spm =
1202 (struct sparablePartitionMap *)gpm;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001203
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001204 map->s_partition_type = UDF_SPARABLE_MAP15;
Marcin Slusarz4b111112008-02-08 04:20:36 -08001205 map->s_type_specific.s_sparing.s_packet_len =
1206 le16_to_cpu(spm->packetLength);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001207 for (j = 0; j < spm->numSparingTables; j++) {
Marcin Slusarz4b111112008-02-08 04:20:36 -08001208 struct buffer_head *bh2;
1209
1210 loc = le32_to_cpu(
1211 spm->locSparingTable[j]);
1212 bh2 = udf_read_tagged(sb, loc, loc,
1213 &ident);
1214 map->s_type_specific.s_sparing.
1215 s_spar_map[j] = bh2;
1216
1217 if (bh2 != NULL) {
1218 st = (struct sparingTable *)
1219 bh2->b_data;
1220 if (ident != 0 || strncmp(
1221 st->sparingIdent.ident,
1222 UDF_ID_SPARING,
1223 strlen(UDF_ID_SPARING))) {
1224 brelse(bh2);
1225 map->s_type_specific.
1226 s_sparing.
1227 s_spar_map[j] =
1228 NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001229 }
1230 }
1231 }
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001232 map->s_partition_func = udf_get_pblock_spar15;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001233 } else {
Marcin Slusarz3a71fc52008-02-08 04:20:28 -08001234 udf_debug("Unknown ident: %s\n",
1235 upm2->partIdent.ident);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001236 continue;
1237 }
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001238 map->s_volumeseqnum = le16_to_cpu(upm2->volSeqNum);
1239 map->s_partition_num = le16_to_cpu(upm2->partitionNum);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001240 }
1241 udf_debug("Partition (%d:%d) type %d on volume %d\n",
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001242 i, map->s_partition_num, type,
1243 map->s_volumeseqnum);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001244 }
1245
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001246 if (fileset) {
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001247 long_ad *la = (long_ad *)&(lvd->logicalVolContentsUse[0]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001248
1249 *fileset = lelb_to_cpu(la->extLocation);
Marcin Slusarz3a71fc52008-02-08 04:20:28 -08001250 udf_debug("FileSet found in LogicalVolDesc at block=%d, "
1251 "partition=%d\n", fileset->logicalBlockNum,
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001252 fileset->partitionReferenceNum);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001253 }
1254 if (lvd->integritySeqExt.extLength)
1255 udf_load_logicalvolint(sb, leea_to_cpu(lvd->integritySeqExt));
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001256
Linus Torvalds1da177e2005-04-16 15:20:36 -07001257 return 0;
1258}
1259
1260/*
1261 * udf_load_logicalvolint
1262 *
1263 */
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001264static void udf_load_logicalvolint(struct super_block *sb, kernel_extent_ad loc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001265{
1266 struct buffer_head *bh = NULL;
1267 uint16_t ident;
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001268 struct udf_sb_info *sbi = UDF_SB(sb);
1269 struct logicalVolIntegrityDesc *lvid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001270
1271 while (loc.extLength > 0 &&
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001272 (bh = udf_read_tagged(sb, loc.extLocation,
1273 loc.extLocation, &ident)) &&
1274 ident == TAG_IDENT_LVID) {
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001275 sbi->s_lvid_bh = bh;
1276 lvid = (struct logicalVolIntegrityDesc *)bh->b_data;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001277
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001278 if (lvid->nextIntegrityExt.extLength)
Marcin Slusarz3a71fc52008-02-08 04:20:28 -08001279 udf_load_logicalvolint(sb,
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001280 leea_to_cpu(lvid->nextIntegrityExt));
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001281
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001282 if (sbi->s_lvid_bh != bh)
Jan Kara3bf25cb2007-05-08 00:35:16 -07001283 brelse(bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001284 loc.extLength -= sb->s_blocksize;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001285 loc.extLocation++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001286 }
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001287 if (sbi->s_lvid_bh != bh)
Jan Kara3bf25cb2007-05-08 00:35:16 -07001288 brelse(bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001289}
1290
1291/*
1292 * udf_process_sequence
1293 *
1294 * PURPOSE
1295 * Process a main/reserve volume descriptor sequence.
1296 *
1297 * PRE-CONDITIONS
1298 * sb Pointer to _locked_ superblock.
1299 * block First block of first extent of the sequence.
1300 * lastblock Lastblock of first extent of the sequence.
1301 *
1302 * HISTORY
1303 * July 1, 1997 - Andrew E. Mileski
1304 * Written, tested, and released.
1305 */
Marcin Slusarz3a71fc52008-02-08 04:20:28 -08001306static int udf_process_sequence(struct super_block *sb, long block,
1307 long lastblock, kernel_lb_addr *fileset)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001308{
1309 struct buffer_head *bh = NULL;
1310 struct udf_vds_record vds[VDS_POS_LENGTH];
Marcin Slusarz4b111112008-02-08 04:20:36 -08001311 struct udf_vds_record *curr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001312 struct generic_desc *gd;
1313 struct volDescPtr *vdp;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001314 int done = 0;
1315 int i, j;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001316 uint32_t vdsn;
1317 uint16_t ident;
1318 long next_s = 0, next_e = 0;
1319
1320 memset(vds, 0, sizeof(struct udf_vds_record) * VDS_POS_LENGTH);
1321
1322 /* Read the main descriptor sequence */
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001323 for (; (!done && block <= lastblock); block++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001324
1325 bh = udf_read_tagged(sb, block, block, &ident);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001326 if (!bh)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001327 break;
1328
1329 /* Process each descriptor (ISO 13346 3/8.3-8.4) */
1330 gd = (struct generic_desc *)bh->b_data;
1331 vdsn = le32_to_cpu(gd->volDescSeqNum);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001332 switch (ident) {
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001333 case TAG_IDENT_PVD: /* ISO 13346 3/10.1 */
Marcin Slusarz4b111112008-02-08 04:20:36 -08001334 curr = &vds[VDS_POS_PRIMARY_VOL_DESC];
1335 if (vdsn >= curr->volDescSeqNum) {
1336 curr->volDescSeqNum = vdsn;
1337 curr->block = block;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001338 }
1339 break;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001340 case TAG_IDENT_VDP: /* ISO 13346 3/10.3 */
Marcin Slusarz4b111112008-02-08 04:20:36 -08001341 curr = &vds[VDS_POS_VOL_DESC_PTR];
1342 if (vdsn >= curr->volDescSeqNum) {
1343 curr->volDescSeqNum = vdsn;
1344 curr->block = block;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001345
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001346 vdp = (struct volDescPtr *)bh->b_data;
Marcin Slusarz4b111112008-02-08 04:20:36 -08001347 next_s = le32_to_cpu(
1348 vdp->nextVolDescSeqExt.extLocation);
1349 next_e = le32_to_cpu(
1350 vdp->nextVolDescSeqExt.extLength);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001351 next_e = next_e >> sb->s_blocksize_bits;
1352 next_e += next_s;
1353 }
1354 break;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001355 case TAG_IDENT_IUVD: /* ISO 13346 3/10.4 */
Marcin Slusarz4b111112008-02-08 04:20:36 -08001356 curr = &vds[VDS_POS_IMP_USE_VOL_DESC];
1357 if (vdsn >= curr->volDescSeqNum) {
1358 curr->volDescSeqNum = vdsn;
1359 curr->block = block;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001360 }
1361 break;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001362 case TAG_IDENT_PD: /* ISO 13346 3/10.5 */
Marcin Slusarz4b111112008-02-08 04:20:36 -08001363 curr = &vds[VDS_POS_PARTITION_DESC];
1364 if (!curr->block)
1365 curr->block = block;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001366 break;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001367 case TAG_IDENT_LVD: /* ISO 13346 3/10.6 */
Marcin Slusarz4b111112008-02-08 04:20:36 -08001368 curr = &vds[VDS_POS_LOGICAL_VOL_DESC];
1369 if (vdsn >= curr->volDescSeqNum) {
1370 curr->volDescSeqNum = vdsn;
1371 curr->block = block;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001372 }
1373 break;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001374 case TAG_IDENT_USD: /* ISO 13346 3/10.8 */
Marcin Slusarz4b111112008-02-08 04:20:36 -08001375 curr = &vds[VDS_POS_UNALLOC_SPACE_DESC];
1376 if (vdsn >= curr->volDescSeqNum) {
1377 curr->volDescSeqNum = vdsn;
1378 curr->block = block;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001379 }
1380 break;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001381 case TAG_IDENT_TD: /* ISO 13346 3/10.9 */
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001382 vds[VDS_POS_TERMINATING_DESC].block = block;
1383 if (next_e) {
1384 block = next_s;
1385 lastblock = next_e;
1386 next_s = next_e = 0;
Marcin Slusarz4b111112008-02-08 04:20:36 -08001387 } else
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001388 done = 1;
1389 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001390 }
Jan Kara3bf25cb2007-05-08 00:35:16 -07001391 brelse(bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001392 }
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001393 for (i = 0; i < VDS_POS_LENGTH; i++) {
1394 if (vds[i].block) {
Marcin Slusarz3a71fc52008-02-08 04:20:28 -08001395 bh = udf_read_tagged(sb, vds[i].block, vds[i].block,
1396 &ident);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001397
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001398 if (i == VDS_POS_PRIMARY_VOL_DESC) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001399 udf_load_pvoldesc(sb, bh);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001400 } else if (i == VDS_POS_LOGICAL_VOL_DESC) {
Marcin Slusarzdeae6cf2008-02-08 04:20:33 -08001401 if (udf_load_logicalvol(sb, bh, fileset)) {
1402 brelse(bh);
1403 return 1;
1404 }
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001405 } else if (i == VDS_POS_PARTITION_DESC) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001406 struct buffer_head *bh2 = NULL;
Jan Karabcec4472007-08-30 23:56:22 -07001407 if (udf_load_partdesc(sb, bh)) {
1408 brelse(bh);
1409 return 1;
1410 }
Marcin Slusarz3a71fc52008-02-08 04:20:28 -08001411 for (j = vds[i].block + 1;
1412 j < vds[VDS_POS_TERMINATING_DESC].block;
1413 j++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001414 bh2 = udf_read_tagged(sb, j, j, &ident);
1415 gd = (struct generic_desc *)bh2->b_data;
1416 if (ident == TAG_IDENT_PD)
Marcin Slusarz3a71fc52008-02-08 04:20:28 -08001417 if (udf_load_partdesc(sb,
1418 bh2)) {
Jan Karabcec4472007-08-30 23:56:22 -07001419 brelse(bh);
1420 brelse(bh2);
1421 return 1;
1422 }
Jan Kara3bf25cb2007-05-08 00:35:16 -07001423 brelse(bh2);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001424 }
1425 }
Jan Kara3bf25cb2007-05-08 00:35:16 -07001426 brelse(bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001427 }
1428 }
1429
1430 return 0;
1431}
1432
1433/*
1434 * udf_check_valid()
1435 */
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001436static int udf_check_valid(struct super_block *sb, int novrs, int silent)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001437{
1438 long block;
1439
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001440 if (novrs) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001441 udf_debug("Validity check skipped because of novrs option\n");
1442 return 0;
1443 }
1444 /* Check that it is NSR02 compliant */
1445 /* Process any "CD-ROM Volume Descriptor Set" (ECMA 167 2/8.3.1) */
Marcin Slusarz3a71fc52008-02-08 04:20:28 -08001446 else {
1447 block = udf_vrs(sb, silent);
1448 if (block == -1) {
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001449 struct udf_sb_info *sbi = UDF_SB(sb);
Marcin Slusarz3a71fc52008-02-08 04:20:28 -08001450 udf_debug("Failed to read byte 32768. Assuming open "
1451 "disc. Skipping validity check\n");
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001452 if (!sbi->s_last_block)
1453 sbi->s_last_block = udf_get_last_block(sb);
Marcin Slusarz3a71fc52008-02-08 04:20:28 -08001454 return 0;
1455 } else
1456 return !block;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001457 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001458}
1459
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001460static int udf_load_partition(struct super_block *sb, kernel_lb_addr *fileset)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001461{
1462 struct anchorVolDescPtr *anchor;
1463 uint16_t ident;
1464 struct buffer_head *bh;
1465 long main_s, main_e, reserve_s, reserve_e;
1466 int i, j;
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001467 struct udf_sb_info *sbi;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001468
1469 if (!sb)
1470 return 1;
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001471 sbi = UDF_SB(sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001472
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001473 for (i = 0; i < ARRAY_SIZE(sbi->s_anchor); i++) {
Marcin Slusarz28f7c4d2008-02-08 04:20:46 -08001474 if (!sbi->s_anchor[i])
1475 continue;
1476 bh = udf_read_tagged(sb, sbi->s_anchor[i], sbi->s_anchor[i],
1477 &ident);
1478 if (!bh)
1479 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001480
Marcin Slusarz28f7c4d2008-02-08 04:20:46 -08001481 anchor = (struct anchorVolDescPtr *)bh->b_data;
Tobias Klausere8c96f82006-03-24 03:15:34 -08001482
Marcin Slusarz28f7c4d2008-02-08 04:20:46 -08001483 /* Locate the main sequence */
1484 main_s = le32_to_cpu(anchor->mainVolDescSeqExt.extLocation);
1485 main_e = le32_to_cpu(anchor->mainVolDescSeqExt.extLength);
1486 main_e = main_e >> sb->s_blocksize_bits;
1487 main_e += main_s;
1488
1489 /* Locate the reserve sequence */
1490 reserve_s = le32_to_cpu(
Marcin Slusarz4b111112008-02-08 04:20:36 -08001491 anchor->reserveVolDescSeqExt.extLocation);
Marcin Slusarz28f7c4d2008-02-08 04:20:46 -08001492 reserve_e = le32_to_cpu(
Marcin Slusarz4b111112008-02-08 04:20:36 -08001493 anchor->reserveVolDescSeqExt.extLength);
Marcin Slusarz28f7c4d2008-02-08 04:20:46 -08001494 reserve_e = reserve_e >> sb->s_blocksize_bits;
1495 reserve_e += reserve_s;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001496
Marcin Slusarz28f7c4d2008-02-08 04:20:46 -08001497 brelse(bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001498
Marcin Slusarz28f7c4d2008-02-08 04:20:46 -08001499 /* Process the main & reserve sequences */
1500 /* responsible for finding the PartitionDesc(s) */
1501 if (!(udf_process_sequence(sb, main_s, main_e,
1502 fileset) &&
1503 udf_process_sequence(sb, reserve_s, reserve_e,
1504 fileset)))
1505 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001506 }
1507
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001508 if (i == ARRAY_SIZE(sbi->s_anchor)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001509 udf_debug("No Anchor block found\n");
1510 return 1;
Marcin Slusarz28f7c4d2008-02-08 04:20:46 -08001511 }
1512 udf_debug("Using anchor in block %d\n", sbi->s_anchor[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001513
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001514 for (i = 0; i < sbi->s_partitions; i++) {
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001515 kernel_lb_addr uninitialized_var(ino);
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001516 struct udf_part_map *map = &sbi->s_partmaps[i];
1517 switch (map->s_partition_type) {
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001518 case UDF_VIRTUAL_MAP15:
1519 case UDF_VIRTUAL_MAP20:
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001520 if (!sbi->s_last_block) {
1521 sbi->s_last_block = udf_get_last_block(sb);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001522 udf_find_anchor(sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001523 }
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001524
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001525 if (!sbi->s_last_block) {
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001526 udf_debug("Unable to determine Lastblock (For "
Cyrill Gorcunovb1e7a4b12007-10-16 23:30:08 -07001527 "Virtual Partition)\n");
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001528 return 1;
1529 }
1530
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001531 for (j = 0; j < sbi->s_partitions; j++) {
1532 struct udf_part_map *map2 = &sbi->s_partmaps[j];
Cyrill Gorcunovb1e7a4b12007-10-16 23:30:08 -07001533 if (j != i &&
Marcin Slusarz4b111112008-02-08 04:20:36 -08001534 map->s_volumeseqnum ==
1535 map2->s_volumeseqnum &&
1536 map->s_partition_num ==
1537 map2->s_partition_num) {
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001538 ino.partitionReferenceNum = j;
Marcin Slusarz4b111112008-02-08 04:20:36 -08001539 ino.logicalBlockNum =
1540 sbi->s_last_block -
1541 map2->s_partition_root;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001542 break;
1543 }
1544 }
1545
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001546 if (j == sbi->s_partitions)
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001547 return 1;
1548
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001549 sbi->s_vat_inode = udf_iget(sb, ino);
1550 if (!sbi->s_vat_inode)
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001551 return 1;
1552
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001553 if (map->s_partition_type == UDF_VIRTUAL_MAP15) {
1554 map->s_type_specific.s_virtual.s_start_offset =
1555 udf_ext0_offset(sbi->s_vat_inode);
1556 map->s_type_specific.s_virtual.s_num_entries =
1557 (sbi->s_vat_inode->i_size - 36) >> 2;
1558 } else if (map->s_partition_type == UDF_VIRTUAL_MAP20) {
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001559 uint32_t pos;
Marcin Slusarz4b111112008-02-08 04:20:36 -08001560 struct virtualAllocationTable20 *vat20;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001561
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001562 pos = udf_block_map(sbi->s_vat_inode, 0);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001563 bh = sb_bread(sb, pos);
1564 if (!bh)
1565 return 1;
Marcin Slusarz4b111112008-02-08 04:20:36 -08001566 vat20 = (struct virtualAllocationTable20 *)
1567 bh->b_data +
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001568 udf_ext0_offset(sbi->s_vat_inode);
Marcin Slusarz4b111112008-02-08 04:20:36 -08001569 map->s_type_specific.s_virtual.s_start_offset =
1570 le16_to_cpu(vat20->lengthHeader) +
1571 udf_ext0_offset(sbi->s_vat_inode);
1572 map->s_type_specific.s_virtual.s_num_entries =
1573 (sbi->s_vat_inode->i_size -
1574 map->s_type_specific.s_virtual.
1575 s_start_offset) >> 2;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001576 brelse(bh);
1577 }
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001578 map->s_partition_root = udf_get_pblock(sb, 0, i, 0);
1579 map->s_partition_len =
1580 sbi->s_partmaps[ino.partitionReferenceNum].
1581 s_partition_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001582 }
1583 }
1584 return 0;
1585}
1586
1587static void udf_open_lvid(struct super_block *sb)
1588{
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001589 struct udf_sb_info *sbi = UDF_SB(sb);
1590 struct buffer_head *bh = sbi->s_lvid_bh;
1591 if (bh) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001592 kernel_timestamp cpu_time;
Marcin Slusarz4b111112008-02-08 04:20:36 -08001593 struct logicalVolIntegrityDesc *lvid =
1594 (struct logicalVolIntegrityDesc *)bh->b_data;
1595 struct logicalVolIntegrityDescImpUse *lvidiu =
1596 udf_sb_lvidiu(sbi);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001597
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001598 lvidiu->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX;
1599 lvidiu->impIdent.identSuffix[1] = UDF_OS_ID_LINUX;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001600 if (udf_time_to_stamp(&cpu_time, CURRENT_TIME))
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001601 lvid->recordingDateAndTime = cpu_to_lets(cpu_time);
1602 lvid->integrityType = LVID_INTEGRITY_TYPE_OPEN;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001603
Marcin Slusarz4b111112008-02-08 04:20:36 -08001604 lvid->descTag.descCRC = cpu_to_le16(
1605 udf_crc((char *)lvid + sizeof(tag),
1606 le16_to_cpu(lvid->descTag.descCRCLength),
1607 0));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001608
Marcin Slusarz3f2587b2008-02-08 04:20:39 -08001609 lvid->descTag.tagChecksum = udf_tag_checksum(&lvid->descTag);
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001610 mark_buffer_dirty(bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001611 }
1612}
1613
1614static void udf_close_lvid(struct super_block *sb)
1615{
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001616 kernel_timestamp cpu_time;
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001617 struct udf_sb_info *sbi = UDF_SB(sb);
1618 struct buffer_head *bh = sbi->s_lvid_bh;
1619 struct logicalVolIntegrityDesc *lvid;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001620
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001621 if (!bh)
1622 return;
1623
1624 lvid = (struct logicalVolIntegrityDesc *)bh->b_data;
1625
1626 if (lvid->integrityType == LVID_INTEGRITY_TYPE_OPEN) {
Marcin Slusarz4b111112008-02-08 04:20:36 -08001627 struct logicalVolIntegrityDescImpUse *lvidiu =
1628 udf_sb_lvidiu(sbi);
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001629 lvidiu->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX;
1630 lvidiu->impIdent.identSuffix[1] = UDF_OS_ID_LINUX;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001631 if (udf_time_to_stamp(&cpu_time, CURRENT_TIME))
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001632 lvid->recordingDateAndTime = cpu_to_lets(cpu_time);
1633 if (UDF_MAX_WRITE_VERSION > le16_to_cpu(lvidiu->maxUDFWriteRev))
Marcin Slusarz4b111112008-02-08 04:20:36 -08001634 lvidiu->maxUDFWriteRev =
1635 cpu_to_le16(UDF_MAX_WRITE_VERSION);
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001636 if (sbi->s_udfrev > le16_to_cpu(lvidiu->minUDFReadRev))
1637 lvidiu->minUDFReadRev = cpu_to_le16(sbi->s_udfrev);
1638 if (sbi->s_udfrev > le16_to_cpu(lvidiu->minUDFWriteRev))
1639 lvidiu->minUDFWriteRev = cpu_to_le16(sbi->s_udfrev);
1640 lvid->integrityType = cpu_to_le32(LVID_INTEGRITY_TYPE_CLOSE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001641
Marcin Slusarz4b111112008-02-08 04:20:36 -08001642 lvid->descTag.descCRC = cpu_to_le16(
1643 udf_crc((char *)lvid + sizeof(tag),
1644 le16_to_cpu(lvid->descTag.descCRCLength),
1645 0));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001646
Marcin Slusarz3f2587b2008-02-08 04:20:39 -08001647 lvid->descTag.tagChecksum = udf_tag_checksum(&lvid->descTag);
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001648 mark_buffer_dirty(bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001649 }
1650}
1651
Marcin Slusarz66e1da32008-02-08 04:20:33 -08001652static void udf_sb_free_bitmap(struct udf_bitmap *bitmap)
1653{
1654 int i;
1655 int nr_groups = bitmap->s_nr_groups;
Marcin Slusarz4b111112008-02-08 04:20:36 -08001656 int size = sizeof(struct udf_bitmap) + (sizeof(struct buffer_head *) *
1657 nr_groups);
Marcin Slusarz66e1da32008-02-08 04:20:33 -08001658
1659 for (i = 0; i < nr_groups; i++)
1660 if (bitmap->s_block_bitmap[i])
1661 brelse(bitmap->s_block_bitmap[i]);
1662
1663 if (size <= PAGE_SIZE)
1664 kfree(bitmap);
1665 else
1666 vfree(bitmap);
1667}
1668
Linus Torvalds1da177e2005-04-16 15:20:36 -07001669static int udf_fill_super(struct super_block *sb, void *options, int silent)
1670{
1671 int i;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001672 struct inode *inode = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001673 struct udf_options uopt;
1674 kernel_lb_addr rootdir, fileset;
1675 struct udf_sb_info *sbi;
1676
1677 uopt.flags = (1 << UDF_FLAG_USE_AD_IN_ICB) | (1 << UDF_FLAG_STRICT);
1678 uopt.uid = -1;
1679 uopt.gid = -1;
1680 uopt.umask = 0;
1681
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001682 sbi = kzalloc(sizeof(struct udf_sb_info), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001683 if (!sbi)
1684 return -ENOMEM;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001685
Linus Torvalds1da177e2005-04-16 15:20:36 -07001686 sb->s_fs_info = sbi;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001687
Ingo Molnar1e7933d2006-03-23 03:00:44 -08001688 mutex_init(&sbi->s_alloc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001689
Miklos Szeredi6da80892008-02-08 04:21:50 -08001690 if (!udf_parse_options((char *)options, &uopt, false))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001691 goto error_out;
1692
1693 if (uopt.flags & (1 << UDF_FLAG_UTF8) &&
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001694 uopt.flags & (1 << UDF_FLAG_NLS_MAP)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001695 udf_error(sb, "udf_read_super",
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001696 "utf8 cannot be combined with iocharset\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001697 goto error_out;
1698 }
1699#ifdef CONFIG_UDF_NLS
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001700 if ((uopt.flags & (1 << UDF_FLAG_NLS_MAP)) && !uopt.nls_map) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001701 uopt.nls_map = load_nls_default();
1702 if (!uopt.nls_map)
1703 uopt.flags &= ~(1 << UDF_FLAG_NLS_MAP);
1704 else
1705 udf_debug("Using default NLS map\n");
1706 }
1707#endif
1708 if (!(uopt.flags & (1 << UDF_FLAG_NLS_MAP)))
1709 uopt.flags |= (1 << UDF_FLAG_UTF8);
1710
1711 fileset.logicalBlockNum = 0xFFFFFFFF;
1712 fileset.partitionReferenceNum = 0xFFFF;
1713
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001714 sbi->s_flags = uopt.flags;
1715 sbi->s_uid = uopt.uid;
1716 sbi->s_gid = uopt.gid;
1717 sbi->s_umask = uopt.umask;
1718 sbi->s_nls_map = uopt.nls_map;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001719
1720 /* Set the block size for all transfers */
Christoph Hellwigf1f73ba82008-02-22 12:38:02 +01001721 if (!sb_min_blocksize(sb, uopt.blocksize)) {
1722 udf_debug("Bad block size (%d)\n", uopt.blocksize);
1723 printk(KERN_ERR "udf: bad block size (%d)\n", uopt.blocksize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001724 goto error_out;
Christoph Hellwigf1f73ba82008-02-22 12:38:02 +01001725 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001726
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001727 if (uopt.session == 0xFFFFFFFF)
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001728 sbi->s_session = udf_get_last_session(sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001729 else
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001730 sbi->s_session = uopt.session;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001731
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001732 udf_debug("Multi-session=%d\n", sbi->s_session);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001733
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001734 sbi->s_last_block = uopt.lastblock;
1735 sbi->s_anchor[0] = sbi->s_anchor[1] = 0;
1736 sbi->s_anchor[2] = uopt.anchor;
1737 sbi->s_anchor[3] = 256;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001738
Marcin Slusarz3a71fc52008-02-08 04:20:28 -08001739 if (udf_check_valid(sb, uopt.novrs, silent)) {
1740 /* read volume recognition sequences */
1741 printk(KERN_WARNING "UDF-fs: No VRS found\n");
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001742 goto error_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001743 }
1744
1745 udf_find_anchor(sb);
1746
1747 /* Fill in the rest of the superblock */
1748 sb->s_op = &udf_sb_ops;
1749 sb->dq_op = NULL;
1750 sb->s_dirt = 0;
1751 sb->s_magic = UDF_SUPER_MAGIC;
1752 sb->s_time_gran = 1000;
1753
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001754 if (udf_load_partition(sb, &fileset)) {
Marcin Slusarz3a71fc52008-02-08 04:20:28 -08001755 printk(KERN_WARNING "UDF-fs: No partition found (1)\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001756 goto error_out;
1757 }
1758
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001759 udf_debug("Lastblock=%d\n", sbi->s_last_block);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001760
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001761 if (sbi->s_lvid_bh) {
Marcin Slusarz4b111112008-02-08 04:20:36 -08001762 struct logicalVolIntegrityDescImpUse *lvidiu =
1763 udf_sb_lvidiu(sbi);
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001764 uint16_t minUDFReadRev = le16_to_cpu(lvidiu->minUDFReadRev);
1765 uint16_t minUDFWriteRev = le16_to_cpu(lvidiu->minUDFWriteRev);
Marcin Slusarz4b111112008-02-08 04:20:36 -08001766 /* uint16_t maxUDFWriteRev =
1767 le16_to_cpu(lvidiu->maxUDFWriteRev); */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001768
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001769 if (minUDFReadRev > UDF_MAX_READ_VERSION) {
Marcin Slusarz4b111112008-02-08 04:20:36 -08001770 printk(KERN_ERR "UDF-fs: minUDFReadRev=%x "
1771 "(max is %x)\n",
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001772 le16_to_cpu(lvidiu->minUDFReadRev),
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001773 UDF_MAX_READ_VERSION);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001774 goto error_out;
Marcin Slusarz4b111112008-02-08 04:20:36 -08001775 } else if (minUDFWriteRev > UDF_MAX_WRITE_VERSION)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001776 sb->s_flags |= MS_RDONLY;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001777
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001778 sbi->s_udfrev = minUDFWriteRev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001779
1780 if (minUDFReadRev >= UDF_VERS_USE_EXTENDED_FE)
1781 UDF_SET_FLAG(sb, UDF_FLAG_USE_EXTENDED_FE);
1782 if (minUDFReadRev >= UDF_VERS_USE_STREAMS)
1783 UDF_SET_FLAG(sb, UDF_FLAG_USE_STREAMS);
1784 }
1785
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001786 if (!sbi->s_partitions) {
Marcin Slusarz3a71fc52008-02-08 04:20:28 -08001787 printk(KERN_WARNING "UDF-fs: No partition found (2)\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001788 goto error_out;
1789 }
1790
Marcin Slusarz4b111112008-02-08 04:20:36 -08001791 if (sbi->s_partmaps[sbi->s_partition].s_partition_flags &
1792 UDF_PART_FLAG_READ_ONLY) {
1793 printk(KERN_NOTICE "UDF-fs: Partition marked readonly; "
1794 "forcing readonly mount\n");
Eric Sandeen39b3f6d2006-09-29 01:59:41 -07001795 sb->s_flags |= MS_RDONLY;
Peter Osterlundc1a26e72006-10-05 21:17:50 +02001796 }
Eric Sandeen39b3f6d2006-09-29 01:59:41 -07001797
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001798 if (udf_find_fileset(sb, &fileset, &rootdir)) {
Marcin Slusarz3a71fc52008-02-08 04:20:28 -08001799 printk(KERN_WARNING "UDF-fs: No fileset found\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001800 goto error_out;
1801 }
1802
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001803 if (!silent) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001804 kernel_timestamp ts;
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001805 udf_time_to_stamp(&ts, sbi->s_record_time);
Adrian Bunka9ca6632008-02-08 04:20:47 -08001806 udf_info("UDF: Mounting volume '%s', "
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001807 "timestamp %04u/%02u/%02u %02u:%02u (%x)\n",
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001808 sbi->s_volume_ident, ts.year, ts.month, ts.day,
1809 ts.hour, ts.minute, ts.typeAndTimezone);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001810 }
1811 if (!(sb->s_flags & MS_RDONLY))
1812 udf_open_lvid(sb);
1813
1814 /* Assign the root inode */
1815 /* assign inodes by physical block number */
1816 /* perhaps it's not extensible enough, but for now ... */
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001817 inode = udf_iget(sb, rootdir);
1818 if (!inode) {
Marcin Slusarz4b111112008-02-08 04:20:36 -08001819 printk(KERN_ERR "UDF-fs: Error in udf_iget, block=%d, "
1820 "partition=%d\n",
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001821 rootdir.logicalBlockNum, rootdir.partitionReferenceNum);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001822 goto error_out;
1823 }
1824
1825 /* Allocate a dentry for the root inode */
1826 sb->s_root = d_alloc_root(inode);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001827 if (!sb->s_root) {
Marcin Slusarz3a71fc52008-02-08 04:20:28 -08001828 printk(KERN_ERR "UDF-fs: Couldn't allocate root dentry\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001829 iput(inode);
1830 goto error_out;
1831 }
Jan Kara31170b62007-05-08 00:35:21 -07001832 sb->s_maxbytes = MAX_LFS_FILESIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001833 return 0;
1834
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001835error_out:
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001836 if (sbi->s_vat_inode)
1837 iput(sbi->s_vat_inode);
1838 if (sbi->s_partitions) {
1839 struct udf_part_map *map = &sbi->s_partmaps[sbi->s_partition];
1840 if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_TABLE)
1841 iput(map->s_uspace.s_table);
1842 if (map->s_partition_flags & UDF_PART_FLAG_FREED_TABLE)
1843 iput(map->s_fspace.s_table);
1844 if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_BITMAP)
Marcin Slusarz66e1da32008-02-08 04:20:33 -08001845 udf_sb_free_bitmap(map->s_uspace.s_bitmap);
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001846 if (map->s_partition_flags & UDF_PART_FLAG_FREED_BITMAP)
Marcin Slusarz66e1da32008-02-08 04:20:33 -08001847 udf_sb_free_bitmap(map->s_fspace.s_bitmap);
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001848 if (map->s_partition_type == UDF_SPARABLE_MAP15)
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001849 for (i = 0; i < 4; i++)
Marcin Slusarz4b111112008-02-08 04:20:36 -08001850 brelse(map->s_type_specific.s_sparing.
1851 s_spar_map[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001852 }
1853#ifdef CONFIG_UDF_NLS
1854 if (UDF_QUERY_FLAG(sb, UDF_FLAG_NLS_MAP))
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001855 unload_nls(sbi->s_nls_map);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001856#endif
1857 if (!(sb->s_flags & MS_RDONLY))
1858 udf_close_lvid(sb);
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001859 brelse(sbi->s_lvid_bh);
1860
1861 kfree(sbi->s_partmaps);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001862 kfree(sbi);
1863 sb->s_fs_info = NULL;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001864
Linus Torvalds1da177e2005-04-16 15:20:36 -07001865 return -EINVAL;
1866}
1867
Adrian Bunkb8145a72008-02-17 10:19:55 +02001868static void udf_error(struct super_block *sb, const char *function,
1869 const char *fmt, ...)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001870{
1871 va_list args;
1872
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001873 if (!(sb->s_flags & MS_RDONLY)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001874 /* mark sb error */
1875 sb->s_dirt = 1;
1876 }
1877 va_start(args, fmt);
Alexey Dobriyan4a6e6172006-12-06 20:37:04 -08001878 vsnprintf(error_buf, sizeof(error_buf), fmt, args);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001879 va_end(args);
Marcin Slusarz3a71fc52008-02-08 04:20:28 -08001880 printk(KERN_CRIT "UDF-fs error (device %s): %s: %s\n",
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001881 sb->s_id, function, error_buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001882}
1883
1884void udf_warning(struct super_block *sb, const char *function,
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001885 const char *fmt, ...)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001886{
1887 va_list args;
1888
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001889 va_start(args, fmt);
Alexey Dobriyan4a6e6172006-12-06 20:37:04 -08001890 vsnprintf(error_buf, sizeof(error_buf), fmt, args);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001891 va_end(args);
1892 printk(KERN_WARNING "UDF-fs warning (device %s): %s: %s\n",
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001893 sb->s_id, function, error_buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001894}
1895
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001896static void udf_put_super(struct super_block *sb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001897{
1898 int i;
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001899 struct udf_sb_info *sbi;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001900
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001901 sbi = UDF_SB(sb);
1902 if (sbi->s_vat_inode)
1903 iput(sbi->s_vat_inode);
1904 if (sbi->s_partitions) {
1905 struct udf_part_map *map = &sbi->s_partmaps[sbi->s_partition];
1906 if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_TABLE)
1907 iput(map->s_uspace.s_table);
1908 if (map->s_partition_flags & UDF_PART_FLAG_FREED_TABLE)
1909 iput(map->s_fspace.s_table);
1910 if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_BITMAP)
Marcin Slusarz66e1da32008-02-08 04:20:33 -08001911 udf_sb_free_bitmap(map->s_uspace.s_bitmap);
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001912 if (map->s_partition_flags & UDF_PART_FLAG_FREED_BITMAP)
Marcin Slusarz66e1da32008-02-08 04:20:33 -08001913 udf_sb_free_bitmap(map->s_fspace.s_bitmap);
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001914 if (map->s_partition_type == UDF_SPARABLE_MAP15)
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001915 for (i = 0; i < 4; i++)
Marcin Slusarz4b111112008-02-08 04:20:36 -08001916 brelse(map->s_type_specific.s_sparing.
1917 s_spar_map[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001918 }
1919#ifdef CONFIG_UDF_NLS
1920 if (UDF_QUERY_FLAG(sb, UDF_FLAG_NLS_MAP))
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001921 unload_nls(sbi->s_nls_map);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001922#endif
1923 if (!(sb->s_flags & MS_RDONLY))
1924 udf_close_lvid(sb);
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001925 brelse(sbi->s_lvid_bh);
1926 kfree(sbi->s_partmaps);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001927 kfree(sb->s_fs_info);
1928 sb->s_fs_info = NULL;
1929}
1930
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001931static int udf_statfs(struct dentry *dentry, struct kstatfs *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001932{
David Howells726c3342006-06-23 02:02:58 -07001933 struct super_block *sb = dentry->d_sb;
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001934 struct udf_sb_info *sbi = UDF_SB(sb);
1935 struct logicalVolIntegrityDescImpUse *lvidiu;
1936
1937 if (sbi->s_lvid_bh != NULL)
1938 lvidiu = udf_sb_lvidiu(sbi);
1939 else
1940 lvidiu = NULL;
David Howells726c3342006-06-23 02:02:58 -07001941
Linus Torvalds1da177e2005-04-16 15:20:36 -07001942 buf->f_type = UDF_SUPER_MAGIC;
1943 buf->f_bsize = sb->s_blocksize;
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001944 buf->f_blocks = sbi->s_partmaps[sbi->s_partition].s_partition_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001945 buf->f_bfree = udf_count_free(sb);
1946 buf->f_bavail = buf->f_bfree;
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001947 buf->f_files = (lvidiu != NULL ? (le32_to_cpu(lvidiu->numFiles) +
1948 le32_to_cpu(lvidiu->numDirs)) : 0)
1949 + buf->f_bfree;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001950 buf->f_ffree = buf->f_bfree;
1951 /* __kernel_fsid_t f_fsid */
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001952 buf->f_namelen = UDF_NAME_LEN - 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001953
1954 return 0;
1955}
1956
Marcin Slusarz4b111112008-02-08 04:20:36 -08001957static unsigned int udf_count_free_bitmap(struct super_block *sb,
1958 struct udf_bitmap *bitmap)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001959{
1960 struct buffer_head *bh = NULL;
1961 unsigned int accum = 0;
1962 int index;
1963 int block = 0, newblock;
1964 kernel_lb_addr loc;
1965 uint32_t bytes;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001966 uint8_t *ptr;
1967 uint16_t ident;
1968 struct spaceBitmapDesc *bm;
1969
1970 lock_kernel();
1971
1972 loc.logicalBlockNum = bitmap->s_extPosition;
Marcin Slusarz6c79e982008-02-08 04:20:30 -08001973 loc.partitionReferenceNum = UDF_SB(sb)->s_partition;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001974 bh = udf_read_ptagged(sb, loc, 0, &ident);
1975
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001976 if (!bh) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001977 printk(KERN_ERR "udf: udf_count_free failed\n");
1978 goto out;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001979 } else if (ident != TAG_IDENT_SBD) {
Jan Kara3bf25cb2007-05-08 00:35:16 -07001980 brelse(bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001981 printk(KERN_ERR "udf: udf_count_free failed\n");
1982 goto out;
1983 }
1984
1985 bm = (struct spaceBitmapDesc *)bh->b_data;
1986 bytes = le32_to_cpu(bm->numOfBytes);
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07001987 index = sizeof(struct spaceBitmapDesc); /* offset in first block only */
1988 ptr = (uint8_t *)bh->b_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001989
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001990 while (bytes > 0) {
Marcin Slusarz01b954a2008-02-02 22:37:07 +01001991 u32 cur_bytes = min_t(u32, bytes, sb->s_blocksize - index);
1992 accum += bitmap_weight((const unsigned long *)(ptr + index),
1993 cur_bytes * 8);
1994 bytes -= cur_bytes;
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001995 if (bytes) {
Jan Kara3bf25cb2007-05-08 00:35:16 -07001996 brelse(bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001997 newblock = udf_get_lb_pblock(sb, loc, ++block);
1998 bh = udf_tread(sb, newblock);
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07001999 if (!bh) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002000 udf_debug("read failed\n");
2001 goto out;
2002 }
2003 index = 0;
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07002004 ptr = (uint8_t *)bh->b_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002005 }
2006 }
Jan Kara3bf25cb2007-05-08 00:35:16 -07002007 brelse(bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002008
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07002009out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002010 unlock_kernel();
2011
2012 return accum;
2013}
2014
Marcin Slusarz4b111112008-02-08 04:20:36 -08002015static unsigned int udf_count_free_table(struct super_block *sb,
2016 struct inode *table)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002017{
2018 unsigned int accum = 0;
Jan Karaff116fc2007-05-08 00:35:14 -07002019 uint32_t elen;
2020 kernel_lb_addr eloc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002021 int8_t etype;
Jan Karaff116fc2007-05-08 00:35:14 -07002022 struct extent_position epos;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002023
2024 lock_kernel();
2025
Marcin Slusarzc0b34432008-02-08 04:20:42 -08002026 epos.block = UDF_I(table)->i_location;
Jan Karaff116fc2007-05-08 00:35:14 -07002027 epos.offset = sizeof(struct unallocSpaceEntry);
2028 epos.bh = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002029
Marcin Slusarz3a71fc52008-02-08 04:20:28 -08002030 while ((etype = udf_next_aext(table, &epos, &eloc, &elen, 1)) != -1)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002031 accum += (elen >> table->i_sb->s_blocksize_bits);
Marcin Slusarz3a71fc52008-02-08 04:20:28 -08002032
Jan Kara3bf25cb2007-05-08 00:35:16 -07002033 brelse(epos.bh);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002034
2035 unlock_kernel();
2036
2037 return accum;
2038}
Cyrill Gorcunovcb00ea32007-07-19 01:47:43 -07002039
2040static unsigned int udf_count_free(struct super_block *sb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002041{
2042 unsigned int accum = 0;
Marcin Slusarz6c79e982008-02-08 04:20:30 -08002043 struct udf_sb_info *sbi;
2044 struct udf_part_map *map;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002045
Marcin Slusarz6c79e982008-02-08 04:20:30 -08002046 sbi = UDF_SB(sb);
2047 if (sbi->s_lvid_bh) {
Marcin Slusarz4b111112008-02-08 04:20:36 -08002048 struct logicalVolIntegrityDesc *lvid =
2049 (struct logicalVolIntegrityDesc *)
2050 sbi->s_lvid_bh->b_data;
Marcin Slusarz6c79e982008-02-08 04:20:30 -08002051 if (le32_to_cpu(lvid->numOfPartitions) > sbi->s_partition) {
Marcin Slusarz4b111112008-02-08 04:20:36 -08002052 accum = le32_to_cpu(
2053 lvid->freeSpaceTable[sbi->s_partition]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002054 if (accum == 0xFFFFFFFF)
2055 accum = 0;
2056 }
2057 }
2058
2059 if (accum)
2060 return accum;
2061
Marcin Slusarz6c79e982008-02-08 04:20:30 -08002062 map = &sbi->s_partmaps[sbi->s_partition];
2063 if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_BITMAP) {
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07002064 accum += udf_count_free_bitmap(sb,
Marcin Slusarz6c79e982008-02-08 04:20:30 -08002065 map->s_uspace.s_bitmap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002066 }
Marcin Slusarz6c79e982008-02-08 04:20:30 -08002067 if (map->s_partition_flags & UDF_PART_FLAG_FREED_BITMAP) {
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07002068 accum += udf_count_free_bitmap(sb,
Marcin Slusarz6c79e982008-02-08 04:20:30 -08002069 map->s_fspace.s_bitmap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002070 }
2071 if (accum)
2072 return accum;
2073
Marcin Slusarz6c79e982008-02-08 04:20:30 -08002074 if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_TABLE) {
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07002075 accum += udf_count_free_table(sb,
Marcin Slusarz6c79e982008-02-08 04:20:30 -08002076 map->s_uspace.s_table);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002077 }
Marcin Slusarz6c79e982008-02-08 04:20:30 -08002078 if (map->s_partition_flags & UDF_PART_FLAG_FREED_TABLE) {
Cyrill Gorcunov28de7942007-07-21 04:37:18 -07002079 accum += udf_count_free_table(sb,
Marcin Slusarz6c79e982008-02-08 04:20:30 -08002080 map->s_fspace.s_table);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002081 }
2082
2083 return accum;
2084}