1/* 2 * Copyright (c) 2000-2014 Apple Inc. All rights reserved. 3 * 4 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@ 5 * 6 * This file contains Original Code and/or Modifications of Original Code 7 * as defined in and that are subject to the Apple Public Source License 8 * Version 2.0 (the 'License'). You may not use this file except in 9 * compliance with the License. The rights granted to you under the License 10 * may not be used to create, or enable the creation or redistribution of, 11 * unlawful or unlicensed copies of an Apple operating system, or to 12 * circumvent, violate, or enable the circumvention or violation of, any 13 * terms of an Apple operating system software license agreement. 14 * 15 * Please obtain a copy of the License at 16 * http://www.opensource.apple.com/apsl/ and read it before using this file. 17 * 18 * The Original Code and all software distributed under the License are 19 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 20 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, 21 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, 22 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 23 * Please see the License for the specific language governing rights and 24 * limitations under the License. 25 * 26 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@ 27 */ 28 29#ifndef __HFS__ 30#define __HFS__ 31 32/* If set to 1, enables the code to allocate blocks from the start 33 * of the disk instead of the nextAllocation for sparse devices like 34 * sparse disk images or sparsebundle images. The free extent cache 35 * for such volumes is also maintained based on the start block instead 36 * of number of contiguous allocation blocks. These devices prefer 37 * allocation of blocks near the start of the disk to avoid the 38 * increasing the image size, but it can also result in file fragmentation. 39 */ 40#define HFS_SPARSE_DEV 1 41 42#if DEBUG 43#define HFS_CHECK_LOCK_ORDER 1 44#endif 45 46#include <sys/appleapiopts.h> 47 48#ifdef KERNEL 49#ifdef __APPLE_API_PRIVATE 50#include <sys/param.h> 51#include <sys/queue.h> 52#include <sys/mount.h> 53#include <sys/vnode.h> 54#include <sys/quota.h> 55#include <sys/dirent.h> 56#include <sys/event.h> 57#include <sys/disk.h> 58#include <kern/thread_call.h> 59 60#include <kern/locks.h> 61 62#include <vfs/vfs_journal.h> 63 64#include <hfs/hfs_format.h> 65#include <hfs/hfs_catalog.h> 66#include <hfs/hfs_cnode.h> 67#include <hfs/hfs_macos_defs.h> 68#include <hfs/hfs_encodings.h> 69#include <hfs/hfs_hotfiles.h> 70#include <hfs/hfs_fsctl.h> 71 72#if CONFIG_PROTECT 73/* Forward declare the cprotect struct */ 74struct cprotect; 75#endif 76 77/* 78 * Just reported via MIG interface. 79 */ 80#define VERSION_STRING "hfs-2 (4-12-99)" 81 82#define HFS_LINK_MAX 32767 83 84#define HFS_MAX_DEFERED_ALLOC (1024*1024) 85 86// 400 megs is a "big" file (i.e. one that when deleted 87// would touch enough data that we should break it into 88// multiple separate transactions) 89#define HFS_BIGFILE_SIZE (400LL * 1024LL * 1024LL) 90 91 92enum { kMDBSize = 512 }; /* Size of I/O transfer to read entire MDB */ 93 94enum { kMasterDirectoryBlock = 2 }; /* MDB offset on disk in 512-byte blocks */ 95enum { kMDBOffset = kMasterDirectoryBlock * 512 }; /* MDB offset on disk in bytes */ 96 97#define kRootDirID kHFSRootFolderID 98 99 100/* number of locked buffer caches to hold for b-tree meta data */ 101#define kMaxLockedMetaBuffers 32 102 103extern struct timezone gTimeZone; 104 105 106/* How many free extents to cache per volume */ 107#define kMaxFreeExtents 10 108 109/* 110 * HFS_MINFREE gives the minimum acceptable percentage 111 * of file system blocks which may be free (but this 112 * minimum will never exceed HFS_MAXRESERVE bytes). If 113 * the free block count drops below this level only the 114 * superuser may continue to allocate blocks. 115 */ 116#define HFS_MINFREE 1 117#define HFS_MAXRESERVE ((u_int64_t)(250*1024*1024)) 118#define HFS_BT_MAXRESERVE ((u_int64_t)(10*1024*1024)) 119 120/* 121 * The system distinguishes between the desirable low-disk 122 * notifiaction levels for root volumes and non-root volumes. 123 * The various thresholds are computed as a fraction of the 124 * volume size, all capped at a certain fixed level 125 */ 126 127#define HFS_ROOTVERYLOWDISKTRIGGERFRACTION 5 128#define HFS_ROOTVERYLOWDISKTRIGGERLEVEL ((u_int64_t)(512*1024*1024)) 129#define HFS_ROOTLOWDISKTRIGGERFRACTION 10 130#define HFS_ROOTLOWDISKTRIGGERLEVEL ((u_int64_t)(1024*1024*1024)) 131#define HFS_ROOTLOWDISKSHUTOFFFRACTION 11 132#define HFS_ROOTLOWDISKSHUTOFFLEVEL ((u_int64_t)(1024*1024*1024 + 250*1024*1024)) 133 134#define HFS_VERYLOWDISKTRIGGERFRACTION 1 135#define HFS_VERYLOWDISKTRIGGERLEVEL ((u_int64_t)(100*1024*1024)) 136#define HFS_LOWDISKTRIGGERFRACTION 2 137#define HFS_LOWDISKTRIGGERLEVEL ((u_int64_t)(150*1024*1024)) 138#define HFS_LOWDISKSHUTOFFFRACTION 3 139#define HFS_LOWDISKSHUTOFFLEVEL ((u_int64_t)(200*1024*1024)) 140 141/* Internal Data structures*/ 142 143/* This structure describes the HFS specific mount structure data. */ 144typedef struct hfsmount { 145 u_int32_t hfs_flags; /* see below */ 146 147 /* Physical Description */ 148 u_int32_t hfs_logical_block_size; /* Logical block size of the disk as reported by ioctl(DKIOCGETBLOCKSIZE), always a multiple of 512 */ 149 daddr64_t hfs_logical_block_count; /* Number of logical blocks on the disk, as reported by ioctl(DKIOCGETBLOCKCOUNT) */ 150 u_int64_t hfs_logical_bytes; /* Number of bytes on the disk device this HFS is mounted on (blockcount * blocksize) */ 151 /* 152 * Regarding the two AVH sector fields below: 153 * Under normal circumstances, the filesystem's notion of the "right" location for the AVH is such that 154 * the partition and filesystem's are in sync. However, during a filesystem resize, HFS proactively 155 * writes a new AVH at the end of the filesystem, assuming that the partition will be resized accordingly. 156 * 157 * However, it is not technically a corruption if the partition size is never modified. As a result, we need 158 * to keep two copies of the AVH around "just in case" the partition size is not modified. 159 */ 160 daddr64_t hfs_partition_avh_sector; /* location of Alt VH w.r.t partition size */ 161 daddr64_t hfs_fs_avh_sector; /* location of Alt VH w.r.t filesystem size */ 162 163 u_int32_t hfs_physical_block_size; /* Physical block size of the disk as reported by ioctl(DKIOCGETPHYSICALBLOCKSIZE) */ 164 u_int32_t hfs_log_per_phys; /* Number of logical blocks per physical block size */ 165 166 /* Access to VFS and devices */ 167 struct mount *hfs_mp; /* filesystem vfs structure */ 168 struct vnode *hfs_devvp; /* block device mounted vnode */ 169 struct vnode * hfs_extents_vp; 170 struct vnode * hfs_catalog_vp; 171 struct vnode * hfs_allocation_vp; 172 struct vnode * hfs_attribute_vp; 173 struct vnode * hfs_startup_vp; 174 struct vnode * hfs_attrdata_vp; /* pseudo file */ 175 struct cnode * hfs_extents_cp; 176 struct cnode * hfs_catalog_cp; 177 struct cnode * hfs_allocation_cp; 178 struct cnode * hfs_attribute_cp; 179 struct cnode * hfs_startup_cp; 180 dev_t hfs_raw_dev; /* device mounted */ 181 u_int32_t hfs_logBlockSize; /* Size of buffer cache buffer for I/O */ 182 183 /* Default values for HFS standard and non-init access */ 184 uid_t hfs_uid; /* uid to set as owner of the files */ 185 gid_t hfs_gid; /* gid to set as owner of the files */ 186 mode_t hfs_dir_mask; /* mask to and with directory protection bits */ 187 mode_t hfs_file_mask; /* mask to and with file protection bits */ 188 u_int32_t hfs_encoding; /* Default encoding for non hfs+ volumes */ 189 190 /* Persistent fields (on disk, dynamic) */ 191 time_t hfs_mtime; /* file system last modification time */ 192 u_int32_t hfs_filecount; /* number of files in file system */ 193 u_int32_t hfs_dircount; /* number of directories in file system */ 194 u_int32_t freeBlocks; /* free allocation blocks */ 195 u_int32_t nextAllocation; /* start of next allocation search */ 196 u_int32_t sparseAllocation; /* start of allocations for sparse devices */ 197 u_int32_t vcbNxtCNID; /* next unused catalog node ID - protected by catalog lock */ 198 u_int32_t vcbWrCnt; /* file system write count */ 199 u_int64_t encodingsBitmap; /* in-use encodings */ 200 u_int16_t vcbNmFls; /* HFS Only - root dir file count */ 201 u_int16_t vcbNmRtDirs; /* HFS Only - root dir directory count */ 202 203 /* Persistent fields (on disk, static) */ 204 u_int16_t vcbSigWord; 205 int16_t vcbFlags; /* Runtime flag to indicate if volume is dirty/clean */ 206 u_int32_t vcbAtrb; 207 u_int32_t vcbJinfoBlock; 208 u_int32_t localCreateDate;/* volume create time from volume header (For HFS+, value is in local time) */ 209 time_t hfs_itime; /* file system creation time (creation date of the root folder) */ 210 time_t hfs_btime; /* file system last backup time */ 211 u_int32_t blockSize; /* size of allocation blocks */ 212 u_int32_t totalBlocks; /* total allocation blocks */ 213 u_int32_t allocLimit; /* Do not allocate this block or beyond */ 214 /* 215 * NOTE: When resizing a volume to make it smaller, allocLimit is set to the allocation 216 * block number which will contain the new alternate volume header. At all other times, 217 * allocLimit is set to totalBlocks. The allocation code uses allocLimit instead of 218 * totalBlocks to limit which blocks may be allocated, so that during a resize, we don't 219 * put new content into the blocks we're trying to truncate away. 220 */ 221 int32_t vcbClpSiz; 222 u_int32_t vcbFndrInfo[8]; 223 int16_t vcbVBMSt; /* HFS only */ 224 int16_t vcbAlBlSt; /* HFS only */ 225 226 /* vcb stuff */ 227 u_int8_t vcbVN[256]; /* volume name in UTF-8 */ 228 u_int32_t volumeNameEncodingHint; 229 u_int32_t hfsPlusIOPosOffset; /* Disk block where HFS+ starts */ 230 u_int32_t vcbVBMIOSize; /* volume bitmap I/O size */ 231 232 /* cache of largest known free extents */ 233 u_int32_t vcbFreeExtCnt; 234 HFSPlusExtentDescriptor vcbFreeExt[kMaxFreeExtents]; 235 lck_spin_t vcbFreeExtLock; 236 237 /* Summary Table */ 238 u_int8_t *hfs_summary_table; /* Each bit is 1 vcbVBMIOSize of bitmap, byte indexed */ 239 u_int32_t hfs_summary_size; /* number of BITS in summary table defined above (not bytes!) */ 240 u_int32_t hfs_summary_bytes; /* number of BYTES in summary table */ 241 242 u_int32_t scan_var; /* For initializing the summary table */ 243 244 245 u_int32_t reserveBlocks; /* free block reserve */ 246 u_int32_t loanedBlocks; /* blocks on loan for delayed allocations */ 247 248 249 /* 250 * HFS+ Private system directories (two). Any access 251 * (besides looking at the cd_cnid) requires holding 252 * the Catalog File lock. 253 */ 254 struct cat_desc hfs_private_desc[2]; 255 struct cat_attr hfs_private_attr[2]; 256 257 u_int32_t hfs_metadata_createdate; 258 hfs_to_unicode_func_t hfs_get_unicode; 259 unicode_to_hfs_func_t hfs_get_hfsname; 260 261 /* Quota variables: */ 262 struct quotafile hfs_qfiles[MAXQUOTAS]; /* quota files */ 263 264 /* Journaling variables: */ 265 struct journal *jnl; // the journal for this volume (if one exists) 266 struct vnode *jvp; // device where the journal lives (may be equal to devvp) 267 u_int32_t jnl_start; // start block of the journal file (so we don't delete it) 268 u_int32_t jnl_size; 269 u_int32_t hfs_jnlfileid; 270 u_int32_t hfs_jnlinfoblkid; 271 lck_rw_t hfs_global_lock; 272 u_int32_t hfs_global_lock_nesting; 273 thread_t hfs_global_lockowner; 274 275 /* Notification variables: */ 276 u_int32_t hfs_notification_conditions; 277 u_int32_t hfs_freespace_notify_dangerlimit; 278 u_int32_t hfs_freespace_notify_warninglimit; 279 u_int32_t hfs_freespace_notify_desiredlevel; 280 281 /* time mounted and last mounted mod time "snapshot" */ 282 time_t hfs_mount_time; 283 time_t hfs_last_mounted_mtime; 284 285 /* Metadata allocation zone variables: */ 286 u_int32_t hfs_metazone_start; 287 u_int32_t hfs_metazone_end; 288 u_int32_t hfs_hotfile_start; 289 u_int32_t hfs_hotfile_end; 290 u_int32_t hfs_min_alloc_start; 291 u_int32_t hfs_freed_block_count; 292 int hfs_hotfile_freeblks; 293 int hfs_hotfile_maxblks; 294 int hfs_overflow_maxblks; 295 int hfs_catalog_maxblks; 296 297 /* Hot File Clustering variables: */ 298 lck_mtx_t hfc_mutex; /* serialize hot file stages */ 299 enum hfc_stage hfc_stage; /* what are we up to... */ 300 time_t hfc_timebase; /* recording period start time */ 301 time_t hfc_timeout; /* recording period stop time */ 302 void * hfc_recdata; /* recording data (opaque) */ 303 int hfc_maxfiles; /* maximum files to track */ 304 struct vnode * hfc_filevp; 305 306#if HFS_SPARSE_DEV 307 /* Sparse device variables: */ 308 struct vnode * hfs_backingfs_rootvp; 309 u_int32_t hfs_last_backingstatfs; 310 u_int32_t hfs_sparsebandblks; 311 u_int64_t hfs_backingfs_maxblocks; 312#endif 313 size_t hfs_max_inline_attrsize; 314 315 lck_mtx_t hfs_mutex; /* protects access to hfsmount data */ 316 317 uint32_t hfs_syncers; // Count of the number of syncers running 318 enum { 319 HFS_THAWED, 320 HFS_WANT_TO_FREEZE, // This state stops hfs_sync from starting 321 HFS_FREEZING, // We're in this state whilst we're flushing 322 HFS_FROZEN // Everything gets blocked in hfs_lock_global 323 } hfs_freeze_state; 324 union { 325 /* 326 * When we're freezing (HFS_FREEZING) but not yet 327 * frozen (HFS_FROZEN), we record the freezing thread 328 * so that we stop other threads from taking locks, 329 * but allow the freezing thread. 330 */ 331 const struct thread *hfs_freezing_thread; 332 /* 333 * Once we have frozen (HFS_FROZEN), we record the 334 * process so that if it dies, we can automatically 335 * unfreeze. 336 */ 337 proc_t hfs_freezing_proc; 338 }; 339 340 thread_t hfs_downgrading_thread; /* thread who's downgrading to rdonly */ 341 342 /* Resize variables: */ 343 u_int32_t hfs_resize_blocksmoved; 344 u_int32_t hfs_resize_totalblocks; 345 u_int32_t hfs_resize_progress; 346#if CONFIG_PROTECT 347 /* Data Protection fields */ 348 struct cprotect *hfs_resize_cpentry; 349 u_int16_t hfs_running_cp_major_vers; 350 uint32_t default_cp_class; /* default effective class value */ 351 uint64_t cproot_flags; 352 uint8_t cp_crypto_generation; 353 uint8_t hfs_cp_lock_state; /* per-mount device lock state info */ 354#endif 355 356 357 /* Per mount cnode hash variables: */ 358 lck_mtx_t hfs_chash_mutex; /* protects access to cnode hash table */ 359 u_long hfs_cnodehash; /* size of cnode hash table - 1 */ 360 LIST_HEAD(cnodehashhead, cnode) *hfs_cnodehashtbl; /* base of cnode hash */ 361 362 /* Per mount fileid hash variables (protected by catalog lock!) */ 363 u_long hfs_idhash; /* size of cnid/fileid hash table -1 */ 364 LIST_HEAD(idhashhead, cat_preflightid) *hfs_idhashtbl; /* base of ID hash */ 365 366 // Records the oldest outstanding sync request 367 struct timeval hfs_sync_req_oldest; 368 369 // Records whether a sync has been queued or is in progress 370 boolean_t hfs_sync_incomplete; 371 372 thread_call_t hfs_syncer; // removeable devices get sync'ed by this guy 373 374 /* Records the syncer thread so that we can avoid the syncer 375 queing more syncs. */ 376 thread_t hfs_syncer_thread; 377 378 // Not currently used except for debugging purposes 379 uint32_t hfs_active_threads; 380} hfsmount_t; 381 382/* 383 * HFS_META_DELAY is a duration (in usecs) used for triggering the 384 * hfs_syncer() routine. We will back off if writes are in 385 * progress, but... 386 * HFS_MAX_META_DELAY is the maximum time we will allow the 387 * syncer to be delayed. 388 */ 389enum { 390 HFS_META_DELAY = 100 * 1000, // 0.1 secs 391 HFS_MAX_META_DELAY = 5000 * 1000 // 5 secs 392}; 393 394typedef hfsmount_t ExtendedVCB; 395 396/* Aliases for legacy (Mac OS 9) field names */ 397#define vcbLsMod hfs_mtime 398#define vcbVolBkUp hfs_btime 399#define extentsRefNum hfs_extents_vp 400#define catalogRefNum hfs_catalog_vp 401#define allocationsRefNum hfs_allocation_vp 402#define vcbFilCnt hfs_filecount 403#define vcbDirCnt hfs_dircount 404 405/* Inline functions to set/reset vcbFlags. Upper 8 bits indicate if the volume 406 * header/VCB is clean/dirty --- if set, volume header is dirty, and 407 * if clear, volume header is clean. This value is checked to determine 408 * if the in-memory copy of volume header should be flushed to the disk 409 * or not. 410 */ 411/* Set runtime flag to indicate that volume is dirty */ 412static __inline__ void MarkVCBDirty(ExtendedVCB *vcb) 413{ 414 vcb->vcbFlags |= 0xFF00; 415} 416 417/* Clear runtime flag to indicate that volume is dirty */ 418static __inline__ void MarkVCBClean(ExtendedVCB *vcb) 419{ 420 vcb->vcbFlags &= 0x00FF; 421} 422 423/* Check runtime flag to determine if the volume is dirty or not */ 424static __inline__ Boolean IsVCBDirty(ExtendedVCB *vcb) 425{ 426 return (vcb->vcbFlags & 0xFF00 ? true : false); 427} 428 429/* 430 * There are two private directories in HFS+. 431 * 432 * One contains inodes for files that are hardlinked or open/unlinked. 433 * The other contains inodes for directories that are hardlinked. 434 */ 435enum privdirtype {FILE_HARDLINKS, DIR_HARDLINKS}; 436 437#define HFS_ALLOCATOR_SCAN_INFLIGHT 0x0001 /* scan started */ 438#define HFS_ALLOCATOR_SCAN_COMPLETED 0x0002 /* initial scan was completed */ 439 440/* HFS mount point flags */ 441#define HFS_READ_ONLY 0x00001 442#define HFS_UNKNOWN_PERMS 0x00002 443#define HFS_WRITEABLE_MEDIA 0x00004 444#define HFS_CLEANED_ORPHANS 0x00008 445#define HFS_X 0x00010 446#define HFS_CASE_SENSITIVE 0x00020 447#define HFS_STANDARD 0x00040 448#define HFS_METADATA_ZONE 0x00080 449#define HFS_FRAGMENTED_FREESPACE 0x00100 450#define HFS_NEED_JNL_RESET 0x00200 451#define HFS_HAS_SPARSE_DEVICE 0x00400 452#define HFS_RESIZE_IN_PROGRESS 0x00800 453#define HFS_QUOTAS 0x01000 454#define HFS_CREATING_BTREE 0x02000 455/* When set, do not update nextAllocation in the mount structure */ 456#define HFS_SKIP_UPDATE_NEXT_ALLOCATION 0x04000 457/* When set, the file system supports extent-based extended attributes */ 458#define HFS_XATTR_EXTENTS 0x08000 459#define HFS_FOLDERCOUNT 0x10000 460/* When set, the file system exists on a virtual device, like disk image */ 461#define HFS_VIRTUAL_DEVICE 0x20000 462/* When set, we're in hfs_changefs, so hfs_sync should do nothing. */ 463#define HFS_IN_CHANGEFS 0x40000 464/* When set, we are in process of downgrading or have downgraded to read-only, 465 * so hfs_start_transaction should return EROFS. 466 */ 467#define HFS_RDONLY_DOWNGRADE 0x80000 468#define HFS_DID_CONTIG_SCAN 0x100000 469#define HFS_UNMAP 0x200000 470#define HFS_SSD 0x400000 471#define HFS_SUMMARY_TABLE 0x800000 472#define HFS_CS 0x1000000 473 474 475/* Macro to update next allocation block in the HFS mount structure. If 476 * the HFS_SKIP_UPDATE_NEXT_ALLOCATION is set, do not update 477 * nextAllocation block. 478 */ 479#define HFS_UPDATE_NEXT_ALLOCATION(hfsmp, new_nextAllocation) \ 480 { \ 481 if ((hfsmp->hfs_flags & HFS_SKIP_UPDATE_NEXT_ALLOCATION) == 0)\ 482 hfsmp->nextAllocation = new_nextAllocation; \ 483 } \ 484 485/* Macro for incrementing and decrementing the folder count in a cnode 486 * attribute only if the HFS_FOLDERCOUNT bit is set in the mount flags 487 * and kHFSHasFolderCount bit is set in the cnode flags. Currently these 488 * bits are only set for case sensitive HFS+ volumes. 489 */ 490#define INC_FOLDERCOUNT(hfsmp, cattr) \ 491 if ((hfsmp->hfs_flags & HFS_FOLDERCOUNT) && \ 492 (cattr.ca_recflags & kHFSHasFolderCountMask)) { \ 493 cattr.ca_dircount++; \ 494 } \ 495 496#define DEC_FOLDERCOUNT(hfsmp, cattr) \ 497 if ((hfsmp->hfs_flags & HFS_FOLDERCOUNT) && \ 498 (cattr.ca_recflags & kHFSHasFolderCountMask) && \ 499 (cattr.ca_dircount > 0)) { \ 500 cattr.ca_dircount--; \ 501 } \ 502 503typedef struct filefork FCB; 504 505/* 506 * Macros for creating item names for our special/private directories. 507 */ 508#define MAKE_INODE_NAME(name, size, linkno) \ 509 (void) snprintf((name), size, "%s%d", HFS_INODE_PREFIX, (linkno)) 510#define HFS_INODE_PREFIX_LEN 5 511 512#define MAKE_DIRINODE_NAME(name, size, linkno) \ 513 (void) snprintf((name), size, "%s%d", HFS_DIRINODE_PREFIX, (linkno)) 514#define HFS_DIRINODE_PREFIX_LEN 4 515 516#define MAKE_DELETED_NAME(NAME, size, FID) \ 517 (void) snprintf((NAME), size, "%s%d", HFS_DELETE_PREFIX, (FID)) 518#define HFS_DELETE_PREFIX_LEN 4 519 520 521#define HFS_AVERAGE_NAME_SIZE 22 522#define AVERAGE_HFSDIRENTRY_SIZE (8+HFS_AVERAGE_NAME_SIZE+4) 523 524#define STD_DIRENT_LEN(namlen) \ 525 ((sizeof(struct dirent) - (NAME_MAX+1)) + (((namlen)+1 + 3) &~ 3)) 526 527#define EXT_DIRENT_LEN(namlen) \ 528 ((sizeof(struct direntry) + (namlen) - (MAXPATHLEN-1) + 7) & ~7) 529 530 531enum { kHFSPlusMaxFileNameBytes = kHFSPlusMaxFileNameChars * 3 }; 532 533 534/* macro to determine if hfs or hfsplus */ 535#define ISHFSPLUS(VCB) ((VCB)->vcbSigWord == kHFSPlusSigWord) 536#define ISHFS(VCB) ((VCB)->vcbSigWord == kHFSSigWord) 537 538 539/* 540 * Various ways to acquire a VFS mount point pointer: 541 */ 542#define VTOVFS(VP) vnode_mount((VP)) 543#define HFSTOVFS(HFSMP) ((HFSMP)->hfs_mp) 544#define VCBTOVFS(VCB) HFSTOVFS(VCB) 545 546/* 547 * Various ways to acquire an HFS mount point pointer: 548 */ 549#define VTOHFS(VP) ((struct hfsmount *)vfs_fsprivate(vnode_mount((VP)))) 550#define VFSTOHFS(MP) ((struct hfsmount *)vfs_fsprivate((MP))) 551#define VCBTOHFS(VCB) (VCB) 552#define FCBTOHFS(FCB) ((struct hfsmount *)vfs_fsprivate(vnode_mount((FCB)->ff_cp->c_vp))) 553 554/* 555 * Various ways to acquire a VCB (legacy) pointer: 556 */ 557#define VTOVCB(VP) VTOHFS(VP) 558#define VFSTOVCB(MP) VFSTOHFS(MP) 559#define HFSTOVCB(HFSMP) (HFSMP) 560#define FCBTOVCB(FCB) FCBTOHFS(FCB) 561 562 563#define E_NONE 0 564#define kHFSBlockSize 512 565 566/* 567 * Macros for getting the MDB/VH sector and offset 568 */ 569#define HFS_PRI_SECTOR(blksize) (1024 / (blksize)) 570#define HFS_PRI_OFFSET(blksize) ((blksize) > 1024 ? 1024 : 0) 571 572#define HFS_ALT_SECTOR(blksize, blkcnt) (((blkcnt) - 1) - (512 / (blksize))) 573#define HFS_ALT_OFFSET(blksize) ((blksize) > 1024 ? (blksize) - 1024 : 0) 574 575/* Convert the logical sector number to be aligned on physical block size boundary. 576 * We are assuming the partition is a multiple of physical block size. 577 */ 578#define HFS_PHYSBLK_ROUNDDOWN(sector_num, log_per_phys) ((sector_num / log_per_phys) * log_per_phys) 579 580/* 581 * HFS specific fcntl()'s 582 */ 583#define HFS_GET_BOOT_INFO (FCNTL_FS_SPECIFIC_BASE + 0x00004) 584#define HFS_SET_BOOT_INFO (FCNTL_FS_SPECIFIC_BASE + 0x00005) 585/* See HFSIOC_EXT_BULKACCESS and friends for HFS specific fsctls*/ 586 587 588 589/* 590 * This is the straight GMT conversion constant: 591 * 00:00:00 January 1, 1970 - 00:00:00 January 1, 1904 592 * (3600 * 24 * ((365 * (1970 - 1904)) + (((1970 - 1904) / 4) + 1))) 593 */ 594#define MAC_GMT_FACTOR 2082844800UL 595 596static inline __attribute__((const)) 597uint64_t hfs_blk_to_bytes(uint32_t blk, uint32_t blk_size) 598{ 599 return (uint64_t)blk * blk_size; // Avoid the overflow 600} 601 602/***************************************************************************** 603 FUNCTION PROTOTYPES 604******************************************************************************/ 605 606/***************************************************************************** 607 hfs_vnop_xxx functions from different files 608******************************************************************************/ 609int hfs_vnop_readdirattr(struct vnop_readdirattr_args *); /* in hfs_attrlist.c */ 610int hfs_vnop_getattrlistbulk(struct vnop_getattrlistbulk_args *); /* in hfs_attrlist.c */ 611 612int hfs_vnop_inactive(struct vnop_inactive_args *); /* in hfs_cnode.c */ 613int hfs_vnop_reclaim(struct vnop_reclaim_args *); /* in hfs_cnode.c */ 614 615int hfs_set_backingstore (struct vnode *vp, int val); /* in hfs_cnode.c */ 616int hfs_is_backingstore (struct vnode *vp, int *val); /* in hfs_cnode.c */ 617 618int hfs_vnop_link(struct vnop_link_args *); /* in hfs_link.c */ 619 620int hfs_vnop_lookup(struct vnop_lookup_args *); /* in hfs_lookup.c */ 621 622int hfs_vnop_search(struct vnop_searchfs_args *); /* in hfs_search.c */ 623 624int hfs_vnop_read(struct vnop_read_args *); /* in hfs_readwrite.c */ 625int hfs_vnop_write(struct vnop_write_args *); /* in hfs_readwrite.c */ 626int hfs_vnop_ioctl(struct vnop_ioctl_args *); /* in hfs_readwrite.c */ 627int hfs_vnop_select(struct vnop_select_args *); /* in hfs_readwrite.c */ 628int hfs_vnop_strategy(struct vnop_strategy_args *); /* in hfs_readwrite.c */ 629int hfs_vnop_allocate(struct vnop_allocate_args *); /* in hfs_readwrite.c */ 630int hfs_vnop_pagein(struct vnop_pagein_args *); /* in hfs_readwrite.c */ 631int hfs_vnop_pageout(struct vnop_pageout_args *); /* in hfs_readwrite.c */ 632int hfs_vnop_bwrite(struct vnop_bwrite_args *); /* in hfs_readwrite.c */ 633int hfs_vnop_blktooff(struct vnop_blktooff_args *); /* in hfs_readwrite.c */ 634int hfs_vnop_offtoblk(struct vnop_offtoblk_args *); /* in hfs_readwrite.c */ 635int hfs_vnop_blockmap(struct vnop_blockmap_args *); /* in hfs_readwrite.c */ 636 637int hfs_vnop_getxattr(struct vnop_getxattr_args *); /* in hfs_xattr.c */ 638int hfs_vnop_setxattr(struct vnop_setxattr_args *); /* in hfs_xattr.c */ 639int hfs_vnop_removexattr(struct vnop_removexattr_args *); /* in hfs_xattr.c */ 640int hfs_vnop_listxattr(struct vnop_listxattr_args *); /* in hfs_xattr.c */ 641#if NAMEDSTREAMS 642extern int hfs_vnop_getnamedstream(struct vnop_getnamedstream_args*); 643extern int hfs_vnop_makenamedstream(struct vnop_makenamedstream_args*); 644extern int hfs_vnop_removenamedstream(struct vnop_removenamedstream_args*); 645#endif 646 647 648/***************************************************************************** 649 Functions from MacOSStubs.c 650******************************************************************************/ 651time_t to_bsd_time(u_int32_t hfs_time); 652 653u_int32_t to_hfs_time(time_t bsd_time); 654 655 656/***************************************************************************** 657 Functions from hfs_encodinghint.c 658******************************************************************************/ 659u_int32_t hfs_pickencoding(const u_int16_t *src, int len); 660 661u_int32_t hfs_getencodingbias(void); 662 663void hfs_setencodingbias(u_int32_t bias); 664 665 666/***************************************************************************** 667 Functions from hfs_encodings.c 668******************************************************************************/ 669void hfs_converterinit(void); 670 671int hfs_relconverter (u_int32_t encoding); 672 673int hfs_getconverter(u_int32_t encoding, hfs_to_unicode_func_t *get_unicode, 674 unicode_to_hfs_func_t *get_hfsname); 675 676#if CONFIG_HFS_STD 677int hfs_to_utf8(ExtendedVCB *vcb, const Str31 hfs_str, ByteCount maxDstLen, 678 ByteCount *actualDstLen, unsigned char* dstStr); 679 680int utf8_to_hfs(ExtendedVCB *vcb, ByteCount srcLen, const unsigned char* srcStr, 681 Str31 dstStr); 682 683int mac_roman_to_utf8(const Str31 hfs_str, ByteCount maxDstLen, ByteCount *actualDstLen, 684 unsigned char* dstStr); 685 686int utf8_to_mac_roman(ByteCount srcLen, const unsigned char* srcStr, Str31 dstStr); 687 688int mac_roman_to_unicode(const Str31 hfs_str, UniChar *uni_str, u_int32_t maxCharLen, u_int32_t *usedCharLen); 689 690int unicode_to_hfs(ExtendedVCB *vcb, ByteCount srcLen, u_int16_t* srcStr, Str31 dstStr, int retry); 691#endif 692 693/***************************************************************************** 694 Functions from hfs_notifications.c 695******************************************************************************/ 696void hfs_generate_volume_notifications(struct hfsmount *hfsmp); 697 698 699/***************************************************************************** 700 Functions from hfs_readwrite.c 701******************************************************************************/ 702extern int hfs_relocate(struct vnode *, u_int32_t, kauth_cred_t, struct proc *); 703 704/* Flags for HFS truncate */ 705#define HFS_TRUNCATE_SKIPUPDATE 0x00000001 706#define HFS_TRUNCATE_SKIPTIMES 0x00000002 /* implied by skipupdate; it is a subset */ 707 708 709extern int hfs_truncate(struct vnode *, off_t, int, int, vfs_context_t); 710 711extern int hfs_release_storage (struct hfsmount *hfsmp, struct filefork *datafork, 712 struct filefork *rsrcfork, u_int32_t fileid); 713 714extern int hfs_prepare_release_storage (struct hfsmount *hfsmp, struct vnode *vp); 715 716extern int hfs_bmap(struct vnode *, daddr_t, struct vnode **, daddr64_t *, unsigned int *); 717 718extern int hfs_fsync(struct vnode *, int, int, struct proc *); 719 720extern int hfs_access(struct vnode *, mode_t, kauth_cred_t, struct proc *); 721 722extern int hfs_removeallattr(struct hfsmount *hfsmp, u_int32_t fileid); 723 724extern int hfs_set_volxattr(struct hfsmount *hfsmp, unsigned int xattrtype, int state); 725 726extern int hfs_isallocated(struct hfsmount *hfsmp, u_int32_t startingBlock, u_int32_t numBlocks); 727 728extern int hfs_count_allocated(struct hfsmount *hfsmp, u_int32_t startBlock, 729 u_int32_t numBlocks, u_int32_t *alloc_count); 730 731extern int hfs_isrbtree_active (struct hfsmount *hfsmp); 732extern errno_t hfs_ubc_setsize(vnode_t vp, off_t len, bool have_cnode_lock); 733 734 735/***************************************************************************** 736 Functions from hfs_resize.c 737******************************************************************************/ 738int hfs_extendfs(struct hfsmount *hfsmp, u_int64_t newsize, vfs_context_t context); 739int hfs_truncatefs(struct hfsmount *hfsmp, u_int64_t newsize, vfs_context_t context); 740 741 742/***************************************************************************** 743 Functions from hfs_vfsops.c 744******************************************************************************/ 745int hfs_mountroot(mount_t mp, vnode_t rvp, vfs_context_t context); 746 747/* used as a callback by the journaling code */ 748extern void hfs_sync_metadata(void *arg); 749 750extern int hfs_vget(struct hfsmount *, cnid_t, struct vnode **, int, int); 751 752extern void hfs_setencodingbits(struct hfsmount *hfsmp, u_int32_t encoding); 753 754enum volop {VOL_UPDATE, VOL_MKDIR, VOL_RMDIR, VOL_MKFILE, VOL_RMFILE}; 755extern int hfs_volupdate(struct hfsmount *hfsmp, enum volop op, int inroot); 756 757int hfs_flushvolumeheader(struct hfsmount *hfsmp, int waitfor, int altflush); 758#define HFS_ALTFLUSH 1 759 760extern int hfs_extendfs(struct hfsmount *, u_int64_t, vfs_context_t); 761extern int hfs_truncatefs(struct hfsmount *, u_int64_t, vfs_context_t); 762extern int hfs_resize_progress(struct hfsmount *, u_int32_t *); 763 764/* If a runtime corruption is detected, mark the volume inconsistent 765 * bit in the volume attributes. 766 */ 767 768typedef enum { 769 HFS_INCONSISTENCY_DETECTED, 770 771 // Used when unable to rollback an operation that failed 772 HFS_ROLLBACK_FAILED, 773 774 // Used when the latter part of an operation failed, but we chose not to roll back 775 HFS_OP_INCOMPLETE, 776 777 // Used when someone told us to force an fsck on next mount 778 HFS_FSCK_FORCED, 779} hfs_inconsistency_reason_t; 780 781void hfs_mark_inconsistent(struct hfsmount *hfsmp, 782 hfs_inconsistency_reason_t reason); 783 784void hfs_scan_blocks (struct hfsmount *hfsmp); 785 786/***************************************************************************** 787 Functions from hfs_vfsutils.c 788******************************************************************************/ 789u_int32_t BestBlockSizeFit(u_int32_t allocationBlockSize, 790 u_int32_t blockSizeLimit, 791 u_int32_t baseMultiple); 792 793#if CONFIG_HFS_STD 794OSErr hfs_MountHFSVolume(struct hfsmount *hfsmp, HFSMasterDirectoryBlock *mdb, 795 struct proc *p); 796#endif 797OSErr hfs_MountHFSPlusVolume(struct hfsmount *hfsmp, HFSPlusVolumeHeader *vhp, 798 off_t embeddedOffset, u_int64_t disksize, struct proc *p, void *args, kauth_cred_t cred); 799 800extern int hfsUnmount(struct hfsmount *hfsmp, struct proc *p); 801 802extern bool overflow_extents(struct filefork *fp); 803 804extern int hfs_owner_rights(struct hfsmount *hfsmp, uid_t cnode_uid, kauth_cred_t cred, 805 struct proc *p, int invokesuperuserstatus); 806 807extern int check_for_tracked_file(struct vnode *vp, time_t ctime, uint64_t op_type, void *arg); 808extern int check_for_dataless_file(struct vnode *vp, uint64_t op_type); 809extern int hfs_generate_document_id(struct hfsmount *hfsmp, uint32_t *docid); 810 811/* Return information about number of metadata blocks for volume */ 812extern int hfs_getinfo_metadata_blocks(struct hfsmount *hfsmp, struct hfsinfo_metadata *hinfo); 813 814/* 815 * Journal lock function prototypes 816 */ 817int hfs_lock_global (struct hfsmount *hfsmp, enum hfs_locktype locktype); 818void hfs_unlock_global (struct hfsmount *hfsmp); 819 820/* HFS mount lock/unlock prototypes */ 821void hfs_lock_mount (struct hfsmount *hfsmp); 822void hfs_unlock_mount (struct hfsmount *hfsmp); 823 824 825/* HFS System file locking */ 826#define SFL_CATALOG 0x0001 827#define SFL_EXTENTS 0x0002 828#define SFL_BITMAP 0x0004 829#define SFL_ATTRIBUTE 0x0008 830#define SFL_STARTUP 0x0010 831#define SFL_VM_PRIV 0x0020 832#define SFL_VALIDMASK (SFL_CATALOG | SFL_EXTENTS | SFL_BITMAP | SFL_ATTRIBUTE | SFL_STARTUP | SFL_VM_PRIV) 833 834extern int hfs_systemfile_lock(struct hfsmount *, int, enum hfs_locktype); 835extern void hfs_systemfile_unlock(struct hfsmount *, int); 836 837extern u_int32_t GetFileInfo(ExtendedVCB *vcb, u_int32_t dirid, const char *name, 838 struct cat_attr *fattr, struct cat_fork *forkinfo); 839 840extern void hfs_remove_orphans(struct hfsmount *); 841 842u_int32_t GetLogicalBlockSize(struct vnode *vp); 843 844extern u_int32_t hfs_freeblks(struct hfsmount * hfsmp, int wantreserve); 845 846short MacToVFSError(OSErr err); 847 848void hfs_metadatazone_init(struct hfsmount *hfsmp, int disable); 849 850/* HFS directory hint functions. */ 851extern directoryhint_t * hfs_getdirhint(struct cnode *, int, int); 852extern void hfs_reldirhint(struct cnode *, directoryhint_t *); 853extern void hfs_reldirhints(struct cnode *, int); 854extern void hfs_insertdirhint(struct cnode *, directoryhint_t *); 855 856extern int hfs_namecmp(const u_int8_t *str1, size_t len1, const u_int8_t *str2, size_t len2); 857 858extern int hfs_early_journal_init(struct hfsmount *hfsmp, HFSPlusVolumeHeader *vhp, 859 void *_args, off_t embeddedOffset, daddr64_t mdb_offset, 860 HFSMasterDirectoryBlock *mdbp, kauth_cred_t cred); 861 862extern int hfs_virtualmetafile(struct cnode *); 863 864extern int hfs_start_transaction(struct hfsmount *hfsmp); 865extern int hfs_end_transaction(struct hfsmount *hfsmp); 866extern void hfs_journal_lock(struct hfsmount *hfsmp); 867extern void hfs_journal_unlock(struct hfsmount *hfsmp); 868extern int hfs_journal_flush(struct hfsmount *hfsmp, boolean_t wait_for_IO); 869extern void hfs_syncer_lock(struct hfsmount *hfsmp); 870extern void hfs_syncer_unlock(struct hfsmount *hfsmp); 871extern void hfs_syncer_wait(struct hfsmount *hfsmp); 872extern void hfs_syncer_wakeup(struct hfsmount *hfsmp); 873extern void hfs_syncer_queue(thread_call_t syncer); 874extern void hfs_sync_ejectable(struct hfsmount *hfsmp); 875 876extern void hfs_trim_callback(void *arg, uint32_t extent_count, const dk_extent_t *extents); 877 878/* Erase unused Catalog nodes due to <rdar://problem/6947811>. */ 879extern int hfs_erase_unused_nodes(struct hfsmount *hfsmp); 880 881extern uint64_t hfs_usecs_to_deadline(uint64_t usecs); 882 883extern int hfs_freeze(struct hfsmount *hfsmp); 884extern int hfs_thaw(struct hfsmount *hfsmp, const struct proc *process); 885 886 887/***************************************************************************** 888 Functions from hfs_vnops.c 889******************************************************************************/ 890int hfs_write_access(struct vnode *vp, kauth_cred_t cred, struct proc *p, Boolean considerFlags); 891 892int hfs_chmod(struct vnode *vp, int mode, kauth_cred_t cred, struct proc *p); 893 894int hfs_chown(struct vnode *vp, uid_t uid, gid_t gid, kauth_cred_t cred, struct proc *p); 895 896#define kMaxSecsForFsync 5 897#define HFS_SYNCTRANS 1 898extern int hfs_btsync(struct vnode *vp, int sync_transaction); 899 900extern void replace_desc(struct cnode *cp, struct cat_desc *cdp); 901 902extern int hfs_vgetrsrc(struct hfsmount *hfsmp, struct vnode *vp, 903 struct vnode **rvpp); 904 905extern int hfs_update(struct vnode *, int); 906 907 908/***************************************************************************** 909 Functions from hfs_xattr.c 910******************************************************************************/ 911 912/* 913 * Maximum extended attribute size supported for all extended attributes except 914 * resource fork and finder info. 915 */ 916#define HFS_XATTR_MAXSIZE INT32_MAX 917 918/* Number of bits used to represent maximum extended attribute size */ 919#define HFS_XATTR_SIZE_BITS 31 920 921int hfs_attrkeycompare(HFSPlusAttrKey *searchKey, HFSPlusAttrKey *trialKey); 922int hfs_buildattrkey(u_int32_t fileID, const char *attrname, HFSPlusAttrKey *key); 923void hfs_xattr_init(struct hfsmount * hfsmp); 924int file_attribute_exist(struct hfsmount *hfsmp, uint32_t fileID); 925int init_attrdata_vnode(struct hfsmount *hfsmp); 926int hfs_xattr_read(vnode_t vp, const char *name, void *data, size_t *size); 927int hfs_getxattr_internal(cnode_t *, struct vnop_getxattr_args *, 928 struct hfsmount *, u_int32_t); 929int hfs_xattr_write(vnode_t vp, const char *name, const void *data, size_t size); 930int hfs_setxattr_internal(struct cnode *, const void *, size_t, 931 struct vnop_setxattr_args *, struct hfsmount *, u_int32_t); 932 933 934/***************************************************************************** 935 Functions from hfs_link.c 936******************************************************************************/ 937 938extern int hfs_unlink(struct hfsmount *hfsmp, struct vnode *dvp, struct vnode *vp, 939 struct componentname *cnp, int skip_reserve); 940extern int hfs_lookup_siblinglinks(struct hfsmount *hfsmp, cnid_t linkfileid, 941 cnid_t *prevlinkid, cnid_t *nextlinkid); 942extern int hfs_lookup_lastlink(struct hfsmount *hfsmp, cnid_t linkfileid, 943 cnid_t *nextlinkid, struct cat_desc *cdesc); 944extern void hfs_privatedir_init(struct hfsmount *, enum privdirtype); 945 946extern void hfs_savelinkorigin(cnode_t *cp, cnid_t parentcnid); 947extern void hfs_relorigins(struct cnode *cp); 948extern void hfs_relorigin(struct cnode *cp, cnid_t parentcnid); 949extern int hfs_haslinkorigin(cnode_t *cp); 950extern cnid_t hfs_currentparent(cnode_t *cp); 951extern cnid_t hfs_currentcnid(cnode_t *cp); 952 953 954#endif /* __APPLE_API_PRIVATE */ 955#endif /* KERNEL */ 956#endif /* __HFS__ */ 957