Print this page
13111 Want futimes() and lutimes() functions
Change-ID: I3be82d4242255a4100f8c35db373eb9140402fc4
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/uts/common/sys/time.h
+++ new/usr/src/uts/common/sys/time.h
1 1 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
2 2 /* All Rights Reserved */
3 3
4 4
5 5 /*
6 6 * Copyright (c) 1982, 1986, 1993 Regents of the University of California.
7 7 * All rights reserved. The Berkeley software License Agreement
|
↓ open down ↓ |
7 lines elided |
↑ open up ↑ |
8 8 * specifies the terms and conditions for redistribution.
9 9 */
10 10
11 11 /*
12 12 * Copyright 2014 Garrett D'Amore <garrett@damore.org>
13 13 *
14 14 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
15 15 * Use is subject to license terms.
16 16 *
17 17 * Copyright 2013 Nexenta Systems, Inc. All rights reserved.
18 + *
19 + * Copyright 2020 OmniOS Community Edition (OmniOSce) Association.
18 20 */
19 21
20 22 /*
21 23 * Copyright (c) 2013, 2016 by Delphix. All rights reserved.
22 24 */
23 25
24 26 #ifndef _SYS_TIME_H
25 27 #define _SYS_TIME_H
26 28
27 29 #include <sys/feature_tests.h>
28 30
29 31 /*
30 32 * Structure returned by gettimeofday(2) system call,
31 33 * and used in other calls.
32 34 */
33 35
34 36 #ifdef __cplusplus
35 37 extern "C" {
36 38 #endif
37 39
38 40 #if !defined(__XOPEN_OR_POSIX) || defined(_XPG4_2) || \
39 41 defined(__EXTENSIONS__)
40 42 #ifndef _ASM
41 43
42 44 #if !defined(_TIME_T) || __cplusplus >= 199711L
43 45 #define _TIME_T
44 46 typedef long time_t; /* time of day in seconds */
45 47 #endif /* _TIME_T */
46 48
47 49 #ifndef _SUSECONDS_T
48 50 #define _SUSECONDS_T
49 51 typedef long suseconds_t; /* signed # of microseconds */
50 52 #endif /* _SUSECONDS_T */
51 53
52 54 struct timeval {
53 55 time_t tv_sec; /* seconds */
54 56 suseconds_t tv_usec; /* and microseconds */
55 57 };
56 58
57 59 #if defined(_SYSCALL32)
58 60
59 61 #include <sys/types32.h>
60 62
61 63 #define TIMEVAL32_TO_TIMEVAL(tv, tv32) { \
62 64 (tv)->tv_sec = (time_t)(tv32)->tv_sec; \
63 65 (tv)->tv_usec = (tv32)->tv_usec; \
64 66 }
65 67
66 68 #define TIMEVAL_TO_TIMEVAL32(tv32, tv) { \
67 69 (tv32)->tv_sec = (time32_t)(tv)->tv_sec; \
68 70 (tv32)->tv_usec = (int32_t)(tv)->tv_usec; \
69 71 }
70 72
71 73 #define TIME32_MAX INT32_MAX
72 74 #define TIME32_MIN INT32_MIN
73 75
74 76 #define TIMEVAL_OVERFLOW(tv) \
75 77 ((tv)->tv_sec < TIME32_MIN || (tv)->tv_sec > TIME32_MAX)
76 78
77 79 #endif /* _SYSCALL32 */
78 80
79 81 #endif /* _ASM */
80 82 #endif /* !defined(__XOPEN_OR_POSIX) || defined(_XPG4_2) ... */
81 83
82 84 #if !defined(__XOPEN_OR_POSIX) || defined(__EXTENSIONS__)
83 85 #ifndef _ASM
84 86 struct timezone {
85 87 int tz_minuteswest; /* minutes west of Greenwich */
86 88 int tz_dsttime; /* type of dst correction */
87 89 };
88 90
89 91 #endif /* _ASM */
90 92 #endif /* !defined(__XOPEN_OR_POSIX) || defined(__EXTENSIONS__) */
91 93
92 94 #ifdef __cplusplus
93 95 }
94 96 #endif
95 97
96 98 /*
97 99 * Needed for longlong_t type. Placement of this due to <sys/types.h>
98 100 * including <sys/select.h> which relies on the presense of the itimerval
99 101 * structure.
100 102 */
101 103 #ifndef _ASM
102 104 #include <sys/types.h>
103 105 #endif /* _ASM */
104 106
105 107 #ifdef __cplusplus
106 108 extern "C" {
107 109 #endif
108 110
109 111 #if !defined(__XOPEN_OR_POSIX) || defined(__EXTENSIONS__)
110 112
111 113 #define DST_NONE 0 /* not on dst */
112 114 #define DST_USA 1 /* USA style dst */
113 115 #define DST_AUST 2 /* Australian style dst */
114 116 #define DST_WET 3 /* Western European dst */
115 117 #define DST_MET 4 /* Middle European dst */
116 118 #define DST_EET 5 /* Eastern European dst */
117 119 #define DST_CAN 6 /* Canada */
118 120 #define DST_GB 7 /* Great Britain and Eire */
119 121 #define DST_RUM 8 /* Rumania */
120 122 #define DST_TUR 9 /* Turkey */
121 123 #define DST_AUSTALT 10 /* Australian style with shift in 1986 */
122 124
123 125 /*
124 126 * Operations on timevals.
125 127 */
126 128 #define timerisset(tvp) ((tvp)->tv_sec || (tvp)->tv_usec)
127 129 #define timercmp(tvp, uvp, cmp) \
128 130 (((tvp)->tv_sec == (uvp)->tv_sec) ? \
129 131 /* CSTYLED */ \
130 132 ((tvp)->tv_usec cmp (uvp)->tv_usec) : \
131 133 /* CSTYLED */ \
132 134 ((tvp)->tv_sec cmp (uvp)->tv_sec))
133 135
134 136 #define timerclear(tvp) (tvp)->tv_sec = (tvp)->tv_usec = 0
135 137
136 138 #ifdef __lint
137 139 /*
138 140 * Make innocuous, lint-happy versions until do {} while (0) is acknowleged as
139 141 * lint-safe. If the compiler could know that we always make tv_usec < 1000000
140 142 * we wouldn't need a special linted version.
141 143 */
142 144 #define timeradd(tvp, uvp, vvp) \
143 145 do \
144 146 { \
145 147 (vvp)->tv_sec = (tvp)->tv_sec + (uvp)->tv_sec; \
146 148 (vvp)->tv_usec = (tvp)->tv_usec + (uvp)->tv_usec; \
147 149 if ((vvp)->tv_usec >= 1000000) \
148 150 { \
149 151 (vvp)->tv_sec++; \
150 152 (vvp)->tv_usec -= 1000000; \
151 153 } \
152 154 } while ((vvp)->tv_usec >= 1000000)
153 155 #define timersub(tvp, uvp, vvp) \
154 156 do \
155 157 { \
156 158 (vvp)->tv_sec = (tvp)->tv_sec - (uvp)->tv_sec; \
157 159 (vvp)->tv_usec = (tvp)->tv_usec - (uvp)->tv_usec; \
158 160 if ((vvp)->tv_usec < 0) \
159 161 { \
160 162 (vvp)->tv_sec--; \
161 163 (vvp)->tv_usec += 1000000; \
162 164 } \
163 165 } while ((vvp)->tv_usec >= 1000000)
164 166 #else
165 167 #define timeradd(tvp, uvp, vvp) \
166 168 do \
167 169 { \
168 170 (vvp)->tv_sec = (tvp)->tv_sec + (uvp)->tv_sec; \
169 171 (vvp)->tv_usec = (tvp)->tv_usec + (uvp)->tv_usec; \
170 172 if ((vvp)->tv_usec >= 1000000) \
171 173 { \
172 174 (vvp)->tv_sec++; \
173 175 (vvp)->tv_usec -= 1000000; \
174 176 } \
175 177 } while (0)
176 178
177 179 #define timersub(tvp, uvp, vvp) \
178 180 do \
179 181 { \
180 182 (vvp)->tv_sec = (tvp)->tv_sec - (uvp)->tv_sec; \
181 183 (vvp)->tv_usec = (tvp)->tv_usec - (uvp)->tv_usec; \
182 184 if ((vvp)->tv_usec < 0) \
183 185 { \
184 186 (vvp)->tv_sec--; \
185 187 (vvp)->tv_usec += 1000000; \
186 188 } \
187 189 } while (0)
188 190 #endif /* __lint */
189 191
190 192 #endif /* !defined(__XOPEN_OR_POSIX) || defined(__EXTENSIONS__) */
191 193
192 194 #if !defined(__XOPEN_OR_POSIX) || defined(_XPG4_2) || defined(__EXTENSIONS__)
193 195 /*
194 196 * Names of the interval timers, and structure
195 197 * defining a timer setting.
196 198 */
197 199 #define ITIMER_REAL 0 /* Decrements in real time */
198 200 #define ITIMER_VIRTUAL 1 /* Decrements in process virtual time */
199 201 #define ITIMER_PROF 2 /* Decrements both in process virtual */
200 202 /* time and when system is running on */
201 203 /* behalf of the process. */
202 204 #define ITIMER_REALPROF 3 /* Decrements in real time for real- */
203 205 /* time profiling of multithreaded */
204 206 /* programs. */
205 207
206 208 #ifndef _ASM
207 209 struct itimerval {
208 210 struct timeval it_interval; /* timer interval */
209 211 struct timeval it_value; /* current value */
210 212 };
211 213
212 214 #if defined(_SYSCALL32)
213 215
214 216 struct itimerval32 {
215 217 struct timeval32 it_interval;
216 218 struct timeval32 it_value;
217 219 };
218 220
219 221 #define ITIMERVAL32_TO_ITIMERVAL(itv, itv32) { \
220 222 TIMEVAL32_TO_TIMEVAL(&(itv)->it_interval, &(itv32)->it_interval); \
221 223 TIMEVAL32_TO_TIMEVAL(&(itv)->it_value, &(itv32)->it_value); \
222 224 }
223 225
224 226 #define ITIMERVAL_TO_ITIMERVAL32(itv32, itv) { \
225 227 TIMEVAL_TO_TIMEVAL32(&(itv32)->it_interval, &(itv)->it_interval); \
226 228 TIMEVAL_TO_TIMEVAL32(&(itv32)->it_value, &(itv)->it_value); \
227 229 }
228 230
229 231 #define ITIMERVAL_OVERFLOW(itv) \
230 232 (TIMEVAL_OVERFLOW(&(itv)->it_interval) || \
231 233 TIMEVAL_OVERFLOW(&(itv)->it_value))
232 234
233 235 #endif /* _SYSCALL32 */
234 236 #endif /* _ASM */
235 237 #endif /* !defined(__XOPEN_OR_POSIX) || defined(_XPG4_2) ... */
236 238
237 239
238 240 #if !defined(__XOPEN_OR_POSIX) || defined(__EXTENSIONS__)
239 241 /*
240 242 * Definitions for commonly used resolutions.
241 243 */
242 244 #define SEC 1
243 245 #define MILLISEC 1000
244 246 #define MICROSEC 1000000
245 247 #define NANOSEC 1000000000LL
246 248
247 249 #define MSEC2NSEC(m) ((hrtime_t)(m) * (NANOSEC / MILLISEC))
248 250 #define NSEC2MSEC(n) ((n) / (NANOSEC / MILLISEC))
249 251
250 252 #define USEC2NSEC(m) ((hrtime_t)(m) * (NANOSEC / MICROSEC))
251 253 #define NSEC2USEC(n) ((n) / (NANOSEC / MICROSEC))
252 254
253 255 #define NSEC2SEC(n) ((n) / (NANOSEC / SEC))
254 256 #define SEC2NSEC(m) ((hrtime_t)(m) * (NANOSEC / SEC))
255 257
256 258 #endif /* !defined(__XOPEN_OR_POSIX) || defined(__EXTENSIONS__) */
257 259
258 260 #ifndef _ASM
259 261
260 262 /*
261 263 * Time expressed as a 64-bit nanosecond counter.
262 264 */
263 265 typedef longlong_t hrtime_t;
264 266
265 267 #if defined(_KERNEL) || defined(_FAKE_KERNEL)
266 268
267 269 #include <sys/time_impl.h>
268 270 #include <sys/mutex.h>
269 271
270 272 extern int tick_per_msec; /* clock ticks per millisecond (may be zero) */
271 273 extern int msec_per_tick; /* milliseconds per clock tick (may be zero) */
272 274 extern int usec_per_tick; /* microseconds per clock tick */
273 275 extern int nsec_per_tick; /* nanoseconds per clock tick */
274 276
275 277 /*
276 278 * Macros to convert from common units of time (sec, msec, usec, nsec,
277 279 * timeval, timestruc) to clock ticks and vice versa.
278 280 */
279 281 #define TICK_TO_SEC(tick) ((tick) / hz)
280 282 #define SEC_TO_TICK(sec) ((sec) * hz)
281 283
282 284 #define TICK_TO_MSEC(tick) \
283 285 (msec_per_tick ? (tick) * msec_per_tick : (tick) / tick_per_msec)
284 286 #define MSEC_TO_TICK(msec) \
285 287 (msec_per_tick ? (msec) / msec_per_tick : (msec) * tick_per_msec)
286 288 #define MSEC_TO_TICK_ROUNDUP(msec) \
287 289 (msec_per_tick ? \
288 290 ((msec) == 0 ? 0 : ((msec) - 1) / msec_per_tick + 1) : \
289 291 (msec) * tick_per_msec)
290 292
291 293 #define TICK_TO_USEC(tick) ((tick) * usec_per_tick)
292 294 #define USEC_TO_TICK(usec) ((usec) / usec_per_tick)
293 295 #define USEC_TO_TICK_ROUNDUP(usec) \
294 296 ((usec) == 0 ? 0 : USEC_TO_TICK((usec) - 1) + 1)
295 297
296 298 #define TICK_TO_NSEC(tick) ((hrtime_t)(tick) * nsec_per_tick)
297 299 #define NSEC_TO_TICK(nsec) ((nsec) / nsec_per_tick)
298 300 #define NSEC_TO_TICK_ROUNDUP(nsec) \
299 301 ((nsec) == 0 ? 0 : NSEC_TO_TICK((nsec) - 1) + 1)
300 302
301 303 #define TICK_TO_TIMEVAL(tick, tvp) { \
302 304 clock_t __tmptck = (tick); \
303 305 (tvp)->tv_sec = TICK_TO_SEC(__tmptck); \
304 306 (tvp)->tv_usec = TICK_TO_USEC(__tmptck - SEC_TO_TICK((tvp)->tv_sec)); \
305 307 }
306 308
307 309 #define TICK_TO_TIMEVAL32(tick, tvp) { \
308 310 clock_t __tmptck = (tick); \
309 311 time_t __tmptm = TICK_TO_SEC(__tmptck); \
310 312 (tvp)->tv_sec = (time32_t)__tmptm; \
311 313 (tvp)->tv_usec = TICK_TO_USEC(__tmptck - SEC_TO_TICK(__tmptm)); \
312 314 }
313 315
314 316 #define TICK_TO_TIMESTRUC(tick, tsp) { \
315 317 clock_t __tmptck = (tick); \
316 318 (tsp)->tv_sec = TICK_TO_SEC(__tmptck); \
317 319 (tsp)->tv_nsec = TICK_TO_NSEC(__tmptck - SEC_TO_TICK((tsp)->tv_sec)); \
318 320 }
319 321
320 322 #define TICK_TO_TIMESTRUC32(tick, tsp) { \
321 323 clock_t __tmptck = (tick); \
322 324 time_t __tmptm = TICK_TO_SEC(__tmptck); \
323 325 (tsp)->tv_sec = (time32_t)__tmptm; \
324 326 (tsp)->tv_nsec = TICK_TO_NSEC(__tmptck - SEC_TO_TICK(__tmptm)); \
325 327 }
326 328
327 329 #define TIMEVAL_TO_TICK(tvp) \
328 330 (SEC_TO_TICK((tvp)->tv_sec) + USEC_TO_TICK((tvp)->tv_usec))
329 331
330 332 #define TIMESTRUC_TO_TICK(tsp) \
331 333 (SEC_TO_TICK((tsp)->tv_sec) + NSEC_TO_TICK((tsp)->tv_nsec))
332 334
333 335 typedef struct todinfo {
334 336 int tod_sec; /* seconds 0-59 */
335 337 int tod_min; /* minutes 0-59 */
336 338 int tod_hour; /* hours 0-23 */
337 339 int tod_dow; /* day of week 1-7 */
338 340 int tod_day; /* day of month 1-31 */
339 341 int tod_month; /* month 1-12 */
340 342 int tod_year; /* year 70+ */
341 343 } todinfo_t;
342 344
343 345 extern int64_t timedelta;
344 346 extern int timechanged;
345 347 extern int tod_needsync;
346 348 extern kmutex_t tod_lock;
347 349 extern volatile timestruc_t hrestime;
348 350 extern hrtime_t hres_last_tick;
|
↓ open down ↓ |
321 lines elided |
↑ open up ↑ |
349 351 extern int64_t hrestime_adj;
350 352 extern uint_t adj_shift;
351 353
352 354 extern timestruc_t tod_get(void);
353 355 extern void tod_set(timestruc_t);
354 356 extern void set_hrestime(timestruc_t *);
355 357 extern todinfo_t utc_to_tod(time_t);
356 358 extern time_t tod_to_utc(todinfo_t);
357 359 extern int hr_clock_lock(void);
358 360 extern void hr_clock_unlock(int);
359 -extern hrtime_t gethrtime(void);
360 -extern hrtime_t gethrtime_unscaled(void);
361 +extern hrtime_t gethrtime(void);
362 +extern hrtime_t gethrtime_unscaled(void);
361 363 extern hrtime_t gethrtime_max(void);
362 364 extern hrtime_t gethrtime_waitfree(void);
363 365 extern void scalehrtime(hrtime_t *);
364 366 extern uint64_t unscalehrtime(hrtime_t);
365 -extern void gethrestime(timespec_t *);
366 -extern time_t gethrestime_sec(void);
367 +extern void gethrestime(timespec_t *);
368 +extern time_t gethrestime_sec(void);
367 369 extern void gethrestime_lasttick(timespec_t *);
368 370 extern void hrt2ts(hrtime_t, timestruc_t *);
369 371 extern hrtime_t ts2hrt(const timestruc_t *);
370 372 extern void hrt2tv(hrtime_t, struct timeval *);
371 373 extern hrtime_t tv2hrt(struct timeval *);
372 374 extern int itimerfix(struct timeval *, int);
373 375 extern int itimerdecr(struct itimerval *, int);
374 376 extern void timevaladd(struct timeval *, struct timeval *);
375 377 extern void timevalsub(struct timeval *, struct timeval *);
376 378 extern void timevalfix(struct timeval *);
377 379 extern void dtrace_hres_tick(void);
378 380
379 381 extern clock_t ddi_get_lbolt(void);
380 382 extern int64_t ddi_get_lbolt64(void);
381 383
382 384 #if defined(_SYSCALL32)
383 385 extern void hrt2ts32(hrtime_t, timestruc32_t *);
384 386 #endif
385 387
386 388 #endif /* _KERNEL */
387 389
388 390 #if !defined(_KERNEL) && !defined(__XOPEN_OR_POSIX) || defined(__EXTENSIONS__)
389 391 int adjtime(struct timeval *, struct timeval *);
390 392 #endif /* !defined(_KERNEL) && !defined(__XOPEN_OR_POSIX) ... */
391 393
|
↓ open down ↓ |
15 lines elided |
↑ open up ↑ |
392 394 #if !defined(_KERNEL) && !defined(__XOPEN_OR_POSIX) || \
393 395 defined(_ATFILE_SOURCE) || defined(__EXTENSIONS__)
394 396 int futimesat(int, const char *, const struct timeval *);
395 397 #endif /* defined(__ATFILE_SOURCE) */
396 398
397 399 #if !defined(_KERNEL) && !defined(__XOPEN_OR_POSIX) || defined(_XPG4_2) || \
398 400 defined(__EXTENSIONS__)
399 401
400 402 int getitimer(int, struct itimerval *);
401 403 int utimes(const char *, const struct timeval *);
404 +
402 405 #if defined(_XPG4_2)
403 406 int setitimer(int, const struct itimerval *_RESTRICT_KYWD,
404 407 struct itimerval *_RESTRICT_KYWD);
405 408 #else
406 409 int setitimer(int, struct itimerval *_RESTRICT_KYWD,
407 410 struct itimerval *_RESTRICT_KYWD);
408 411 #endif /* defined(_XPG2_2) */
409 412
410 413 #endif /* !defined(_KERNEL) ... defined(_XPG4_2) */
411 414
415 +#if !defined(_KERNEL) && !defined(_STRICT_SYMBOLS)
416 +int futimes(int, const struct timeval *);
417 +int lutimes(const char *, const struct timeval *);
418 +
419 +#define TIMESPEC_TO_TIMEVAL(tv, ts) { \
420 + (tv)->tv_sec = (ts)->tv_sec; \
421 + (tv)->tv_usec = (ts)->tv_nsec / 1000; \
422 +}
423 +
424 +#define TIMEVAL_TO_TIMESPEC(tv, ts) { \
425 + (ts)->tv_sec = (tv)->tv_sec; \
426 + (ts)->tv_nsec = (tv)->tv_usec * 1000; \
427 +}
428 +
429 +#endif /* !defined(_KERNEL) && !defined(_STRICT_SYMBOLS) */
430 +
412 431 /*
413 432 * gettimeofday() and settimeofday() were included in SVr4 due to their
414 433 * common use in BSD based applications. They were to be included exactly
415 434 * as in BSD, with two parameters. However, AT&T/USL noted that the second
416 435 * parameter was unused and deleted it, thereby making a routine included
417 436 * for compatibility, incompatible.
418 437 *
419 438 * XSH4.2 (spec 1170) defines gettimeofday and settimeofday to have two
420 439 * parameters.
421 440 *
422 441 * This has caused general disagreement in the application community as to
423 442 * the syntax of these routines. Solaris defaults to the XSH4.2 definition.
424 443 * The flag _SVID_GETTOD may be used to force the SVID version.
425 444 */
426 445 #if !defined(_KERNEL) && !defined(__XOPEN_OR_POSIX) || defined(__EXTENSIONS__)
427 446
428 447 #if defined(_SVID_GETTOD)
429 448 int settimeofday(struct timeval *);
430 449 #else
431 450 int settimeofday(struct timeval *, void *);
432 451 #endif
433 452 hrtime_t gethrtime(void);
434 453 hrtime_t gethrvtime(void);
435 454
436 455 #endif /* !(defined _KERNEL) && !defined(__XOPEN_OR_POSIX) ... */
437 456
438 457 #if !defined(_KERNEL) && !defined(__XOPEN_OR_POSIX) || defined(_XPG4_2) || \
439 458 defined(__EXTENSIONS__)
440 459
441 460 #if defined(_SVID_GETTOD)
442 461 int gettimeofday(struct timeval *);
443 462 #else
444 463 int gettimeofday(struct timeval *_RESTRICT_KYWD, void *_RESTRICT_KYWD);
445 464 #endif
446 465
447 466 #endif /* !defined(_KERNEL) && !defined(__XOPEN_OR_POSIX) ... */
448 467
449 468 /*
450 469 * The inclusion of <time.h> is historical and was added for
451 470 * backward compatibility in delta 1.2 when a number of definitions
452 471 * were moved out of <sys/time.h>. More recently, the timespec and
453 472 * itimerspec structure definitions, along with the _CLOCK_*, CLOCK_*,
454 473 * _TIMER_*, and TIMER_* symbols were moved to <sys/time_impl.h>,
455 474 * which is now included by <time.h>. This change was due to POSIX
456 475 * 1003.1b-1993 and X/Open UNIX 98 requirements. For non-POSIX and
457 476 * non-X/Open applications, including this header will still make
458 477 * visible these definitions.
459 478 */
460 479 #if !defined(_BOOT) && !defined(_KERNEL) && !defined(_FAKE_KERNEL) && \
461 480 !defined(__XOPEN_OR_POSIX) || defined(__EXTENSIONS__)
462 481 #include <time.h>
463 482 #endif
464 483
465 484 /*
466 485 * The inclusion of <sys/select.h> is needed for the FD_CLR,
467 486 * FD_ISSET, FD_SET, and FD_SETSIZE macros as well as the
468 487 * select() prototype defined in the XOpen specifications
469 488 * beginning with XSH4v2. Placement required after definition
470 489 * for itimerval.
471 490 */
472 491 #if !defined(_KERNEL) && !defined(_FAKE_KERNEL) && \
473 492 !defined(__XOPEN_OR_POSIX) || \
474 493 defined(_XPG4_2) || defined(__EXTENSIONS__)
475 494 #include <sys/select.h>
476 495 #endif
477 496
478 497 #endif /* _ASM */
479 498
480 499 #ifdef __cplusplus
481 500 }
482 501 #endif
483 502
484 503 #endif /* _SYS_TIME_H */
|
↓ open down ↓ |
63 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX