1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright 2006 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26 #pragma ident "%Z%%M% %I% %E% SMI" 27 28 #include <assert.h> 29 #include <errno.h> 30 #include <libintl.h> 31 #include <string.h> 32 #include <strings.h> 33 #include <sys/types.h> 34 #include <sys/statvfs.h> 35 #include <sys/param.h> 36 37 #include <sys/lx_debug.h> 38 #include <sys/lx_misc.h> 39 #include <sys/lx_statfs.h> 40 41 /* 42 * these defines must exist before we include regexp.h, see regexp(5) 43 */ 44 #define RE_SIZE 1024 45 #define INIT char *sp = instring; 46 #define GETC() (*sp++) 47 #define PEEKC() (*sp) 48 #define UNGETC(c) (--sp) 49 #define RETURN(c) return (NULL); 50 #define ERROR(c) return ((char *)c); 51 52 /* 53 * for regular expressions we're using regexp(5). 54 * 55 * we'd really prefer to use some other nicer regular expressions 56 * interfaces (like regcmp(3c), regcomp(3c), or re_comp(3c)) but we 57 * can't because all these other interfaces rely on the ability 58 * to allocate memory via libc malloc()/calloc() calls, which 59 * we can't really do here. 60 * 61 * we could optionally use regexpr(3gen) but we don't since the 62 * interfaces there are incredibly similar to the regexp(5) 63 * interfaces we're already using and we'd have the added 64 * requirement of linking against libgen. 65 * 66 * another option that was considered is fnmatch(3c) but the 67 * limited pattern expansion capability of this interface would 68 * force us to include more patterns to check against. 69 */ 70 #include <regexp.h> 71 72 static struct lx_ftype_path { 73 char *lfp_path; 74 char lfp_re[RE_SIZE]; 75 int lfp_magic; 76 char *lfp_magic_str; 77 } ftype_path_list[] = { 78 { "^/dev/pts$", "", 79 LX_DEVPTS_SUPER_MAGIC, "LX_DEVPTS_SUPER_MAGIC" }, 80 { "^/dev/pts/$", "", 81 LX_DEVPTS_SUPER_MAGIC, "LX_DEVPTS_SUPER_MAGIC" }, 82 { "^/dev/pts/[0-9][0-9]*$", "", 83 LX_DEVPTS_SUPER_MAGIC, "LX_DEVPTS_SUPER_MAGIC" }, 84 { NULL, "", 85 0, NULL } 86 }; 87 88 /* 89 * For lack of linux equivalents, we present lofs and zfs as being ufs. 90 */ 91 static struct lx_ftype_name { 92 const char *lfn_name; 93 int lfn_magic; 94 char *lfn_magic_str; 95 } ftype_name_list[] = { 96 { "hsfs", LX_ISOFS_SUPER_MAGIC, "LX_ISOFS_SUPER_MAGIC" }, 97 { "nfs", LX_NFS_SUPER_MAGIC, "LX_NFS_SUPER_MAGIC" }, 98 { "pcfs", LX_MSDOS_SUPER_MAGIC, "LX_MSDOS_SUPER_MAGIC" }, 99 { "lx_proc", LX_PROC_SUPER_MAGIC, "LX_PROC_SUPER_MAGIC" }, 100 { "ufs", LX_UFS_MAGIC, "LX_UFS_MAGIC" }, 101 { "lofs", LX_UFS_MAGIC, "LX_UFS_MAGIC" }, 102 { "zfs", LX_UFS_MAGIC, "LX_UFS_MAGIC" }, 103 { NULL, 0, NULL } 104 }; 105 106 int 107 lx_statfs_init() 108 { 109 int i; 110 char *rv; 111 112 for (i = 0; ftype_path_list[i].lfp_path != NULL; i++) { 113 rv = compile( 114 ftype_path_list[i].lfp_path, 115 ftype_path_list[i].lfp_re, 116 ftype_path_list[i].lfp_re + RE_SIZE, '\0'); 117 if (rv == NULL) 118 continue; 119 120 lx_debug("lx_statfs_init compile(\"%s\") failed", 121 ftype_path_list[i].lfp_path); 122 return (1); 123 } 124 return (0); 125 } 126 127 static int 128 stol_type(const char *path, const char *name) 129 { 130 int i; 131 lx_debug("\tstol_type(\"%s\", \"%s\")\n", path == NULL ? "NULL" : path, 132 name == NULL ? "NULL" : name); 133 134 if (path != NULL) { 135 char userpath[MAXPATHLEN]; 136 137 if (uucopystr(path, userpath, MAXPATHLEN) == -1) 138 return (-errno); 139 140 for (i = 0; ftype_path_list[i].lfp_path != NULL; i++) { 141 if (step(userpath, ftype_path_list[i].lfp_re) == 0) 142 continue; 143 144 /* got a match on the fs path */ 145 lx_debug("\ttranslated f_type to 0x%x - %s", 146 ftype_path_list[i].lfp_magic, 147 ftype_path_list[i].lfp_magic_str); 148 return (ftype_path_list[i].lfp_magic); 149 } 150 } 151 152 assert(name != NULL); 153 for (i = 0; ftype_name_list[i].lfn_name != NULL; i++) { 154 if (strcmp(name, ftype_name_list[i].lfn_name) == 0) { 155 156 /* got a match on the fs name */ 157 lx_debug("\ttranslated f_type to 0x%x - %s", 158 ftype_name_list[i].lfn_magic, 159 ftype_name_list[i].lfn_magic_str); 160 return (ftype_name_list[i].lfn_magic); 161 } 162 } 163 164 /* we don't know what the fs type is so just set it to 0 */ 165 return (0); 166 } 167 168 /* 169 * The Linux statfs() is similar to the Solaris statvfs() call, the main 170 * difference being the use of a numeric 'f_type' identifier instead of the 171 * 'f_basetype' string. 172 */ 173 static int 174 stol_statfs(const char *path, struct lx_statfs *l, struct statvfs *s) 175 { 176 int type; 177 178 if ((type = stol_type(path, s->f_basetype)) < 0) 179 return (type); 180 181 l->f_type = type; 182 l->f_bsize = s->f_bsize; 183 l->f_blocks = s->f_blocks; 184 l->f_bfree = s->f_bfree; 185 l->f_bavail = s->f_bavail; 186 l->f_files = s->f_files; 187 l->f_ffree = s->f_ffree; 188 l->f_fsid = s->f_fsid; 189 l->f_namelen = s->f_namemax; 190 l->f_frsize = s->f_frsize; 191 bzero(&(l->f_spare), sizeof (l->f_spare)); 192 193 return (0); 194 } 195 196 static int 197 stol_statfs64(const char *path, struct lx_statfs64 *l, struct statvfs64 *s) 198 { 199 int type; 200 201 if ((type = stol_type(path, s->f_basetype)) < 0) 202 return (type); 203 204 l->f_type = type; 205 l->f_bsize = s->f_bsize; 206 l->f_blocks = s->f_blocks; 207 l->f_bfree = s->f_bfree; 208 l->f_bavail = s->f_bavail; 209 l->f_files = s->f_files; 210 l->f_ffree = s->f_ffree; 211 l->f_fsid = s->f_fsid; 212 l->f_namelen = s->f_namemax; 213 l->f_frsize = s->f_frsize; 214 bzero(&(l->f_spare), sizeof (l->f_spare)); 215 216 return (0); 217 } 218 219 int 220 lx_statfs(uintptr_t p1, uintptr_t p2) 221 { 222 const char *path = (const char *)p1; 223 struct lx_statfs lxfs, *fs = (struct lx_statfs *)p2; 224 struct statvfs vfs; 225 int err; 226 227 lx_debug("\tfstatvfs(%s, 0x%p)", path, fs); 228 if (statvfs(path, &vfs) != 0) 229 return (-errno); 230 231 if ((err = stol_statfs(path, &lxfs, &vfs)) != 0) 232 return (err); 233 234 if (uucopy(&lxfs, fs, sizeof (struct lx_statfs)) != 0) 235 return (-errno); 236 237 return (0); 238 } 239 240 int 241 lx_fstatfs(uintptr_t p1, uintptr_t p2) 242 { 243 struct lx_statfs lxfs, *fs = (struct lx_statfs *)p2; 244 struct statvfs vfs; 245 char *path, path_buf[MAXPATHLEN]; 246 int fd = (int)p1; 247 int err; 248 249 lx_debug("\tfstatvfs(%d, 0x%p)", fd, fs); 250 if (fstatvfs(fd, &vfs) != 0) 251 return (-errno); 252 253 path = lx_fd_to_path(fd, path_buf, sizeof (path_buf)); 254 255 if ((err = stol_statfs(path, &lxfs, &vfs)) != 0) 256 return (err); 257 258 if (uucopy(&lxfs, fs, sizeof (struct lx_statfs)) != 0) 259 return (-errno); 260 261 return (0); 262 } 263 264 /* ARGSUSED */ 265 int 266 lx_statfs64(uintptr_t p1, uintptr_t p2, uintptr_t p3) 267 { 268 const char *path = (const char *)p1; 269 struct lx_statfs64 lxfs, *fs = (struct lx_statfs64 *)p3; 270 struct statvfs64 vfs; 271 int err; 272 273 lx_debug("\tstatvfs64(%s, %d, 0x%p)", path, p2, fs); 274 if (statvfs64(path, &vfs) != 0) 275 return (-errno); 276 277 if ((err = stol_statfs64(path, &lxfs, &vfs)) != 0) 278 return (err); 279 280 if (uucopy(&lxfs, fs, sizeof (struct lx_statfs64)) != 0) 281 return (-errno); 282 283 return (0); 284 } 285 286 /* ARGSUSED */ 287 int 288 lx_fstatfs64(uintptr_t p1, uintptr_t p2, uintptr_t p3) 289 { 290 struct lx_statfs64 lxfs, *fs = (struct lx_statfs64 *)p3; 291 struct statvfs64 vfs; 292 char *path, path_buf[MAXPATHLEN]; 293 int fd = (int)p1; 294 int err; 295 296 lx_debug("\tfstatvfs64(%d, %d, 0x%p)", fd, p2, fs); 297 if (fstatvfs64(fd, &vfs) != 0) 298 return (-errno); 299 300 path = lx_fd_to_path(fd, path_buf, sizeof (path_buf)); 301 302 if ((err = stol_statfs64(path, &lxfs, &vfs)) != 0) 303 return (err); 304 305 if (uucopy(&lxfs, fs, sizeof (struct lx_statfs64)) != 0) 306 return (-errno); 307 308 return (0); 309 }