[apple/hfs.git] / hfs_util / hfsutil_jnl.c

/*
 * Copyright (c) 1999-2001 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * The contents of this file constitute Original Code as defined in and
 * are subject to the Apple Public Source License Version 1.1 (the
 * "License").  You may not use this file except in compliance with the
 * License.  Please obtain a copy of the License at
 * http://www.apple.com/publicsource and read it before using this file.
 * 
 * This Original Code and all software distributed under the License are
 * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
 * License for the specific language governing rights and limitations
 * under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@
 */
/*
 Copyright (c) 2002 Apple Computer, Inc.
 All Rights Reserved.

 This file contains the routine to make an HFS+ volume journaled
 and a corresponding routine to turn it off.
 
 */

#include <sys/types.h>
#include <sys/attr.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/sysctl.h>
#include <sys/resource.h>
#include <sys/vmmeter.h>
#include <sys/mount.h>
#include <sys/wait.h>

#include <dev/disk.h>
#include <sys/loadable_fs.h>
#include <hfs/hfs_format.h>

#include <errno.h>
#include <fcntl.h>
#include <libgen.h>
#include <pwd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include <architecture/byte_order.h>

//
// Secret HFS sysctl's to instruct it to turn
// journaling on/off for a volume.
//
#define HFS_BECOME_JOURNALED   0x082969
#define HFS_BECOME_UNJOURNALED 0x031272


/* getattrlist buffers start with an extra length field */
struct ExtentsAttrBuf {
	unsigned long	infoLength;
	HFSPlusExtentRecord	extents;
};
typedef struct ExtentsAttrBuf ExtentsAttrBuf;


#define kIsInvisible 0x4000

/*
 * Generic Finder file/dir data
 */
struct FinderInfo {
	u_int32_t 	opaque_1[2];
	u_int16_t 	fdFlags;	/* Finder flags */
	int16_t 	opaque_2[11];
};
typedef struct FinderInfo FinderInfo;

/* getattrlist buffers start with an extra length field */
struct FinderAttrBuf {
	unsigned long	infoLength;
	FinderInfo	finderInfo;
};
typedef struct FinderAttrBuf FinderAttrBuf;


int hide_file(const char * file)
{
    struct attrlist alist = {0};
    FinderAttrBuf finderInfoBuf = {0};
    int result;
    
    alist.bitmapcount = ATTR_BIT_MAP_COUNT;
    alist.commonattr = ATTR_CMN_FNDRINFO;

    result = getattrlist(file, &alist, &finderInfoBuf, sizeof(finderInfoBuf), 0);
    if (result) {
		return (errno);
	}
	
    if (finderInfoBuf.finderInfo.fdFlags & kIsInvisible) {
		printf("hide: %s is alreadly invisible\n", file);
		return (0);
    }

    finderInfoBuf.finderInfo.fdFlags |= kIsInvisible;

    result = setattrlist(file, &alist, &finderInfoBuf.finderInfo, sizeof(FinderInfo), 0);
    
    return (result == -1 ? errno : result);
}

int
get_start_block(const char *file)
{
    struct attrlist alist = {0};
    ExtentsAttrBuf extentsbuf = {0};

    alist.bitmapcount = ATTR_BIT_MAP_COUNT;
    alist.fileattr = ATTR_FILE_DATAEXTENTS;

    if (getattrlist(file, &alist, &extentsbuf, sizeof(extentsbuf), 0)) {
		fprintf(stderr, "could not get attrlist for %s (%s)", file, strerror(errno));
		return -1;
    }

    if (extentsbuf.extents[1].startBlock != 0) {
		fprintf(stderr, "Journal File not contiguous!\n");
		return -1;
    }

    return extentsbuf.extents[0].startBlock;
}

static const char *journal_fname = ".journal";
static const char *jib_fname = ".journal_info_block";

