Loading...
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 sync_dirty_buffer(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 sync_dirty_buffer(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}
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 pr_err("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 pr_err("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 pr_err("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 pr_warn("unable to locate alternate MDB\n");
166 pr_warn("continuing without an alternate MDB\n");
167 }
168
169 HFS_SB(sb)->bitmap = kmalloc(8192, GFP_KERNEL);
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 pr_err("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 pr_err("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 pr_err("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 pr_warn("filesystem was not cleanly unmounted, running fsck.hfs is recommended. mounting read-only.\n");
207 sb->s_flags |= MS_RDONLY;
208 }
209 if ((attrib & cpu_to_be16(HFS_SB_ATTRIB_SLOCK))) {
210 pr_warn("filesystem is marked locked, mounting read-only.\n");
211 sb->s_flags |= MS_RDONLY;
212 }
213 if (!(sb->s_flags & MS_RDONLY)) {
214 /* Mark the volume uncleanly unmounted in case we crash */
215 attrib &= cpu_to_be16(~HFS_SB_ATTRIB_UNMNT);
216 attrib |= cpu_to_be16(HFS_SB_ATTRIB_INCNSTNT);
217 mdb->drAtrb = attrib;
218 be32_add_cpu(&mdb->drWrCnt, 1);
219 mdb->drLsMod = hfs_mtime();
220
221 mark_buffer_dirty(HFS_SB(sb)->mdb_bh);
222 sync_dirty_buffer(HFS_SB(sb)->mdb_bh);
223 }
224
225 return 0;
226
227out_bh:
228 brelse(bh);
229out:
230 hfs_mdb_put(sb);
231 return -EIO;
232}
233
234/*
235 * hfs_mdb_commit()
236 *
237 * Description:
238 * This updates the MDB on disk.
239 * It does not check, if the superblock has been modified, or
240 * if the filesystem has been mounted read-only. It is mainly
241 * called by hfs_sync_fs() and flush_mdb().
242 * Input Variable(s):
243 * struct hfs_mdb *mdb: Pointer to the hfs MDB
244 * int backup;
245 * Output Variable(s):
246 * NONE
247 * Returns:
248 * void
249 * Preconditions:
250 * 'mdb' points to a "valid" (struct hfs_mdb).
251 * Postconditions:
252 * The HFS MDB and on disk will be updated, by copying the possibly
253 * modified fields from the in memory MDB (in native byte order) to
254 * the disk block buffer.
255 * If 'backup' is non-zero then the alternate MDB is also written
256 * and the function doesn't return until it is actually on disk.
257 */
258void hfs_mdb_commit(struct super_block *sb)
259{
260 struct hfs_mdb *mdb = HFS_SB(sb)->mdb;
261
262 if (sb->s_flags & MS_RDONLY)
263 return;
264
265 lock_buffer(HFS_SB(sb)->mdb_bh);
266 if (test_and_clear_bit(HFS_FLG_MDB_DIRTY, &HFS_SB(sb)->flags)) {
267 /* These parameters may have been modified, so write them back */
268 mdb->drLsMod = hfs_mtime();
269 mdb->drFreeBks = cpu_to_be16(HFS_SB(sb)->free_ablocks);
270 mdb->drNxtCNID = cpu_to_be32(HFS_SB(sb)->next_id);
271 mdb->drNmFls = cpu_to_be16(HFS_SB(sb)->root_files);
272 mdb->drNmRtDirs = cpu_to_be16(HFS_SB(sb)->root_dirs);
273 mdb->drFilCnt = cpu_to_be32(HFS_SB(sb)->file_count);
274 mdb->drDirCnt = cpu_to_be32(HFS_SB(sb)->folder_count);
275
276 /* write MDB to disk */
277 mark_buffer_dirty(HFS_SB(sb)->mdb_bh);
278 }
279
280 /* write the backup MDB, not returning until it is written.
281 * we only do this when either the catalog or extents overflow
282 * files grow. */
283 if (test_and_clear_bit(HFS_FLG_ALT_MDB_DIRTY, &HFS_SB(sb)->flags) &&
284 HFS_SB(sb)->alt_mdb) {
285 hfs_inode_write_fork(HFS_SB(sb)->ext_tree->inode, mdb->drXTExtRec,
286 &mdb->drXTFlSize, NULL);
287 hfs_inode_write_fork(HFS_SB(sb)->cat_tree->inode, mdb->drCTExtRec,
288 &mdb->drCTFlSize, NULL);
289
290 lock_buffer(HFS_SB(sb)->alt_mdb_bh);
291 memcpy(HFS_SB(sb)->alt_mdb, HFS_SB(sb)->mdb, HFS_SECTOR_SIZE);
292 HFS_SB(sb)->alt_mdb->drAtrb |= cpu_to_be16(HFS_SB_ATTRIB_UNMNT);
293 HFS_SB(sb)->alt_mdb->drAtrb &= cpu_to_be16(~HFS_SB_ATTRIB_INCNSTNT);
294 unlock_buffer(HFS_SB(sb)->alt_mdb_bh);
295
296 mark_buffer_dirty(HFS_SB(sb)->alt_mdb_bh);
297 sync_dirty_buffer(HFS_SB(sb)->alt_mdb_bh);
298 }
299
300 if (test_and_clear_bit(HFS_FLG_BITMAP_DIRTY, &HFS_SB(sb)->flags)) {
301 struct buffer_head *bh;
302 sector_t block;
303 char *ptr;
304 int off, size, len;
305
306 block = be16_to_cpu(HFS_SB(sb)->mdb->drVBMSt) + HFS_SB(sb)->part_start;
307 off = (block << HFS_SECTOR_SIZE_BITS) & (sb->s_blocksize - 1);
308 block >>= sb->s_blocksize_bits - HFS_SECTOR_SIZE_BITS;
309 size = (HFS_SB(sb)->fs_ablocks + 7) / 8;
310 ptr = (u8 *)HFS_SB(sb)->bitmap;
311 while (size) {
312 bh = sb_bread(sb, block);
313 if (!bh) {
314 pr_err("unable to read volume bitmap\n");
315 break;
316 }
317 len = min((int)sb->s_blocksize - off, size);
318
319 lock_buffer(bh);
320 memcpy(bh->b_data + off, ptr, len);
321 unlock_buffer(bh);
322
323 mark_buffer_dirty(bh);
324 brelse(bh);
325 block++;
326 off = 0;
327 ptr += len;
328 size -= len;
329 }
330 }
331 unlock_buffer(HFS_SB(sb)->mdb_bh);
332}
333
334void hfs_mdb_close(struct super_block *sb)
335{
336 /* update volume attributes */
337 if (sb->s_flags & MS_RDONLY)
338 return;
339 HFS_SB(sb)->mdb->drAtrb |= cpu_to_be16(HFS_SB_ATTRIB_UNMNT);
340 HFS_SB(sb)->mdb->drAtrb &= cpu_to_be16(~HFS_SB_ATTRIB_INCNSTNT);
341 mark_buffer_dirty(HFS_SB(sb)->mdb_bh);
342}
343
344/*
345 * hfs_mdb_put()
346 *
347 * Release the resources associated with the in-core MDB. */
348void hfs_mdb_put(struct super_block *sb)
349{
350 if (!HFS_SB(sb))
351 return;
352 /* free the B-trees */
353 hfs_btree_close(HFS_SB(sb)->ext_tree);
354 hfs_btree_close(HFS_SB(sb)->cat_tree);
355
356 /* free the buffers holding the primary and alternate MDBs */
357 brelse(HFS_SB(sb)->mdb_bh);
358 brelse(HFS_SB(sb)->alt_mdb_bh);
359
360 unload_nls(HFS_SB(sb)->nls_io);
361 unload_nls(HFS_SB(sb)->nls_disk);
362
363 kfree(HFS_SB(sb)->bitmap);
364 kfree(HFS_SB(sb));
365 sb->s_fs_info = NULL;
366}