1 /* 2 * Copyright (c) 2011 The DragonFly Project. All rights reserved. 3 * 4 * This code is derived from software contributed to The DragonFly Project 5 * by Antonio Huete <tuxillo@quantumachine.net> 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in 15 * the documentation and/or other materials provided with the 16 * distribution. 17 * 3. Neither the name of The DragonFly Project nor the names of its 18 * contributors may be used to endorse or promote products derived 19 * from this software without specific, prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 22 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 24 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 25 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 26 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, 27 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 28 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 29 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 30 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT 31 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 32 * SUCH DAMAGE. 33 */ 34 35 #include <dirent.h> 36 #include <err.h> 37 #include <errno.h> 38 #include <fcntl.h> 39 #include <stdio.h> 40 #include <stdlib.h> 41 #include <string.h> 42 #include <sys/param.h> 43 #include <sys/stat.h> 44 #include <unistd.h> 45 46 #include "libhammer.h" 47 48 libhammer_fsinfo_t 49 libhammer_get_fsinfo(const char *path) 50 { 51 struct hammer_pseudofs_data *pfs_od; 52 struct hammer_ioc_pseudofs_rw pfs; 53 struct hammer_ioc_info info; 54 libhammer_pfsinfo_t pip; 55 libhammer_fsinfo_t fip; 56 int error = 0; 57 int fd; 58 59 if ((fd = open(path, O_RDONLY)) < 0) 60 return NULL; 61 62 fip = _libhammer_malloc(sizeof(*fip)); 63 TAILQ_INIT(&fip->list_pseudo); 64 if ((ioctl(fd, HAMMERIOC_GET_INFO, &info)) < 0) { 65 libhammer_free_fsinfo(fip); 66 close(fd); 67 return NULL; 68 } 69 70 /* Fill filesystem information */ 71 snprintf(fip->vol_name, TXTLEN, "%s", info.vol_label); 72 fip->vol_fsid = info.vol_fsid; 73 fip->version = info.version; 74 fip->nvolumes = info.nvolumes; 75 fip->rootvol = info.rootvol; 76 fip->inodes = info.inodes; 77 fip->bigblocks = info.bigblocks; 78 fip->freebigblocks = info.freebigblocks; 79 fip->rsvbigblocks = info.rsvbigblocks; 80 81 bzero(&pfs, sizeof(pfs)); 82 pfs.pfs_id = 0; /* start off with root PFS */ 83 pfs.ondisk = _libhammer_malloc(sizeof(*pfs_od)); 84 pfs.bytes = sizeof(struct hammer_pseudofs_data); 85 86 while(error == 0) { 87 error = ioctl(fd, HAMMERIOC_SCAN_PSEUDOFS, &pfs); 88 if (error == 0 && !hammer_is_pfs_deleted(pfs.ondisk)) { 89 pip = _libhammer_malloc(sizeof(*pip)); 90 pfs_od = pfs.ondisk; 91 pip->ismaster = hammer_is_pfs_master(pfs_od); 92 93 /* 94 * Fill in structs used in the library. We don't rely on 95 * HAMMER structs but we do fill our own. 96 */ 97 pip->version = fip->version; 98 pip->pfs_id = pfs.pfs_id; 99 pip->mirror_flags = pfs_od->mirror_flags; 100 pip->beg_tid = pfs_od->sync_beg_tid; 101 pip->end_tid = pfs_od->sync_end_tid; 102 pip->mountedon = 103 libhammer_find_pfs_mount(&pfs_od->unique_uuid); 104 if (fip->version < 3) { 105 libhammer_compat_old_snapcount(pip); 106 } else { 107 TAILQ_INIT(&pip->list_snap); 108 if (libhammer_pfs_get_snapshots(fip, pip) < 0) 109 pip->snapcount = 0; 110 } 111 112 /* 113 * PFS retrieval goes 0..n so inserting in the tail 114 * leaves the TAILQ sorted by pfs_id. 115 * This is important since quickly getting PFS #0 is 116 * required for some functions so *DO NOT CHANGE IT*. 117 */ 118 TAILQ_INSERT_TAIL(&fip->list_pseudo, pip, entries); 119 120 } 121 pfs.pfs_id++; 122 } 123 free(pfs.ondisk); 124 125 close (fd); 126 127 return (fip); 128 } 129 130 void 131 libhammer_free_fsinfo(libhammer_fsinfo_t fip) 132 { 133 struct libhammer_pfsinfo *pfstmp; 134 135 while(!TAILQ_EMPTY(&fip->list_pseudo)) { 136 pfstmp = TAILQ_FIRST(&fip->list_pseudo); 137 libhammer_pfs_free_snapshots(pfstmp); 138 if (pfstmp->mountedon) 139 free(pfstmp->mountedon); 140 TAILQ_REMOVE(&fip->list_pseudo, pfstmp, entries); 141 free(pfstmp); 142 } 143 free(fip); 144 } 145