int
DoMakeJournaled(char *volname, int jsize)
{
    int              fd, i, block_size, journal_size = 8*1024*1024;
    char            *buf;
    int              ret;
    fstore_t         fst;
    int              jstart_block, jinfo_block, sysctl_info[8];
    JournalInfoBlock jib;
	struct statfs    sfs;
	static char      tmpname[MAXPATHLEN];

	if (jsize != 0) {
		journal_size = jsize;
	}

	if (statfs(volname, &sfs) != 0) {
		fprintf(stderr, "Can't stat volume %s (%s).\n", volname, strerror(errno));
		return 10;
	}

	// Make sure that we're HFS+.  First we check the fstypename.
	// If that's ok then we try to create a symlink (which won't
	// work on plain hfs volumes but will work on hfs+ volumes).
	//
	sprintf(tmpname, "%s/is_vol_hfs_plus", volname);
	if (strcmp(sfs.f_fstypename, "hfs") != 0 ||
		((ret = symlink(tmpname, tmpname)) != 0 && errno == ENOTSUP)) {
		fprintf(stderr, "%s is not an HFS+ volume.  Journaling only works on HFS+ volumes.\n",
				volname);
		return 10;
	}
	unlink(tmpname);

	if (sfs.f_flags & MNT_JOURNALED) {
		fprintf(stderr, "Volume %s is already journaled.\n", volname);
		return 1;
	}

    if (chdir(volname) != 0) {
		fprintf(stderr, "Can't locate volume %s to make it journaled (%s).\n",
				volname, strerror(errno));
		return 10;
	}

    fd = open(journal_fname, O_CREAT|O_TRUNC|O_RDWR, 000);
    if (fd < 0) {
		fprintf(stderr, "Can't create journal file on volume %s (%s)\n",
				volname, strerror(errno));
		return 5;
    }

	// make sure that it has no r/w/x privs (only could happen if
	// the file already existed since open() doesn't reset the mode
	// bits).
	//
	fchmod(fd, 0);

    block_size = sfs.f_bsize;
    if ((journal_size % block_size) != 0) {
		fprintf(stderr, "Journal size %dk is not a multiple of volume %s block size (%d).\n",
				journal_size/1024, volname, block_size);
		close(fd);
		unlink(journal_fname);
		return 5;
    }

    memset(&fst, 0, sizeof(fst));
    fst.fst_flags   = F_ALLOCATECONTIG|F_ALLOCATEALL;
    fst.fst_length  = journal_size;
    fst.fst_posmode = F_PEOFPOSMODE;
    
    ret = fcntl(fd, F_PREALLOCATE, &fst);
    if (ret < 0) {
		fprintf(stderr, "Pre-allocating the journal file failed on volume %s (%s)\n",
				volname, strerror(errno));
		fprintf(stderr, "Try using a smaller (%d k) journal size\n", journal_size/2/1024);
		close(fd);
		unlink(journal_fname);
		return 10;
    }

    printf("Allocated %lldK for journal file.\n", fst.fst_bytesalloc/1024LL);
    buf = (char *)calloc(block_size, 1);
    if (buf) {
		for(i=0; i < journal_size/block_size; i++) {
			ret = write(fd, buf, block_size);
			if (ret != block_size) {
				break;
			}
		}
		
		if (i*block_size != journal_size) {
			fprintf(stderr, "Failed to write %dk to journal on volume %s (%s)\n",
					journal_size/1024, volname, strerror(errno));
		}
    } else {
		printf("Could not allocate memory to write to the journal on volume %s (%s)\n",
			   volname, strerror(errno));
    }

    fsync(fd);
    close(fd);
    hide_file(journal_fname);

    jstart_block = get_start_block(journal_fname);

    memset(&jib, 0, sizeof(jib));
    jib.flags  = kJIJournalInFSMask;
    jib.offset = (off_t)jstart_block * (off_t)block_size;
    jib.size   = (off_t)journal_size;

    fd = open(jib_fname, O_CREAT|O_TRUNC|O_RDWR, 000);
    if (fd < 0) {
		fprintf(stderr, "Could not create journal info block file on volume %s (%s)\n",
				volname, strerror(errno));
		unlink(journal_fname);
		return 5;
    }
    
    memcpy(buf, &jib, sizeof(jib));
    if (write(fd, buf, block_size) != block_size) {
		fprintf(stderr, "Failed to write journal info block on volume %s (%s)!\n",
				volname, strerror(errno));
		unlink(journal_fname);
		return 10;
    }

    fsync(fd);
    close(fd);
    hide_file(jib_fname);

    jinfo_block = get_start_block(jib_fname);


    //
    // Now make the volume journaled!
    //
    memset(sysctl_info, 0, sizeof(sysctl_info));
    sysctl_info[0] = CTL_VFS;
    sysctl_info[1] = sfs.f_fsid.val[1];
    sysctl_info[2] = HFS_BECOME_JOURNALED;
    sysctl_info[3] = jinfo_block;
    sysctl_info[4] = jstart_block;
    sysctl_info[5] = journal_size;
     
    //printf("fs type: 0x%x\n", sysctl_info[1]);
    //printf("jinfo block : 0x%x\n", jinfo_block);
    //printf("jstart block: 0x%x\n", jstart_block);
    //printf("journal size: 0x%x\n", journal_size);

    ret = sysctl((void *)sysctl_info, 6, NULL, NULL, NULL, 0);
    if (ret != 0) {
		fprintf(stderr, "Failed to make volume %s journaled (%s)\n",
				volname, strerror(errno));
		unlink(journal_fname);
		unlink(jib_fname);
		return 20;
    }

	return 0;
}


