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