hfs_util/hfsutil_jnl.c

   1 /*
   2  * Copyright (c) 1999-2001 Apple Computer, Inc. All rights reserved.
   3  *
   4  * @APPLE_LICENSE_HEADER_START@
   5  *
   6  * The contents of this file constitute Original Code as defined in and
   7  * are subject to the Apple Public Source License Version 1.2 (the
   8  * "License").  You may not use this file except in compliance with the
   9  * License.  Please obtain a copy of the License at
  10  * http://www.apple.com/publicsource and read it before using this file.
  11  *
  12  * This Original Code and all software distributed under the License are
  13  * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  14  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  15  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  16  * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
  17  * License for the specific language governing rights and limitations
  18  * under the License.
  19  *
  20  * @APPLE_LICENSE_HEADER_END@
  21  */
  22 /*
  23  Copyright (c) 2002 Apple Computer, Inc.
  24  All Rights Reserved.
  25
  26  This file contains the routine to make an HFS+ volume journaled
  27  and a corresponding routine to turn it off.
  28
  29  */
  30
  31 #include <sys/types.h>
  32 #include <sys/attr.h>
  33 #include <sys/stat.h>
  34 #include <sys/time.h>
  35 #include <sys/sysctl.h>
  36 #include <sys/resource.h>
  37 #include <sys/vmmeter.h>
  38 #include <sys/mount.h>
  39 #include <sys/wait.h>
  40 #include <sys/ioctl.h>
  41
  42 #include <sys/disk.h>
  43 #include <sys/loadable_fs.h>
  44 #include <hfs/hfs_format.h>
  45 #include <hfs/hfs_mount.h>    /* for hfs sysctl values */
  46
  47 #include <errno.h>
  48 #include <fcntl.h>
  49 #include <libgen.h>
  50 #include <pwd.h>
  51 #include <stdio.h>
  52 #include <stdlib.h>
  53 #include <string.h>
  54 #include <unistd.h>
  55
  56 #include <architecture/byte_order.h>
  57
  58 // just in case these aren't in <hfs/hfs_mount.h> yet
  59 #ifndef HFS_ENABLE_JOURNALING
  60 #define HFS_ENABLE_JOURNALING   0x082969
  61 #endif
  62 #ifndef HFS_DISABLE_JOURNALING
  63 #define HFS_DISABLE_JOURNALING 0x031272
  64 #endif
  65 #ifndef HFS_GET_JOURNAL_INFO
  66 #define HFS_GET_JOURNAL_INFO    0x6a6e6c69
  67 #endif
  68
  69 /* getattrlist buffers start with an extra length field */
  70 struct ExtentsAttrBuf {
  71         unsigned long   infoLength;
  72         HFSPlusExtentRecord     extents;
  73 };
  74 typedef struct ExtentsAttrBuf ExtentsAttrBuf;
  75
  76
  77
  78 #define kIsInvisible 0x4000
  79
  80 /*
  81  * Generic Finder file/dir data
  82  */
  83 struct FinderInfo {
  84         u_int32_t       opaque_1[2];
  85         u_int16_t       fdFlags;        /* Finder flags */
  86         int16_t         opaque_2[11];
  87 };
  88 typedef struct FinderInfo FinderInfo;
  89
  90 /* getattrlist buffers start with an extra length field */
  91 struct FinderAttrBuf {
  92         unsigned long   infoLength;
  93         FinderInfo      finderInfo;
  94 };
  95 typedef struct FinderAttrBuf FinderAttrBuf;
  96
  97
  98 int hide_file(const char * file)
  99 {
 100     struct attrlist alist = {0};
 101     FinderAttrBuf finderInfoBuf = {0};
 102     int result;
 103
 104     alist.bitmapcount = ATTR_BIT_MAP_COUNT;
 105     alist.commonattr = ATTR_CMN_FNDRINFO;
 106
 107     result = getattrlist(file, &alist, &finderInfoBuf, sizeof(finderInfoBuf), 0);
 108     if (result) {
 109         return (errno);
 110     }
 111
 112     if (finderInfoBuf.finderInfo.fdFlags & kIsInvisible) {
 113         printf("hide: %s is alreadly invisible\n", file);
 114         return (0);
 115     }
 116
 117     finderInfoBuf.finderInfo.fdFlags |= kIsInvisible;
 118
 119     result = setattrlist(file, &alist, &finderInfoBuf.finderInfo, sizeof(FinderInfo), 0);
 120
 121     return (result == -1 ? errno : result);
 122 }
 123
 124 off_t
 125 get_start_block(const char *file, uint32_t fs_block_size)
 126 {
 127     off_t cur_pos, phys_start, len;
 128     int fd, err;
 129     struct log2phys l2p;
 130     struct stat st;
 131
 132     fd = open(file, O_RDONLY);
 133     if (fd < 0) {
 134         return -1;
 135     }
 136
 137     if (fstat(fd, &st) < 0) {
 138         fprintf(stderr, "can't stat %s (%s)\n", file, strerror(errno));
 139         close(fd);
 140         return -1;
 141     }
 142
 143     fs_block_size = st.st_blksize; // XXXdbg quick hack for now
 144
 145     phys_start = len = 0;
 146     for(cur_pos=0; cur_pos < st.st_size; cur_pos += fs_block_size) {
 147         memset(&l2p, 0, sizeof(l2p));
 148         lseek(fd, cur_pos, SEEK_SET);
 149         err = fcntl(fd, F_LOG2PHYS, &l2p);
 150
 151         if (phys_start == 0) {
 152             phys_start = l2p.l2p_devoffset;
 153             len = fs_block_size;
 154         } else if (l2p.l2p_devoffset != (phys_start + len)) {
 155             // printf("    %lld : %lld - %lld\n", cur_pos, phys_start / fs_block_size, len / fs_block_size);
 156             fprintf(stderr, "%s : is not contiguous!\n", file);
 157             close(fd);
 158             return -1;
 159             // phys_start = l2p.l2p_devoffset;
 160             // len = fs_block_size;
 161         } else {
 162             len += fs_block_size;
 163         }
 164     }
 165
 166     close(fd);
 167
 168     //printf("%s start offset %lld; byte len %lld (blksize %d)\n",
 169     // file, phys_start, len, fs_block_size);
 170
 171     if ((phys_start / (unsigned)fs_block_size) & 0xffffffff00000000LL) {
 172         fprintf(stderr, "%s : starting block is > 32bits!\n", file);
 173         return -1;
 174     }
 175
 176     return phys_start;
 177 }
 178
 179
 180 //
 181 // Get the embedded offset (if any) for an hfs+ volume.
 182 // This is pretty skanky that we have to do this but
 183 // that's life...
 184 //
 185 #include <sys/disk.h>
 186 #include <hfs/hfs_format.h>
 187
 188 #include <machine/endian.h>
 189
 190 #define HFS_PRI_SECTOR(blksize)          (1024 / (blksize))
 191 #define HFS_PRI_OFFSET(blksize)          ((blksize) > 1024 ? 1024 : 0)
 192
 193 #define SWAP_BE16(x) ntohs(x)
 194 #define SWAP_BE32(x) ntohl(x)
 195
 196
 197 off_t
 198 get_embedded_offset(char *devname)
 199 {
 200     int fd = -1;
 201     off_t ret = 0;
 202     char *buff = NULL, rawdev[256];
 203     u_int64_t blkcnt;
 204     u_int32_t blksize;
 205     HFSMasterDirectoryBlock *mdbp;
 206     off_t embeddedOffset;
 207     struct statfs sfs;
 208     struct stat   st;
 209
 210   restart:
 211     if (stat(devname, &st) != 0) {
 212         fprintf(stderr, "Could not access %s (%s)\n", devname, strerror(errno));
 213         ret = -1;
 214         goto out;
 215     }
 216
 217     if (S_ISCHR(st.st_mode) == 0) {
 218         // hmmm, it's not the character special raw device so we
 219         // should try to figure out the real device.
 220         if (statfs(devname, &sfs) != 0) {
 221             fprintf(stderr, "Can't find out any info about the fs for path %s (%s)\n",
 222                 devname, strerror(errno));
 223             ret = -1;
 224             goto out;
 225         }
 226
 227         // copy the "/dev/"
 228         strncpy(rawdev, sfs.f_mntfromname, 5);
 229         rawdev[5] = 'r';
 230         strcpy(&rawdev[6], &sfs.f_mntfromname[5]);
 231         devname = &rawdev[0];
 232         goto restart;
 233     }
 234
 235     fd = open(devname, O_RDONLY);
 236     if (fd < 0) {
 237         fprintf(stderr, "can't open: %s (%s)\n", devname, strerror(errno));
 238         ret = -1;
 239         goto out;
 240     }
 241
 242     /* Get the real physical block size. */
 243     if (ioctl(fd, DKIOCGETBLOCKSIZE, (caddr_t)&blksize) != 0) {
 244         fprintf(stderr, "can't get the device block size (%s). assuming 512\n", strerror(errno));
 245         blksize = 512;
 246         ret = -1;
 247         goto out;
 248     }
 249
 250     /* Get the number of physical blocks. */
 251     if (ioctl(fd, DKIOCGETBLOCKCOUNT, (caddr_t)&blkcnt)) {
 252         struct stat st;
 253         fprintf(stderr, "failed to get block count. trying stat().\n");
 254         if (fstat(fd, &st) != 0) {
 255             ret = -1;
 256             goto out;
 257         }
 258
 259         blkcnt = st.st_size / blksize;
 260     }
 261
 262     /*
 263      * At this point:
 264      *   blksize has our prefered physical block size
 265      *   blkcnt has the total number of physical blocks
 266      */
 267
 268     buff = (char *)malloc(blksize);
 269
 270     if (pread(fd, buff, blksize, HFS_PRI_SECTOR(blksize)*blksize) != blksize) {
 271         fprintf(stderr, "failed to read volume header @ offset %d (%s)\n",
 272             HFS_PRI_SECTOR(blksize), strerror(errno));
 273         ret = -1;
 274         goto out;
 275     }
 276
 277     mdbp = (HFSMasterDirectoryBlock *)buff;
 278     if (   (SWAP_BE16(mdbp->drSigWord) != kHFSSigWord)
 279         && (SWAP_BE16(mdbp->drSigWord) != kHFSPlusSigWord)
 280         && (SWAP_BE16(mdbp->drSigWord) != kHFSXSigWord)) {
 281         ret = -1;
 282         goto out;
 283     }
 284
 285     if ((SWAP_BE16(mdbp->drSigWord) == kHFSSigWord) && (SWAP_BE16(mdbp->drEmbedSigWord) != kHFSPlusSigWord)) {
 286         ret = -1;
 287         goto out;
 288     } else if (SWAP_BE16(mdbp->drEmbedSigWord) == kHFSPlusSigWord) {
 289         /* Get the embedded Volume Header */
 290         embeddedOffset = SWAP_BE16(mdbp->drAlBlSt) * 512;
 291         embeddedOffset += (u_int64_t)SWAP_BE16(mdbp->drEmbedExtent.startBlock) *
 292                           (u_int64_t)SWAP_BE32(mdbp->drAlBlkSiz);
 293
 294         /*
 295          * If the embedded volume doesn't start on a block
 296          * boundary, then switch the device to a 512-byte
 297          * block size so everything will line up on a block
 298          * boundary.
 299          */
 300         if ((embeddedOffset % blksize) != 0) {
 301             fprintf(stderr, "HFS Mount: embedded volume offset not"
 302                 " a multiple of physical block size (%d);"
 303                 " switching to 512\n", blksize);
 304
 305             blkcnt  *= (blksize / 512);
 306             blksize  = 512;
 307         }
 308
 309     } else { /* pure HFS+ */
 310         embeddedOffset = 0;
 311     }
 312
 313     ret = embeddedOffset;
 314
 315   out:
 316     if (buff) {
 317         free(buff);
 318     }
 319     if (fd >= 0)
 320         close(fd);
 321
 322     return ret;
 323 }
 324
 325
 326
 327 static const char *journal_fname = ".journal";
 328 static const char *jib_fname = ".journal_info_block";
 329
 330 int
 331 DoMakeJournaled(char *volname, int jsize)
 332 {
 333     int              fd, i, block_size, journal_size = 8*1024*1024;
 334     char            *buf;
 335     int              ret;
 336     fstore_t         fst;
 337     int32_t          jstart_block, jinfo_block;
 338     int              sysctl_info[8];
 339     JournalInfoBlock jib;
 340     struct statfs    sfs;
 341     static char      tmpname[MAXPATHLEN];
 342     off_t            start_block, embedded_offset;
 343
 344     if (statfs(volname, &sfs) != 0) {
 345         fprintf(stderr, "Can't stat volume %s (%s).\n", volname, strerror(errno));
 346         return 10;
 347     }
 348
 349     // Make sure that we're HFS+.  First we check the fstypename.
 350     // If that's ok then we try to create a symlink (which won't
 351     // work on plain hfs volumes but will work on hfs+ volumes).
 352     //
 353     sprintf(tmpname, "%s/is_vol_hfs_plus", volname);
 354     if (strcmp(sfs.f_fstypename, "hfs") != 0 ||
 355         ((ret = symlink(tmpname, tmpname)) != 0 && errno == ENOTSUP)) {
 356         fprintf(stderr, "%s is not an HFS+ volume.  Journaling only works on HFS+ volumes.\n",
 357                 volname);
 358         return 10;
 359     }
 360     unlink(tmpname);
 361
 362     if (sfs.f_flags & MNT_JOURNALED) {
 363         fprintf(stderr, "Volume %s is already journaled.\n", volname);
 364         return 1;
 365     }
 366
 367     if (jsize != 0) {
 368         journal_size = jsize;
 369     } else {
 370         int scale;
 371
 372         //
 373         // we want at least 8 megs of journal for each 100 gigs of
 374         // disk space.  We cap the size at 512 megs though.
 375         //
 376         scale = ((long long)sfs.f_bsize * (long long)((unsigned)sfs.f_blocks)) / (100*1024*1024*1024ULL);
 377         journal_size *= (scale + 1);
 378         if (journal_size > 512 * 1024 * 1024) {
 379             journal_size = 512 * 1024 * 1024;
 380         }
 381     }
 382
 383     if (chdir(volname) != 0) {
 384         fprintf(stderr, "Can't locate volume %s to make it journaled (%s).\n",
 385                 volname, strerror(errno));
 386         return 10;
 387     }
 388
 389
 390     embedded_offset = get_embedded_offset(volname);
 391     if (embedded_offset < 0) {
 392         fprintf(stderr, "Can't calculate the embedded offset (if any) for %s.\n", volname);
 393         fprintf(stderr, "Journal creation failure.\n");
 394         return 15;
 395     }
 396     // printf("Embedded offset == 0x%llx\n", embedded_offset);
 397
 398     fd = open(journal_fname, O_CREAT|O_TRUNC|O_RDWR, 000);
 399     if (fd < 0) {
 400         fprintf(stderr, "Can't create journal file on volume %s (%s)\n",
 401                 volname, strerror(errno));
 402         return 5;
 403     }
 404
 405     // make sure that it has no r/w/x privs (only could happen if
 406     // the file already existed since open() doesn't reset the mode
 407     // bits).
 408     //
 409     fchmod(fd, 0);
 410
 411     block_size = sfs.f_bsize;
 412     if ((journal_size % block_size) != 0) {
 413         fprintf(stderr, "Journal size %dk is not a multiple of volume %s block size (%d).\n",
 414                 journal_size/1024, volname, block_size);
 415         close(fd);
 416         unlink(journal_fname);
 417         return 5;
 418     }
 419
 420   retry:
 421     memset(&fst, 0, sizeof(fst));
 422     fst.fst_flags   = F_ALLOCATECONTIG|F_ALLOCATEALL;
 423     fst.fst_length  = journal_size;
 424     fst.fst_posmode = F_PEOFPOSMODE;
 425
 426     ret = fcntl(fd, F_PREALLOCATE, &fst);
 427     if (ret < 0) {
 428         if (journal_size >= 2*1024*1024) {
 429             fprintf(stderr, "Not enough contiguous space for a %d k journal.  Retrying.\n",
 430                     journal_size/1024);
 431             journal_size /= 2;
 432             ftruncate(fd, 0);     // make sure the file is zero bytes long.
 433             goto retry;
 434         } else {
 435             fprintf(stderr, "Disk too fragmented to enable journaling.\n");
 436             fprintf(stderr, "Please run a defragmenter on %s.\n", volname);
 437             close(fd);
 438             unlink(journal_fname);
 439             return 10;
 440         }
 441     }
 442
 443     printf("Allocated %lldK for journal file.\n", fst.fst_bytesalloc/1024LL);
 444     buf = (char *)calloc(block_size, 1);
 445     if (buf) {
 446         for(i=0; i < journal_size/block_size; i++) {
 447             ret = write(fd, buf, block_size);
 448             if (ret != block_size) {
 449                 break;
 450             }
 451         }
 452
 453         if (i*block_size != journal_size) {
 454             fprintf(stderr, "Failed to write %dk to journal on volume %s (%s)\n",
 455                     journal_size/1024, volname, strerror(errno));
 456         }
 457     } else {
 458         printf("Could not allocate memory to write to the journal on volume %s (%s)\n",
 459                volname, strerror(errno));
 460     }
 461
 462     fsync(fd);
 463     close(fd);
 464     hide_file(journal_fname);
 465
 466     start_block = get_start_block(journal_fname, block_size);
 467     if (start_block == (off_t)-1) {
 468         fprintf(stderr, "Failed to get start block for %s (%s)\n",
 469                 journal_fname, strerror(errno));
 470         unlink(journal_fname);
 471         return 20;
 472     }
 473     jstart_block = (start_block / block_size) - (embedded_offset / block_size);
 474
 475     memset(&jib, 'Z', sizeof(jib));
 476     jib.flags  = kJIJournalInFSMask;
 477     jib.offset = (off_t)((unsigned)jstart_block) * (off_t)((unsigned)block_size);
 478     jib.size   = (off_t)((unsigned)journal_size);
 479
 480     fd = open(jib_fname, O_CREAT|O_TRUNC|O_RDWR, 000);
 481     if (fd < 0) {
 482         fprintf(stderr, "Could not create journal info block file on volume %s (%s)\n",
 483                 volname, strerror(errno));
 484         unlink(journal_fname);
 485         return 5;
 486     }
 487
 488     // swap the data before we copy it
 489     jib.flags  = OSSwapBigToHostInt32(jib.flags);
 490     jib.offset = OSSwapBigToHostInt64(jib.offset);
 491     jib.size   = OSSwapBigToHostInt64(jib.size);
 492
 493     memcpy(buf, &jib, sizeof(jib));
 494
 495     // now put it back the way it was
 496     jib.size   = OSSwapBigToHostInt64(jib.size);
 497     jib.offset = OSSwapBigToHostInt64(jib.offset);
 498     jib.flags  = OSSwapBigToHostInt32(jib.flags);
 499
 500     if (write(fd, buf, block_size) != block_size) {
 501         fprintf(stderr, "Failed to write journal info block on volume %s (%s)!\n",
 502                 volname, strerror(errno));
 503         unlink(journal_fname);
 504         return 10;
 505     }
 506
 507     fsync(fd);
 508     close(fd);
 509     hide_file(jib_fname);
 510
 511     start_block = get_start_block(jib_fname, block_size);
 512     if (start_block == (off_t)-1) {
 513         fprintf(stderr, "Failed to get start block for %s (%s)\n",
 514                 jib_fname, strerror(errno));
 515         unlink(journal_fname);
 516         unlink(jib_fname);
 517         return 20;
 518     }
 519     jinfo_block = (start_block / block_size) - (embedded_offset / block_size);
 520
 521
 522     //
 523     // Now make the volume journaled!
 524     //
 525     memset(sysctl_info, 0, sizeof(sysctl_info));
 526     sysctl_info[0] = CTL_VFS;
 527     sysctl_info[1] = sfs.f_fsid.val[1];
 528     sysctl_info[2] = HFS_ENABLE_JOURNALING;
 529     sysctl_info[3] = jinfo_block;
 530     sysctl_info[4] = jstart_block;
 531     sysctl_info[5] = journal_size;
 532
 533     //printf("fs type: 0x%x\n", sysctl_info[1]);
 534     //printf("jinfo block : 0x%x\n", jinfo_block);
 535     //printf("jstart block: 0x%x\n", jstart_block);
 536     //printf("journal size: 0x%x\n", journal_size);
 537
 538     ret = sysctl((void *)sysctl_info, 6, NULL, NULL, NULL, 0);
 539     if (ret != 0) {
 540         fprintf(stderr, "Failed to make volume %s journaled (%s)\n",
 541                 volname, strerror(errno));
 542         unlink(journal_fname);
 543         unlink(jib_fname);
 544         return 20;
 545     }
 546
 547     return 0;
 548 }
 549
 550
 551 int
 552 DoUnJournal(char *volname)
 553 {
 554     int           result;
 555     int           sysctl_info[8];
 556     struct statfs sfs;
 557     char          jbuf[MAXPATHLEN];
 558
 559     if (statfs(volname, &sfs) != 0) {
 560         fprintf(stderr, "Can't stat volume %s (%s).\n", volname, strerror(errno));
 561         return 10;
 562     }
 563
 564     if ((sfs.f_flags & MNT_JOURNALED) == 0) {
 565         fprintf(stderr, "Volume %s is not journaled.\n", volname);
 566         return 1;
 567     }
 568
 569     if (chdir(volname) != 0) {
 570         fprintf(stderr, "Can't locate volume %s to turn off journaling (%s).\n",
 571                 volname, strerror(errno));
 572         return 10;
 573     }
 574
 575     memset(sysctl_info, 0, sizeof(sysctl_info));
 576     sysctl_info[0] = CTL_VFS;
 577     sysctl_info[1] = sfs.f_fsid.val[1];
 578     sysctl_info[2] = HFS_DISABLE_JOURNALING;
 579
 580     result = sysctl((void *)sysctl_info, 3, NULL, NULL, NULL, 0);
 581     if (result != 0) {
 582         fprintf(stderr, "Failed to make volume %s UN-journaled (%s)\n",
 583                 volname, strerror(errno));
 584         return 20;
 585     }
 586
 587     sprintf(jbuf, "%s/%s", volname, journal_fname);
 588     if (unlink(jbuf) != 0) {
 589         fprintf(stderr, "Failed to remove the journal %s (%s)\n",
 590                 jbuf, strerror(errno));
 591     }
 592
 593     sprintf(jbuf, "%s/%s", volname, jib_fname);
 594     if (unlink(jbuf) != 0) {
 595         fprintf(stderr, "Failed to remove the journal info block %s (%s)\n",
 596                 jbuf, strerror(errno));
 597     }
 598
 599     printf("Journaling disabled on %s\n", volname);
 600
 601     return 0;
 602 }
 603
 604
 605 int
 606 DoGetJournalInfo(char *volname)
 607 {
 608     int           result;
 609     int           sysctl_info[8];
 610     struct statfs sfs;
 611     off_t         jstart, jsize;
 612
 613     if (statfs(volname, &sfs) != 0) {
 614         fprintf(stderr, "Can't stat volume %s (%s).\n", volname, strerror(errno));
 615         return 10;
 616     }
 617
 618     if ((sfs.f_flags & MNT_JOURNALED) == 0) {
 619         fprintf(stderr, "Volume %s is not journaled.\n", volname);
 620         return 1;
 621     }
 622
 623     if (chdir(volname) != 0) {
 624         fprintf(stderr, "Can't cd to volume %s to get journal info (%s).\n",
 625                 volname, strerror(errno));
 626         return 10;
 627     }
 628
 629     memset(sysctl_info, 0, sizeof(sysctl_info));
 630     sysctl_info[0] = CTL_VFS;
 631     sysctl_info[1] = sfs.f_fsid.val[1];
 632     sysctl_info[2] = HFS_GET_JOURNAL_INFO;
 633     sysctl_info[3] = (int)&jstart;
 634     sysctl_info[4] = (int)&jsize;
 635
 636     result = sysctl((void *)sysctl_info, 5, NULL, NULL, NULL, 0);
 637     if (result != 0) {
 638         fprintf(stderr, "Failed to get journal info for volume %s (%s)\n",
 639                 volname, strerror(errno));
 640         return 20;
 641     }
 642
 643     if (jsize == 0) {
 644         printf("%s : not journaled.\n", volname);
 645     } else {
 646         printf("%s : journal size %lld k at offset 0x%llx\n", volname, jsize/1024, jstart);
 647     }
 648
 649     return 0;
 650 }
 651
 652
 653 int
 654 RawDisableJournaling(char *devname)
 655 {
 656     int fd = -1, ret = 0;
 657     char *buff = NULL, rawdev[256];
 658     u_int64_t disksize;
 659     u_int64_t blkcnt;
 660     u_int32_t blksize;
 661     daddr_t   mdb_offset;
 662     HFSMasterDirectoryBlock *mdbp;
 663     HFSPlusVolumeHeader *vhp;
 664     off_t embeddedOffset, hdr_offset;
 665     struct statfs sfs;
 666     struct stat   st;
 667
 668   restart:
 669     if (stat(devname, &st) != 0) {
 670         fprintf(stderr, "Could not access %s (%s)\n", devname, strerror(errno));
 671         ret = -1;
 672         goto out;
 673     }
 674
 675     if (S_ISCHR(st.st_mode) == 0) {
 676         // hmmm, it's not the character special raw device so we
 677         // should try to figure out the real device.
 678         if (S_ISBLK(st.st_mode)) {
 679             strcpy(rawdev, "/dev/r");
 680             strcat(rawdev, devname + 5);
 681         } else {
 682             if (statfs(devname, &sfs) != 0) {
 683                 fprintf(stderr, "Can't find out any info about the fs for path %s (%s)\n",
 684                     devname, strerror(errno));
 685                 ret = -1;
 686                 goto out;
 687             }
 688
 689             // copy the "/dev/"
 690             strncpy(rawdev, sfs.f_mntfromname, 5);
 691             rawdev[5] = 'r';
 692             strcpy(&rawdev[6], &sfs.f_mntfromname[5]);
 693         }
 694
 695         devname = &rawdev[0];
 696         goto restart;
 697     }
 698
 699     fd = open(devname, O_RDWR);
 700     if (fd < 0) {
 701         fprintf(stderr, "can't open: %s (%s)\n", devname, strerror(errno));
 702         ret = -1;
 703         goto out;
 704     }
 705
 706     /* Get the real physical block size. */
 707     if (ioctl(fd, DKIOCGETBLOCKSIZE, (caddr_t)&blksize) != 0) {
 708         fprintf(stderr, "can't get the device block size (%s). assuming 512\n", strerror(errno));
 709         blksize = 512;
 710         ret = -1;
 711         goto out;
 712     }
 713
 714     /* Get the number of physical blocks. */
 715     if (ioctl(fd, DKIOCGETBLOCKCOUNT, (caddr_t)&blkcnt)) {
 716         struct stat st;
 717
 718         if (fstat(fd, &st) != 0) {
 719             ret = -1;
 720             goto out;
 721         }
 722
 723         blkcnt = st.st_size / blksize;
 724     }
 725
 726     /* Compute an accurate disk size */
 727     disksize = blkcnt * (u_int64_t)blksize;
 728
 729     /*
 730      * There are only 31 bits worth of block count in
 731      * the buffer cache.  So for large volumes a 4K
 732      * physical block size is needed.
 733      */
 734     if (blksize == 512 && blkcnt > (u_int64_t)0x000000007fffffff) {
 735         blksize = 4096;
 736     }
 737
 738     /*
 739      * At this point:
 740      *   blksize has our prefered physical block size
 741      *   blkcnt has the total number of physical blocks
 742      */
 743
 744     buff  = (char *)malloc(blksize);
 745
 746     hdr_offset = HFS_PRI_SECTOR(blksize)*blksize;
 747     if (pread(fd, buff, blksize, hdr_offset) != blksize) {
 748         fprintf(stderr, "failed to read volume header @ offset %lld (%s)\n",
 749             hdr_offset, strerror(errno));
 750         ret = -1;
 751         goto out;
 752     }
 753
 754     // if we read in an empty bunch of junk at location zero, then
 755     // retry at offset 0x400 which is where the header normally is.
 756     if (*(int *)buff == 0 && hdr_offset == 0) {
 757         hdr_offset = 0x400;
 758         if (pread(fd, buff, blksize, hdr_offset) != blksize) {
 759             fprintf(stderr, "failed to read volume header @ offset %lld (%s)\n",
 760                 hdr_offset, strerror(errno));
 761             ret = -1;
 762             goto out;
 763         }
 764     }
 765
 766
 767
 768     mdbp = (HFSMasterDirectoryBlock *)buff;
 769     if ((SWAP_BE16(mdbp->drSigWord) == kHFSSigWord) && (SWAP_BE16(mdbp->drEmbedSigWord) != kHFSPlusSigWord)) {
 770         // normal hfs can not ever be journaled
 771         fprintf(stderr, "disable_journaling: volume is only regular HFS, not HFS+\n");
 772         goto out;
 773     }
 774
 775     /* Get the embedded Volume Header */
 776     if (SWAP_BE16(mdbp->drEmbedSigWord) == kHFSPlusSigWord) {
 777         embeddedOffset = SWAP_BE16(mdbp->drAlBlSt) * 512;
 778         embeddedOffset += (u_int64_t)SWAP_BE16(mdbp->drEmbedExtent.startBlock) * (u_int64_t)SWAP_BE32(mdbp->drAlBlkSiz);
 779
 780         /*
 781          * If the embedded volume doesn't start on a block
 782          * boundary, then switch the device to a 512-byte
 783          * block size so everything will line up on a block
 784          * boundary.
 785          */
 786         if ((embeddedOffset % blksize) != 0) {
 787             fprintf(stderr, "HFS Mount: embedded volume offset not"
 788                 " a multiple of physical block size (%d);"
 789                 " switching to 512\n", blksize);
 790
 791             blkcnt  *= (blksize / 512);
 792             blksize  = 512;
 793         }
 794
 795         disksize = (u_int64_t)SWAP_BE16(mdbp->drEmbedExtent.blockCount) * (u_int64_t)SWAP_BE32(mdbp->drAlBlkSiz);
 796
 797         mdb_offset = (embeddedOffset / blksize) + HFS_PRI_SECTOR(blksize);
 798         hdr_offset = mdb_offset * blksize;
 799         if (pread(fd, buff, blksize, hdr_offset) != blksize) {
 800             fprintf(stderr, "failed to read the embedded vhp @ offset %d\n", mdb_offset * blksize);
 801             ret = -1;
 802             goto out;
 803         }
 804
 805         vhp = (HFSPlusVolumeHeader*) buff;
 806     } else /* pure HFS+ */ {
 807         embeddedOffset = 0;
 808         vhp = (HFSPlusVolumeHeader*) mdbp;
 809     }
 810
 811
 812     if ((SWAP_BE32(vhp->attributes) & kHFSVolumeJournaledMask) != 0) {
 813         unsigned int tmp = SWAP_BE32(vhp->attributes);
 814
 815         tmp &= ~kHFSVolumeJournaledMask;
 816         vhp->attributes = SWAP_BE32(tmp);
 817         if ((tmp = pwrite(fd, buff, blksize, hdr_offset)) != blksize) {
 818             fprintf(stderr, "Update of super-block on %s failed! (%d != %d, %s)\n",
 819                 devname, tmp, blksize, strerror(errno));
 820         } else {
 821             fprintf(stderr, "Turned off the journaling bit for %s\n", devname);
 822         }
 823     } else {
 824         fprintf(stderr, "disable_journaling: volume was not journaled.\n");
 825     }
 826
 827
 828   out:
 829     if (buff)
 830         free(buff);
 831     if (fd >= 0)
 832         close(fd);
 833
 834     return ret;
 835 }