Root/fs/hfs/mdb.c

1/*
2 * linux/fs/hfs/mdb.c
3 *
4 * Copyright (C) 1995-1997 Paul H. Hargrove
5 * (C) 2003 Ardis Technologies <roman@ardistech.com>
6 * This file may be distributed under the terms of the GNU General Public License.
7 *
8 * This file contains functions for reading/writing the MDB.
9 */
10
11#include <linux/cdrom.h>
12#include <linux/genhd.h>
13#include <linux/nls.h>
14#include <linux/slab.h>
15
16#include "hfs_fs.h"
17#include "btree.h"
18
19/*================ File-local data types ================*/
20
21/*
22 * The HFS Master Directory Block (MDB).
23 *
24 * Also known as the Volume Information Block (VIB), this structure is
25 * the HFS equivalent of a superblock.
26 *
27 * Reference: _Inside Macintosh: Files_ pages 2-59 through 2-62
28 *
29 * modified for HFS Extended
30 */
31
32static int hfs_get_last_session(struct super_block *sb,
33                sector_t *start, sector_t *size)
34{
35    struct cdrom_multisession ms_info;
36    struct cdrom_tocentry te;
37    int res;
38
39    /* default values */
40    *start = 0;
41    *size = sb->s_bdev->bd_inode->i_size >> 9;
42
43    if (HFS_SB(sb)->session >= 0) {
44        te.cdte_track = HFS_SB(sb)->session;
45        te.cdte_format = CDROM_LBA;
46        res = ioctl_by_bdev(sb->s_bdev, CDROMREADTOCENTRY, (unsigned long)&te);
47        if (!res && (te.cdte_ctrl & CDROM_DATA_TRACK) == 4) {
48            *start = (sector_t)te.cdte_addr.lba << 2;
49            return 0;
50        }
51        printk(KERN_ERR "hfs: invalid session number or type of track\n");
52        return -EINVAL;
53    }
54    ms_info.addr_format = CDROM_LBA;
55    res = ioctl_by_bdev(sb->s_bdev, CDROMMULTISESSION, (unsigned long)&ms_info);
56    if (!res && ms_info.xa_flag)
57        *start = (sector_t)ms_info.addr.lba << 2;
58    return 0;
59}
60
61/*
62 * hfs_mdb_get()
63 *
64 * Build the in-core MDB for a filesystem, including
65 * the B-trees and the volume bitmap.
66 */
67int hfs_mdb_get(struct super_block *sb)
68{
69    struct buffer_head *bh;
70    struct hfs_mdb *mdb, *mdb2;
71    unsigned int block;
72    char *ptr;
73    int off2, len, size, sect;
74    sector_t part_start, part_size;
75    loff_t off;
76    __be16 attrib;
77
78    /* set the device driver to 512-byte blocks */
79    size = sb_min_blocksize(sb, HFS_SECTOR_SIZE);
80    if (!size)
81        return -EINVAL;
82
83    if (hfs_get_last_session(sb, &part_start, &part_size))
84        return -EINVAL;
85    while (1) {
86        /* See if this is an HFS filesystem */
87        bh = sb_bread512(sb, part_start + HFS_MDB_BLK, mdb);
88        if (!bh)
89            goto out;
90
91        if (mdb->drSigWord == cpu_to_be16(HFS_SUPER_MAGIC))
92            break;
93        brelse(bh);
94
95        /* check for a partition block
96         * (should do this only for cdrom/loop though)
97         */
98        if (hfs_part_find(sb, &part_start, &part_size))
99            goto out;
100    }
101
102    HFS_SB(sb)->alloc_blksz = size = be32_to_cpu(mdb->drAlBlkSiz);
103    if (!size || (size & (HFS_SECTOR_SIZE - 1))) {
104        printk(KERN_ERR "hfs: bad allocation block size %d\n", size);
105        goto out_bh;
106    }
107
108    size = min(HFS_SB(sb)->alloc_blksz, (u32)PAGE_SIZE);
109    /* size must be a multiple of 512 */
110    while (size & (size - 1))
111        size -= HFS_SECTOR_SIZE;
112    sect = be16_to_cpu(mdb->drAlBlSt) + part_start;
113    /* align block size to first sector */
114    while (sect & ((size - 1) >> HFS_SECTOR_SIZE_BITS))
115        size >>= 1;
116    /* align block size to weird alloc size */
117    while (HFS_SB(sb)->alloc_blksz & (size - 1))
118        size >>= 1;
119    brelse(bh);
120    if (!sb_set_blocksize(sb, size)) {
121        printk(KERN_ERR "hfs: unable to set blocksize to %u\n", size);
122        goto out;
123    }
124
125    bh = sb_bread512(sb, part_start + HFS_MDB_BLK, mdb);
126    if (!bh)
127        goto out;
128    if (mdb->drSigWord != cpu_to_be16(HFS_SUPER_MAGIC))
129        goto out_bh;
130
131    HFS_SB(sb)->mdb_bh = bh;
132    HFS_SB(sb)->mdb = mdb;
133
134    /* These parameters are read from the MDB, and never written */
135    HFS_SB(sb)->part_start = part_start;
136    HFS_SB(sb)->fs_ablocks = be16_to_cpu(mdb->drNmAlBlks);
137    HFS_SB(sb)->fs_div = HFS_SB(sb)->alloc_blksz >> sb->s_blocksize_bits;
138    HFS_SB(sb)->clumpablks = be32_to_cpu(mdb->drClpSiz) /
139                 HFS_SB(sb)->alloc_blksz;
140    if (!HFS_SB(sb)->clumpablks)
141        HFS_SB(sb)->clumpablks = 1;
142    HFS_SB(sb)->fs_start = (be16_to_cpu(mdb->drAlBlSt) + part_start) >>
143                   (sb->s_blocksize_bits - HFS_SECTOR_SIZE_BITS);
144
145    /* These parameters are read from and written to the MDB */
146    HFS_SB(sb)->free_ablocks = be16_to_cpu(mdb->drFreeBks);
147    HFS_SB(sb)->next_id = be32_to_cpu(mdb->drNxtCNID);
148    HFS_SB(sb)->root_files = be16_to_cpu(mdb->drNmFls);
149    HFS_SB(sb)->root_dirs = be16_to_cpu(mdb->drNmRtDirs);
150    HFS_SB(sb)->file_count = be32_to_cpu(mdb->drFilCnt);
151    HFS_SB(sb)->folder_count = be32_to_cpu(mdb->drDirCnt);
152
153    /* TRY to get the alternate (backup) MDB. */
154    sect = part_start + part_size - 2;
155    bh = sb_bread512(sb, sect, mdb2);
156    if (bh) {
157        if (mdb2->drSigWord == cpu_to_be16(HFS_SUPER_MAGIC)) {
158            HFS_SB(sb)->alt_mdb_bh = bh;
159            HFS_SB(sb)->alt_mdb = mdb2;
160        } else
161            brelse(bh);
162    }
163
164    if (!HFS_SB(sb)->alt_mdb) {
165        printk(KERN_WARNING "hfs: unable to locate alternate MDB\n");
166        printk(KERN_WARNING "hfs: continuing without an alternate MDB\n");
167    }
168
169    HFS_SB(sb)->bitmap = (__be32 *)__get_free_pages(GFP_KERNEL, PAGE_SIZE < 8192 ? 1 : 0);
170    if (!HFS_SB(sb)->bitmap)
171        goto out;
172
173    /* read in the bitmap */
174    block = be16_to_cpu(mdb->drVBMSt) + part_start;
175    off = (loff_t)block << HFS_SECTOR_SIZE_BITS;
176    size = (HFS_SB(sb)->fs_ablocks + 8) / 8;
177    ptr = (u8 *)HFS_SB(sb)->bitmap;
178    while (size) {
179        bh = sb_bread(sb, off >> sb->s_blocksize_bits);
180        if (!bh) {
181            printk(KERN_ERR "hfs: unable to read volume bitmap\n");
182            goto out;
183        }
184        off2 = off & (sb->s_blocksize - 1);
185        len = min((int)sb->s_blocksize - off2, size);
186        memcpy(ptr, bh->b_data + off2, len);
187        brelse(bh);
188        ptr += len;
189        off += len;
190        size -= len;
191    }
192
193    HFS_SB(sb)->ext_tree = hfs_btree_open(sb, HFS_EXT_CNID, hfs_ext_keycmp);
194    if (!HFS_SB(sb)->ext_tree) {
195        printk(KERN_ERR "hfs: unable to open extent tree\n");
196        goto out;
197    }
198    HFS_SB(sb)->cat_tree = hfs_btree_open(sb, HFS_CAT_CNID, hfs_cat_keycmp);
199    if (!HFS_SB(sb)->cat_tree) {
200        printk(KERN_ERR "hfs: unable to open catalog tree\n");
201        goto out;
202    }
203
204    attrib = mdb->drAtrb;
205    if (!(attrib & cpu_to_be16(HFS_SB_ATTRIB_UNMNT))) {
206        printk(KERN_WARNING "hfs: filesystem was not cleanly unmounted, "
207             "running fsck.hfs is recommended. mounting read-only.\n");
208        sb->s_flags |= MS_RDONLY;
209    }
210    if ((attrib & cpu_to_be16(HFS_SB_ATTRIB_SLOCK))) {
211        printk(KERN_WARNING "hfs: filesystem is marked locked, mounting read-only.\n");
212        sb->s_flags |= MS_RDONLY;
213    }
214    if (!(sb->s_flags & MS_RDONLY)) {
215        /* Mark the volume uncleanly unmounted in case we crash */
216        attrib &= cpu_to_be16(~HFS_SB_ATTRIB_UNMNT);
217        attrib |= cpu_to_be16(HFS_SB_ATTRIB_INCNSTNT);
218        mdb->drAtrb = attrib;
219        be32_add_cpu(&mdb->drWrCnt, 1);
220        mdb->drLsMod = hfs_mtime();
221
222        mark_buffer_dirty(HFS_SB(sb)->mdb_bh);
223        hfs_buffer_sync(HFS_SB(sb)->mdb_bh);
224    }
225
226    return 0;
227
228out_bh:
229    brelse(bh);
230out:
231    hfs_mdb_put(sb);
232    return -EIO;
233}
234
235/*
236 * hfs_mdb_commit()
237 *
238 * Description:
239 * This updates the MDB on disk (look also at hfs_write_super()).
240 * It does not check, if the superblock has been modified, or
241 * if the filesystem has been mounted read-only. It is mainly
242 * called by hfs_write_super() and hfs_btree_extend().
243 * Input Variable(s):
244 * struct hfs_mdb *mdb: Pointer to the hfs MDB
245 * int backup;
246 * Output Variable(s):
247 * NONE
248 * Returns:
249 * void
250 * Preconditions:
251 * 'mdb' points to a "valid" (struct hfs_mdb).
252 * Postconditions:
253 * The HFS MDB and on disk will be updated, by copying the possibly
254 * modified fields from the in memory MDB (in native byte order) to
255 * the disk block buffer.
256 * If 'backup' is non-zero then the alternate MDB is also written
257 * and the function doesn't return until it is actually on disk.
258 */
259void hfs_mdb_commit(struct super_block *sb)
260{
261    struct hfs_mdb *mdb = HFS_SB(sb)->mdb;
262
263    if (test_and_clear_bit(HFS_FLG_MDB_DIRTY, &HFS_SB(sb)->flags)) {
264        /* These parameters may have been modified, so write them back */
265        mdb->drLsMod = hfs_mtime();
266        mdb->drFreeBks = cpu_to_be16(HFS_SB(sb)->free_ablocks);
267        mdb->drNxtCNID = cpu_to_be32(HFS_SB(sb)->next_id);
268        mdb->drNmFls = cpu_to_be16(HFS_SB(sb)->root_files);
269        mdb->drNmRtDirs = cpu_to_be16(HFS_SB(sb)->root_dirs);
270        mdb->drFilCnt = cpu_to_be32(HFS_SB(sb)->file_count);
271        mdb->drDirCnt = cpu_to_be32(HFS_SB(sb)->folder_count);
272
273        /* write MDB to disk */
274        mark_buffer_dirty(HFS_SB(sb)->mdb_bh);
275    }
276
277    /* write the backup MDB, not returning until it is written.
278     * we only do this when either the catalog or extents overflow
279     * files grow. */
280    if (test_and_clear_bit(HFS_FLG_ALT_MDB_DIRTY, &HFS_SB(sb)->flags) &&
281        HFS_SB(sb)->alt_mdb) {
282        hfs_inode_write_fork(HFS_SB(sb)->ext_tree->inode, mdb->drXTExtRec,
283                     &mdb->drXTFlSize, NULL);
284        hfs_inode_write_fork(HFS_SB(sb)->cat_tree->inode, mdb->drCTExtRec,
285                     &mdb->drCTFlSize, NULL);
286        memcpy(HFS_SB(sb)->alt_mdb, HFS_SB(sb)->mdb, HFS_SECTOR_SIZE);
287        HFS_SB(sb)->alt_mdb->drAtrb |= cpu_to_be16(HFS_SB_ATTRIB_UNMNT);
288        HFS_SB(sb)->alt_mdb->drAtrb &= cpu_to_be16(~HFS_SB_ATTRIB_INCNSTNT);
289        mark_buffer_dirty(HFS_SB(sb)->alt_mdb_bh);
290        hfs_buffer_sync(HFS_SB(sb)->alt_mdb_bh);
291    }
292
293    if (test_and_clear_bit(HFS_FLG_BITMAP_DIRTY, &HFS_SB(sb)->flags)) {
294        struct buffer_head *bh;
295        sector_t block;
296        char *ptr;
297        int off, size, len;
298
299        block = be16_to_cpu(HFS_SB(sb)->mdb->drVBMSt) + HFS_SB(sb)->part_start;
300        off = (block << HFS_SECTOR_SIZE_BITS) & (sb->s_blocksize - 1);
301        block >>= sb->s_blocksize_bits - HFS_SECTOR_SIZE_BITS;
302        size = (HFS_SB(sb)->fs_ablocks + 7) / 8;
303        ptr = (u8 *)HFS_SB(sb)->bitmap;
304        while (size) {
305            bh = sb_bread(sb, block);
306            if (!bh) {
307                printk(KERN_ERR "hfs: unable to read volume bitmap\n");
308                break;
309            }
310            len = min((int)sb->s_blocksize - off, size);
311            memcpy(bh->b_data + off, ptr, len);
312            mark_buffer_dirty(bh);
313            brelse(bh);
314            block++;
315            off = 0;
316            ptr += len;
317            size -= len;
318        }
319    }
320}
321
322void hfs_mdb_close(struct super_block *sb)
323{
324    /* update volume attributes */
325    if (sb->s_flags & MS_RDONLY)
326        return;
327    HFS_SB(sb)->mdb->drAtrb |= cpu_to_be16(HFS_SB_ATTRIB_UNMNT);
328    HFS_SB(sb)->mdb->drAtrb &= cpu_to_be16(~HFS_SB_ATTRIB_INCNSTNT);
329    mark_buffer_dirty(HFS_SB(sb)->mdb_bh);
330}
331
332/*
333 * hfs_mdb_put()
334 *
335 * Release the resources associated with the in-core MDB. */
336void hfs_mdb_put(struct super_block *sb)
337{
338    if (!HFS_SB(sb))
339        return;
340    /* free the B-trees */
341    hfs_btree_close(HFS_SB(sb)->ext_tree);
342    hfs_btree_close(HFS_SB(sb)->cat_tree);
343
344    /* free the buffers holding the primary and alternate MDBs */
345    brelse(HFS_SB(sb)->mdb_bh);
346    brelse(HFS_SB(sb)->alt_mdb_bh);
347
348    unload_nls(HFS_SB(sb)->nls_io);
349    unload_nls(HFS_SB(sb)->nls_disk);
350
351    free_pages((unsigned long)HFS_SB(sb)->bitmap, PAGE_SIZE < 8192 ? 1 : 0);
352    kfree(HFS_SB(sb));
353    sb->s_fs_info = NULL;
354}
355

Archive Download this file



interactive