~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/hfs/mdb.c

Version: ~ [ linux-5.4-rc3 ] ~ [ linux-5.3.6 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.79 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.149 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.196 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.196 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.75 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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_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  */
 67 int 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 = (__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                         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 
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.
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  */
258 void 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 
334 void 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.  */
348 void 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         free_pages((unsigned long)HFS_SB(sb)->bitmap, PAGE_SIZE < 8192 ? 1 : 0);
364         kfree(HFS_SB(sb));
365         sb->s_fs_info = NULL;
366 }
367 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp