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