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 * Miscellaneous support subroutines for High Sierra filesystem 23 * 24 * Copyright 2007 Sun Microsystems, Inc. All rights reserved. 25 * Use is subject to license terms. 26 */ 27 28 #include <sys/types.h> 29 #include <sys/param.h> 30 #include <sys/time.h> 31 #include <sys/cmn_err.h> 32 #include <sys/systm.h> 33 #include <sys/sysmacros.h> 34 #include <sys/buf.h> 35 #include <sys/conf.h> 36 #include <sys/user.h> 37 #include <sys/vfs.h> 38 #include <sys/vnode.h> 39 #include <sys/proc.h> 40 #include <sys/debug.h> 41 #include <sys/kmem.h> 42 #include <sys/uio.h> 43 #include <vm/hat.h> 44 #include <vm/as.h> 45 #include <vm/seg.h> 46 #include <vm/page.h> 47 #include <vm/pvn.h> 48 #include <vm/seg_map.h> 49 #include <sys/swap.h> 50 #include <vm/seg_kmem.h> 51 52 #include <sys/fs/hsfs_spec.h> 53 #include <sys/fs/hsfs_node.h> 54 #include <sys/fs/hsfs_impl.h> 55 56 #define THE_EPOCH 1970 57 #define END_OF_TIME 2099 58 extern int hsfs_lostpage; 59 60 #ifdef __STDC__ 61 static time_t hs_date_to_gmtime(int year, int mon, int day, int gmtoff); 62 #else 63 static time_t hs_date_to_gmtime(); 64 #endif 65 66 /* 67 * Table used in logging non-fatal errors which should be recorded 68 * once per mount. Indexed by HSFS_ERR values (defined in hsfs_node.h). 69 */ 70 struct hsfs_error { 71 char *hdr_text; /* msg prefix: general error type */ 72 /* must contain %s for mnt pt */ 73 char *err_text; /* specific error message */ 74 uchar_t multiple; /* > 1 such error per fs possible? */ 75 uchar_t n_printf_args; /* if err_text printf-like, # addtl args */ 76 } hsfs_error[] = { 77 /* HSFS_ERR_TRAILING_JUNK */ 78 "hsfs: Warning: the file system mounted on %s " 79 "does not conform to the ISO-9660 specification:", 80 "trailing blanks or null characters in file or directory name.\n", 81 1, 0, 82 /* HSFS_ERR_LOWER_CASE_NM */ 83 "hsfs: Warning: the file system mounted on %s " 84 "does not conform to the ISO-9660 specification:", 85 "lower case characters in file or directory name.\n", 86 1, 0, 87 /* HSFS_ERR_BAD_ROOT_DIR */ 88 "hsfs: Warning: the file system mounted on %s " 89 "does not conform to the ISO-9660 specification:", 90 "invalid root directory.\n", 91 0, 0, 92 /* HSFS_ERR_UNSUP_TYPE */ 93 "hsfs: Warning: the file system mounted on %s " 94 "contains a file or directory with an unsupported type:", 95 " 0x%x.\n", 96 1, 1, 97 /* HSFS_ERR_BAD_FILE_LEN */ 98 "hsfs: Warning: file system mounted on %s " 99 "does not conform to the ISO-9660 specification:", 100 "file name length greater than max allowed\n", 101 1, 0, 102 /* HSFS_ERR_BAD_JOLIET_FILE_LEN */ 103 "hsfs: Warning: file system mounted on %s " 104 "does not conform to the Joliet specification:", 105 "file name length greater than max allowed\n", 106 1, 0, 107 /* HSFS_ERR_TRUNC_JOLIET_FILE_LEN */ 108 "hsfs: Warning: file system mounted on %s " 109 "does not conform to the Joliet specification:", 110 "file name length greater than MAXNAMELEN (truncated)\n", 111 1, 0, 112 /* HSFS_ERR_BAD_DIR_ENTRY */ 113 "hsfs: Warning: file system mounted on %s " 114 "has inconsistent data:", 115 "invalid directory or file name length (ignored)\n", 116 1, 0, 117 /* HSFS_ERR_NEG_SUA_LEN */ 118 "hsfs: Warning: file system mounted on %s " 119 "has inconsistent Rock Ridge data:", 120 "negative SUA len\n", 121 1, 0, 122 /* HSFS_ERR_BAD_SUA_LEN */ 123 "hsfs: Warning: file system mounted on %s " 124 "has inconsistent Rock Ridge data:", 125 "SUA len too big\n", 126 1, 0, 127 }; 128 129 /* 130 * Local datatype for defining tables of (Offset, Name) pairs for 131 * kstats. 132 */ 133 typedef struct { 134 offset_t index; 135 char *name; 136 } hsfs_ksindex_t; 137 138 static const hsfs_ksindex_t hsfs_kstats[] = { 139 { 0, "mountpoint" }, 140 { 1, "pages_lost" }, 141 { 2, "physical_read_pages" }, 142 { 3, "cache_read_pages" }, 143 { 4, "readahead_pages" }, 144 { 5, "coalesced_pages" }, 145 { 6, "total_pages_requested" }, 146 {-1, NULL } 147 }; 148 149 /* 150 * hs_parse_dirdate 151 * 152 * Parse the short 'directory-format' date into a Unix timeval. 153 * This is the date format used in Directory Entries. 154 * 155 * If the date is not representable, make something up. 156 */ 157 void 158 hs_parse_dirdate(dp, tvp) 159 uchar_t *dp; 160 struct timeval *tvp; 161 { 162 int year, month, day, hour, minute, sec, gmtoff; 163 164 year = HDE_DATE_YEAR(dp); 165 month = HDE_DATE_MONTH(dp); 166 day = HDE_DATE_DAY(dp); 167 hour = HDE_DATE_HOUR(dp); 168 minute = HDE_DATE_MIN(dp); 169 sec = HDE_DATE_SEC(dp); 170 gmtoff = HDE_DATE_GMTOFF(dp); 171 172 tvp->tv_usec = 0; 173 if (year < THE_EPOCH) { 174 tvp->tv_sec = 0; 175 } else { 176 tvp->tv_sec = hs_date_to_gmtime(year, month, day, gmtoff); 177 if (tvp->tv_sec != -1) { 178 tvp->tv_sec += ((hour * 60) + minute) * 60 + sec; 179 } 180 } 181 182 return; 183 184 } 185 186 /* 187 * hs_parse_longdate 188 * 189 * Parse the long 'user-oriented' date into a Unix timeval. 190 * This is the date format used in the Volume Descriptor. 191 * 192 * If the date is not representable, make something up. 193 */ 194 void 195 hs_parse_longdate(dp, tvp) 196 uchar_t *dp; 197 struct timeval *tvp; 198 { 199 int year, month, day, hour, minute, sec, gmtoff; 200 201 year = HSV_DATE_YEAR(dp); 202 month = HSV_DATE_MONTH(dp); 203 day = HSV_DATE_DAY(dp); 204 hour = HSV_DATE_HOUR(dp); 205 minute = HSV_DATE_MIN(dp); 206 sec = HSV_DATE_SEC(dp); 207 gmtoff = HSV_DATE_GMTOFF(dp); 208 209 tvp->tv_usec = 0; 210 if (year < THE_EPOCH) { 211 tvp->tv_sec = 0; 212 } else { 213 tvp->tv_sec = hs_date_to_gmtime(year, month, day, gmtoff); 214 if (tvp->tv_sec != -1) { 215 tvp->tv_sec += ((hour * 60) + minute) * 60 + sec; 216 tvp->tv_usec = HSV_DATE_HSEC(dp) * 10000; 217 } 218 } 219 220 } 221 222 /* cumulative number of seconds per month, non-leap and leap-year versions */ 223 static time_t cum_sec[] = { 224 0x0, 0x28de80, 0x4dc880, 0x76a700, 0x9e3400, 0xc71280, 225 0xee9f80, 0x1177e00, 0x1405c80, 0x167e980, 0x190c800, 0x1b85500 226 }; 227 static time_t cum_sec_leap[] = { 228 0x0, 0x28de80, 0x4f1a00, 0x77f880, 0x9f8580, 0xc86400, 229 0xeff100, 0x118cf80, 0x141ae00, 0x1693b00, 0x1921980, 0x1b9a680 230 }; 231 #define SEC_PER_DAY 0x15180 232 #define SEC_PER_YEAR 0x1e13380 233 234 /* 235 * hs_date_to_gmtime 236 * 237 * Convert year(1970-2099)/month(1-12)/day(1-31) to seconds-since-1970/1/1. 238 * 239 * Returns -1 if the date is out of range. 240 */ 241 static time_t 242 hs_date_to_gmtime(year, mon, day, gmtoff) 243 int year; 244 int mon; 245 int day; 246 int gmtoff; 247 { 248 time_t sum; 249 time_t *cp; 250 int y; 251 252 if ((year < THE_EPOCH) || (year > END_OF_TIME) || 253 (mon < 1) || (mon > 12) || 254 (day < 1) || (day > 31)) 255 return (-1); 256 257 /* 258 * Figure seconds until this year and correct for leap years. 259 * Note: 2000 is a leap year but not 2100. 260 */ 261 y = year - THE_EPOCH; 262 sum = y * SEC_PER_YEAR; 263 sum += ((y + 1) / 4) * SEC_PER_DAY; 264 /* 265 * Point to the correct table for this year and 266 * add in seconds until this month. 267 */ 268 cp = ((y + 2) % 4) ? cum_sec : cum_sec_leap; 269 sum += cp[mon - 1]; 270 /* 271 * Add in seconds until 0:00 of this day. 272 * (days-per-month validation is not done here) 273 */ 274 sum += (day - 1) * SEC_PER_DAY; 275 sum -= (gmtoff * 15 * 60); 276 return (sum); 277 } 278 279 /* 280 * Indicate whether the directory is valid. 281 */ 282 283 int 284 hsfs_valid_dir(hd) 285 struct hs_direntry *hd; 286 { 287 /* 288 * check to see if this directory is not marked as a directory. 289 * check to see if data length is zero. 290 */ 291 292 if (hd->ext_size == 0) 293 return (0); 294 295 if (hd->type != VDIR) 296 return (0); 297 298 return (1); 299 } 300 301 302 303 /* 304 * If we haven't complained about this error type yet, do. 305 */ 306 void 307 hs_log_bogus_disk_warning(fsp, errtype, data) 308 struct hsfs *fsp; 309 int errtype; 310 uint_t data; 311 { 312 313 if (fsp->hsfs_err_flags & (1 << errtype)) 314 return; /* already complained */ 315 316 cmn_err(CE_NOTE, hsfs_error[errtype].hdr_text, 317 fsp->hsfs_fsmnt); 318 319 switch (hsfs_error[errtype].n_printf_args) { 320 case 0: 321 cmn_err(CE_CONT, hsfs_error[errtype].err_text); 322 break; 323 case 1: 324 cmn_err(CE_CONT, hsfs_error[errtype].err_text, data); 325 break; 326 default: 327 /* don't currently handle more than 1 arg */ 328 cmn_err(CE_CONT, "unknown problem; internal error.\n"); 329 } 330 cmn_err(CE_CONT, 331 "Due to this error, the file system may not be correctly interpreted.\n"); 332 if (hsfs_error[errtype].multiple) 333 cmn_err(CE_CONT, 334 "Other such errors in this file system will be silently ignored.\n\n"); 335 else 336 cmn_err(CE_CONT, "\n"); 337 338 fsp->hsfs_err_flags |= (1 << errtype); 339 } 340 341 /* 342 * Callback from kstat framework. Grab a snapshot of the current hsfs 343 * counters and populate the kstats. 344 */ 345 static int 346 hsfs_kstats_update(kstat_t *ksp, int flag) 347 { 348 struct hsfs *fsp; 349 kstat_named_t *knp; 350 uint64_t pages_lost; 351 uint64_t physical_read_bytes; 352 uint64_t cache_read_pages; 353 uint64_t readahead_bytes; 354 uint64_t coalesced_bytes; 355 uint64_t total_pages_requested; 356 357 if (flag != KSTAT_READ) 358 return (EACCES); 359 360 fsp = ksp->ks_private; 361 knp = ksp->ks_data; 362 363 mutex_enter(&(fsp->hqueue->strategy_lock)); 364 mutex_enter(&(fsp->hqueue->hsfs_queue_lock)); 365 366 cache_read_pages = fsp->cache_read_pages; 367 pages_lost = hsfs_lostpage; 368 physical_read_bytes = fsp->physical_read_bytes; 369 readahead_bytes = fsp->readahead_bytes; 370 coalesced_bytes = fsp->coalesced_bytes; 371 total_pages_requested = fsp->total_pages_requested; 372 373 mutex_exit(&(fsp->hqueue->strategy_lock)); 374 mutex_exit(&(fsp->hqueue->hsfs_queue_lock)); 375 376 knp++; 377 (knp++)->value.ui64 = pages_lost; 378 (knp++)->value.ui64 = howmany(physical_read_bytes, PAGESIZE); 379 (knp++)->value.ui64 = cache_read_pages; 380 (knp++)->value.ui64 = howmany(readahead_bytes, PAGESIZE); 381 (knp++)->value.ui64 = howmany(coalesced_bytes, PAGESIZE); 382 (knp++)->value.ui64 = total_pages_requested; 383 384 return (0); 385 } 386 387 /* 388 * Initialize hsfs kstats, which are all name value pairs with 389 * values being various counters. 390 */ 391 static kstat_t * 392 hsfs_setup_named_kstats(struct hsfs *fsp, int fsid, char *name, 393 const hsfs_ksindex_t *ksip, int (*update)(kstat_t *, int)) 394 { 395 kstat_t *ksp; 396 kstat_named_t *knp; 397 char *np; 398 char *mntpt = fsp->hsfs_fsmnt; 399 size_t size; 400 401 size = (sizeof (hsfs_kstats)) / (sizeof (hsfs_ksindex_t)); 402 ksp = kstat_create("hsfs_fs", fsid, name, "hsfs", 403 KSTAT_TYPE_NAMED, size-1, KSTAT_FLAG_VIRTUAL); 404 if (ksp == NULL) 405 return (NULL); 406 407 ksp->ks_data = kmem_alloc(sizeof (kstat_named_t) * size, KM_SLEEP); 408 ksp->ks_private = fsp; 409 ksp->ks_update = update; 410 ksp->ks_data_size += strlen(mntpt) + 1; 411 knp = ksp->ks_data; 412 kstat_named_init(knp, ksip->name, KSTAT_DATA_STRING); 413 kstat_named_setstr(knp, mntpt); 414 knp++; 415 ksip++; 416 417 for (; (np = ksip->name) != NULL; ++knp, ++ksip) { 418 kstat_named_init(knp, np, KSTAT_DATA_UINT64); 419 } 420 kstat_install(ksp); 421 422 return (ksp); 423 } 424 425 void 426 hsfs_init_kstats(struct hsfs *fsp, int fsid) 427 { 428 fsp->hsfs_kstats = hsfs_setup_named_kstats(fsp, fsid, "hsfs_read_stats", 429 hsfs_kstats, hsfs_kstats_update); 430 } 431 432 void 433 hsfs_fini_kstats(struct hsfs *fsp) 434 { 435 void *data; 436 437 if (fsp->hsfs_kstats != NULL) { 438 data = fsp->hsfs_kstats->ks_data; 439 kstat_delete(fsp->hsfs_kstats); 440 kmem_free(data, sizeof (kstat_named_t) * 441 (sizeof (hsfs_kstats)) / (sizeof (hsfs_ksindex_t))); 442 } 443 fsp->hsfs_kstats = NULL; 444 } 445