int
DoUnJournal(char *volname)
{
	int           result;
    int           sysctl_info[8];
	struct statfs sfs;
	char          jbuf[MAXPATHLEN];
	
	if (statfs(volname, &sfs) != 0) {
		fprintf(stderr, "Can't stat volume %s (%s).\n", volname, strerror(errno));
		return 10;
	}

	if ((sfs.f_flags & MNT_JOURNALED) == 0) {
		fprintf(stderr, "Volume %s is not journaled.\n", volname);
		return 1;
	}

	if (chdir(volname) != 0) {
		fprintf(stderr, "Can't locate volume %s to turn off journaling (%s).\n",
				volname, strerror(errno));
		return 10;
	}
	
	memset(sysctl_info, 0, sizeof(sysctl_info));
	sysctl_info[0] = CTL_VFS;
	sysctl_info[1] = sfs.f_fsid.val[1];
	sysctl_info[2] = HFS_BECOME_UNJOURNALED;
	
	result = sysctl((void *)sysctl_info, 6, NULL, NULL, NULL, 0);
	if (result != 0) {
		fprintf(stderr, "Failed to make volume %s UN-journaled (%s)\n",
				volname, strerror(errno));
		return 20;
	}

	sprintf(jbuf, "%s/%s", volname, journal_fname);
	if (unlink(jbuf) != 0) {
		fprintf(stderr, "Failed to remove the journal %s (%s)\n",
				jbuf, strerror(errno));
	}

	sprintf(jbuf, "%s/%s", volname, jib_fname);
	if (unlink(jbuf) != 0) {
		fprintf(stderr, "Failed to remove the journal info block %s (%s)\n",
				jbuf, strerror(errno));
	}

	printf("Journaling disabled on %s\n", volname);
	    
	return 0;
}
Commit	Line	Data
08cdaae8 A	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.1 (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
	41	#include <dev/disk.h>
	42	#include <sys/loadable_fs.h>
	43	#include <hfs/hfs_format.h>
	44
	45	#include <errno.h>
	46	#include <fcntl.h>
	47	#include <libgen.h>
	48	#include <pwd.h>
	49	#include <stdio.h>
	50	#include <stdlib.h>
	51	#include <string.h>
	52	#include <unistd.h>
	53
	54	#include <architecture/byte_order.h>
	55
	56	//
	57	// Secret HFS sysctl's to instruct it to turn
	58	// journaling on/off for a volume.
	59	//
	60	#define HFS_BECOME_JOURNALED 0x082969
	61	#define HFS_BECOME_UNJOURNALED 0x031272
	62
	63
	64	/* getattrlist buffers start with an extra length field */
65	struct ExtentsAttrBuf {
66	unsigned long infoLength;
67	HFSPlusExtentRecord extents;
68	};
69	typedef struct ExtentsAttrBuf ExtentsAttrBuf;
70
71
72
73	#define kIsInvisible 0x4000
74
75	/*
76	* Generic Finder file/dir data
77	*/
78	struct FinderInfo {
79	u_int32_t opaque_1[2];
80	u_int16_t fdFlags; /* Finder flags */
81	int16_t opaque_2[11];
82	};
83	typedef struct FinderInfo FinderInfo;
84
85	/* getattrlist buffers start with an extra length field */
86	struct FinderAttrBuf {
87	unsigned long infoLength;
88	FinderInfo finderInfo;
89	};
90	typedef struct FinderAttrBuf FinderAttrBuf;
91
92
93	int hide_file(const char * file)
94	{
95	struct attrlist alist = {0};
96	FinderAttrBuf finderInfoBuf = {0};
97	int result;
98
99	alist.bitmapcount = ATTR_BIT_MAP_COUNT;
100	alist.commonattr = ATTR_CMN_FNDRINFO;
101
102	result = getattrlist(file, &alist, &finderInfoBuf, sizeof(finderInfoBuf), 0);
103	if (result) {
104	return (errno);
105	}
106
107	if (finderInfoBuf.finderInfo.fdFlags & kIsInvisible) {
108	printf("hide: %s is alreadly invisible\n", file);
109	return (0);
110	}
111
112	finderInfoBuf.finderInfo.fdFlags \|= kIsInvisible;
113
114	result = setattrlist(file, &alist, &finderInfoBuf.finderInfo, sizeof(FinderInfo), 0);
115
116	return (result == -1 ? errno : result);
117	}
118
119	int
120	get_start_block(const char *file)
121	{
122	struct attrlist alist = {0};
123	ExtentsAttrBuf extentsbuf = {0};
124
125	alist.bitmapcount = ATTR_BIT_MAP_COUNT;
126	alist.fileattr = ATTR_FILE_DATAEXTENTS;
127
128	if (getattrlist(file, &alist, &extentsbuf, sizeof(extentsbuf), 0)) {
129	fprintf(stderr, "could not get attrlist for %s (%s)", file, strerror(errno));
130	return -1;
131	}
132
133	if (extentsbuf.extents[1].startBlock != 0) {
134	fprintf(stderr, "Journal File not contiguous!\n");
135	return -1;
136	}
137
138	return extentsbuf.extents[0].startBlock;
139	}
140
141	static const char *journal_fname = ".journal";
142	static const char *jib_fname = ".journal_info_block";
143
144	int
145	DoMakeJournaled(char *volname, int jsize)
146	{
147	int fd, i, block_size, journal_size = 810241024;
148	char *buf;
149	int ret;
150	fstore_t fst;
151	int jstart_block, jinfo_block, sysctl_info[8];
152	JournalInfoBlock jib;
153	struct statfs sfs;
154	static char tmpname[MAXPATHLEN];
155
156	if (jsize != 0) {
157	journal_size = jsize;
158	}
159
160	if (statfs(volname, &sfs) != 0) {
161	fprintf(stderr, "Can't stat volume %s (%s).\n", volname, strerror(errno));
162	return 10;
163	}
164
165	// Make sure that we're HFS+. First we check the fstypename.
166	// If that's ok then we try to create a symlink (which won't
167	// work on plain hfs volumes but will work on hfs+ volumes).
168	//
169	sprintf(tmpname, "%s/is_vol_hfs_plus", volname);
170	if (strcmp(sfs.f_fstypename, "hfs") != 0 \|\|
171	((ret = symlink(tmpname, tmpname)) != 0 && errno == ENOTSUP)) {
172	fprintf(stderr, "%s is not an HFS+ volume. Journaling only works on HFS+ volumes.\n",
173	volname);
174	return 10;
175	}
176	unlink(tmpname);
177
178	if (sfs.f_flags & MNT_JOURNALED) {
179	fprintf(stderr, "Volume %s is already journaled.\n", volname);
180	return 1;
181	}
182
183	if (chdir(volname) != 0) {
184	fprintf(stderr, "Can't locate volume %s to make it journaled (%s).\n",
185	volname, strerror(errno));
186	return 10;
187	}
188
189	fd = open(journal_fname, O_CREAT\|O_TRUNC\|O_RDWR, 000);
190	if (fd < 0) {
191	fprintf(stderr, "Can't create journal file on volume %s (%s)\n",
192	volname, strerror(errno));
193	return 5;
194	}
195
196	// make sure that it has no r/w/x privs (only could happen if
197	// the file already existed since open() doesn't reset the mode
198	// bits).
199	//
200	fchmod(fd, 0);
201
202	block_size = sfs.f_bsize;
203	if ((journal_size % block_size) != 0) {
204	fprintf(stderr, "Journal size %dk is not a multiple of volume %s block size (%d).\n",
205	journal_size/1024, volname, block_size);
206	close(fd);
207	unlink(journal_fname);
208	return 5;
209	}
210
211	memset(&fst, 0, sizeof(fst));
212	fst.fst_flags = F_ALLOCATECONTIG\|F_ALLOCATEALL;
213	fst.fst_length = journal_size;
214	fst.fst_posmode = F_PEOFPOSMODE;
215
216	ret = fcntl(fd, F_PREALLOCATE, &fst);
217	if (ret < 0) {
218	fprintf(stderr, "Pre-allocating the journal file failed on volume %s (%s)\n",
219	volname, strerror(errno));
220	fprintf(stderr, "Try using a smaller (%d k) journal size\n", journal_size/2/1024);
221	close(fd);
222	unlink(journal_fname);
223	return 10;
224	}
225
226	printf("Allocated %lldK for journal file.\n", fst.fst_bytesalloc/1024LL);
227	buf = (char *)calloc(block_size, 1);
228	if (buf) {
229	for(i=0; i < journal_size/block_size; i++) {
230	ret = write(fd, buf, block_size);
231	if (ret != block_size) {
232	break;
233	}
234	}
235
236	if (i*block_size != journal_size) {
237	fprintf(stderr, "Failed to write %dk to journal on volume %s (%s)\n",
238	journal_size/1024, volname, strerror(errno));
239	}
240	} else {
241	printf("Could not allocate memory to write to the journal on volume %s (%s)\n",
242	volname, strerror(errno));
243	}
244
245	fsync(fd);
246	close(fd);
247	hide_file(journal_fname);
248
249	jstart_block = get_start_block(journal_fname);
250
251	memset(&jib, 0, sizeof(jib));
252	jib.flags = kJIJournalInFSMask;
253	jib.offset = (off_t)jstart_block * (off_t)block_size;
254	jib.size = (off_t)journal_size;
255
256	fd = open(jib_fname, O_CREAT\|O_TRUNC\|O_RDWR, 000);
257	if (fd < 0) {
258	fprintf(stderr, "Could not create journal info block file on volume %s (%s)\n",
259	volname, strerror(errno));
260	unlink(journal_fname);
261	return 5;
262	}
263
264	memcpy(buf, &jib, sizeof(jib));
265	if (write(fd, buf, block_size) != block_size) {
266	fprintf(stderr, "Failed to write journal info block on volume %s (%s)!\n",
267	volname, strerror(errno));
268	unlink(journal_fname);
269	return 10;
270	}
271
272	fsync(fd);
273	close(fd);
274	hide_file(jib_fname);
275
276	jinfo_block = get_start_block(jib_fname);
277
278
279	//
280	// Now make the volume journaled!
281	//
282	memset(sysctl_info, 0, sizeof(sysctl_info));
283	sysctl_info[0] = CTL_VFS;
284	sysctl_info[1] = sfs.f_fsid.val[1];
285	sysctl_info[2] = HFS_BECOME_JOURNALED;
286	sysctl_info[3] = jinfo_block;
287	sysctl_info[4] = jstart_block;
288	sysctl_info[5] = journal_size;
289
290	//printf("fs type: 0x%x\n", sysctl_info[1]);
291	//printf("jinfo block : 0x%x\n", jinfo_block);
292	//printf("jstart block: 0x%x\n", jstart_block);
293	//printf("journal size: 0x%x\n", journal_size);
294
295	ret = sysctl((void *)sysctl_info, 6, NULL, NULL, NULL, 0);
296	if (ret != 0) {
297	fprintf(stderr, "Failed to make volume %s journaled (%s)\n",
298	volname, strerror(errno));
299	unlink(journal_fname);
300	unlink(jib_fname);
301	return 20;
302	}
303
304	return 0;
305	}
306
307
308	int
309	DoUnJournal(char *volname)
310	{
311	int result;
312	int sysctl_info[8];
313	struct statfs sfs;
314	char jbuf[MAXPATHLEN];
315
316	if (statfs(volname, &sfs) != 0) {
317	fprintf(stderr, "Can't stat volume %s (%s).\n", volname, strerror(errno));
318	return 10;
319	}
320
321	if ((sfs.f_flags & MNT_JOURNALED) == 0) {
322	fprintf(stderr, "Volume %s is not journaled.\n", volname);
323	return 1;
324	}
325
326	if (chdir(volname) != 0) {
327	fprintf(stderr, "Can't locate volume %s to turn off journaling (%s).\n",
328	volname, strerror(errno));
329	return 10;
330	}
331
332	memset(sysctl_info, 0, sizeof(sysctl_info));
333	sysctl_info[0] = CTL_VFS;
334	sysctl_info[1] = sfs.f_fsid.val[1];
335	sysctl_info[2] = HFS_BECOME_UNJOURNALED;
336
337	result = sysctl((void *)sysctl_info, 6, NULL, NULL, NULL, 0);
338	if (result != 0) {
339	fprintf(stderr, "Failed to make volume %s UN-journaled (%s)\n",
340	volname, strerror(errno));
341	return 20;
342	}
343
344	sprintf(jbuf, "%s/%s", volname, journal_fname);
345	if (unlink(jbuf) != 0) {
346	fprintf(stderr, "Failed to remove the journal %s (%s)\n",
347	jbuf, strerror(errno));
348	}
349
350	sprintf(jbuf, "%s/%s", volname, jib_fname);
351	if (unlink(jbuf) != 0) {
352	fprintf(stderr, "Failed to remove the journal info block %s (%s)\n",
353	jbuf, strerror(errno));
354	}
355
356	printf("Journaling disabled on %s\n", volname);
357
358	return 0;
359	}