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