Page MenuHomeFreeBSD
Files F166923755

D42945.id131603.diff
No OneTemporary
Actions

D42945.id131603.diff
View Options

diff --git a/lib/libc/include/compat.h b/lib/libc/include/compat.h
--- a/lib/libc/include/compat.h
+++ b/lib/libc/include/compat.h
@@ -69,6 +69,9 @@
__sym_compat(swapoff, freebsd13_swapoff, FBSD_1.0);
+__sym_compat(ffclock_setestimate, ffclock_setdata, FBSD_1.3);
+__sym_compat(ffclock_getestimate, ffclock_getdata, FBSD_1.3);
+
#undef __sym_compat
#define __weak_reference(sym,alias) \
diff --git a/lib/libc/sys/Makefile.inc b/lib/libc/sys/Makefile.inc
--- a/lib/libc/sys/Makefile.inc
+++ b/lib/libc/sys/Makefile.inc
@@ -402,8 +402,8 @@
extattr_get_file.2 extattr_set_file.2 \
extattr_get_file.2 extattr_set_link.2
MLINKS+=ffclock.2 ffclock_getcounter.2 \
- ffclock.2 ffclock_getestimate.2 \
- ffclock.2 ffclock_setestimate.2
+ ffclock.2 ffclock_getdata.2 \
+ ffclock.2 ffclock_setdata.2
MLINKS+=fhlink.2 fhlinkat.2
MLINKS+=fhopen.2 fhstat.2 fhopen.2 fhstatfs.2
MLINKS+=fork.2 _Fork.2
diff --git a/lib/libc/sys/Symbol.map b/lib/libc/sys/Symbol.map
--- a/lib/libc/sys/Symbol.map
+++ b/lib/libc/sys/Symbol.map
@@ -358,8 +358,6 @@
clock_getcpuclockid2;
connectat;
ffclock_getcounter;
- ffclock_getestimate;
- ffclock_setestimate;
pipe2;
posix_fadvise;
procctl;
@@ -425,6 +423,11 @@
timerfd_settime;
};
+FBSD_1.8 {
+ ffclock_getdata;
+ ffclock_setdata;
+};
+
FBSDprivate_1.0 {
___acl_aclcheck_fd;
__sys___acl_aclcheck_fd;
diff --git a/lib/libc/sys/ffclock.2 b/lib/libc/sys/ffclock.2
--- a/lib/libc/sys/ffclock.2
+++ b/lib/libc/sys/ffclock.2
@@ -30,8 +30,8 @@
.Os
.Sh NAME
.Nm ffclock_getcounter ,
-.Nm ffclock_getestimate ,
-.Nm ffclock_setestimate
+.Nm ffclock_getdata ,
+.Nm ffclock_setdata
.Nd Retrieve feedforward counter, get and set the parameters defining the
native feedforward clock.
.Sh LIBRARY
@@ -41,9 +41,9 @@
.Ft int
.Fn ffclock_getcounter "ffcounter *ffcount"
.Ft int
-.Fn ffclock_getestimate "struct ffclock_estimate *cest"
+.Fn ffclock_getdata "struct ffclock_data *cdat"
.Ft int
-.Fn ffclock_setestimate "struct ffclock_estimate *cest"
+.Fn ffclock_setdata "struct ffclock_data *cdat"
.Sh DESCRIPTION
The FFclock is an alternative method to synchronize the system clock.
It implements a feedforward paradigm that decouples low level timestamping
@@ -69,17 +69,17 @@
feedforward counter maintained by the kernel.
.Pp
The
-.Fn ffclock_getestimate
+.Fn ffclock_getdata
and
-.Fn ffclock_setestimate
+.Fn ffclock_setdata
system calls allow the caller to respectively get and set the kernel's
native feedforward clock parameters.
The
-.Fn ffclock_setestimate
+.Fn ffclock_setdata
system call should be invoked by a single instance of a feedforward
synchronization daemon.
The
-.Fn ffclock_getestimate
+.Fn ffclock_getdata
system call can be called by any process to retrieve the current value of the
parameters.
.Pp
@@ -89,12 +89,12 @@
reading of the ffcounter itself.
.Pp
The native clock parameter data structure pointed to by
-.Fa cest
+.Fa cdat
is defined in
.In sys/timeffc.h
as:
.Bd -literal
-struct ffclock_estimate {
+struct ffclock_data {
struct bintime update_time; /* FFclock time of last update */
ffcounter update_ffcount; /* Counter value at last update */
ffcounter leapsec_expected; /* Estimated counter value of next leap. */
@@ -119,7 +119,7 @@
The
.Fa ffcount
or
-.Fa cest
+.Fa cdat
pointer referenced invalid memory.
.It Bq Er EPERM
A user other than the super-user attempted to set the FFclock data.
@@ -172,7 +172,7 @@
.Nm ffclock_getcounter ,
or directly in bypass mode.
The clock parameters could be obtained via
-.Fn ffclock_getestimate ,
+.Fn ffclock_getdata ,
or
.Po
preferred
@@ -192,6 +192,16 @@
.Sh HISTORY
Feedforward clock support first appeared in
.Fx 10.0 .
+The
+.Fn ffclock_getdata
+and
+.Fn ffclock_setdata
+system calls were named
+.Fn ffclock_getestimate
+and
+.Fn ffclock_setestimate
+prior to
+.Fx 15 .
.Sh AUTHORS
.An -nosplit
The feedforward clock support was written by
diff --git a/sys/compat/freebsd32/freebsd32.h b/sys/compat/freebsd32/freebsd32.h
--- a/sys/compat/freebsd32/freebsd32.h
+++ b/sys/compat/freebsd32/freebsd32.h
@@ -64,7 +64,7 @@
uint32_t frac[2];
};
-struct ffclock_estimate32 {
+struct ffclock_data32 {
struct bintime32 update_time;
ffcounter update_ffcount;
ffcounter leapsec_expected;
@@ -81,9 +81,9 @@
#endif
;
#if defined(__amd64__)
-_Static_assert(sizeof(struct ffclock_estimate32) == 52, "ffclock_estimate32 size");
+_Static_assert(sizeof(struct ffclock_data32) == 52, "ffclock_data32 size");
#else
-_Static_assert(sizeof(struct ffclock_estimate32) == 56, "ffclock_estimate32 size");
+_Static_assert(sizeof(struct ffclock_data32) == 56, "ffclock_data32 size");
#endif
struct rusage32 {
diff --git a/sys/compat/freebsd32/freebsd32_misc.c b/sys/compat/freebsd32/freebsd32_misc.c
--- a/sys/compat/freebsd32/freebsd32_misc.c
+++ b/sys/compat/freebsd32/freebsd32_misc.c
@@ -4084,82 +4084,82 @@
#ifdef FFCLOCK
extern struct mtx ffclock_mtx;
-extern struct ffclock_estimate ffclock_estimate;
+extern struct ffclock_data ffclock_data;
extern int8_t ffclock_updated;
int
-freebsd32_ffclock_setestimate(struct thread *td,
- struct freebsd32_ffclock_setestimate_args *uap)
+freebsd32_ffclock_setdata(struct thread *td,
+ struct freebsd32_ffclock_setdata_args *uap)
{
- struct ffclock_estimate cest;
- struct ffclock_estimate32 cest32;
+ struct ffclock_data cdat;
+ struct ffclock_data32 cdat32;
int error;
/* Reuse of PRIV_CLOCK_SETTIME. */
if ((error = priv_check(td, PRIV_CLOCK_SETTIME)) != 0)
return (error);
- if ((error = copyin(uap->cest, &cest32,
- sizeof(struct ffclock_estimate32))) != 0)
+ if ((error = copyin(uap->cdat, &cdat32,
+ sizeof(struct ffclock_data32))) != 0)
return (error);
- CP(cest32.update_time, cest.update_time, sec);
- memcpy(&cest.update_time.frac, &cest32.update_time.frac, sizeof(uint64_t));
- CP(cest32, cest, update_ffcount);
- CP(cest32, cest, leapsec_expected);
- CP(cest32, cest, period);
- CP(cest32, cest, errb_abs);
- CP(cest32, cest, errb_rate);
- CP(cest32, cest, status);
- CP(cest32, cest, secs_to_nextupdate);
- CP(cest32, cest, leapsec_total);
- CP(cest32, cest, leapsec_next);
+ CP(cdat32.update_time, cdat.update_time, sec);
+ memcpy(&cdat.update_time.frac, &cdat32.update_time.frac, sizeof(uint64_t));
+ CP(cdat32, cdat, update_ffcount);
+ CP(cdat32, cdat, leapsec_expected);
+ CP(cdat32, cdat, period);
+ CP(cdat32, cdat, errb_abs);
+ CP(cdat32, cdat, errb_rate);
+ CP(cdat32, cdat, status);
+ CP(cdat32, cdat, secs_to_nextupdate);
+ CP(cdat32, cdat, leapsec_total);
+ CP(cdat32, cdat, leapsec_next);
mtx_lock_spin(&ffclock_mtx);
- memcpy(&ffclock_estimate, &cest, sizeof(struct ffclock_estimate));
+ memcpy(&ffclock_data, &cdat, sizeof(struct ffclock_data));
ffclock_updated++;
mtx_unlock_spin(&ffclock_mtx);
return (error);
}
int
-freebsd32_ffclock_getestimate(struct thread *td,
- struct freebsd32_ffclock_getestimate_args *uap)
+freebsd32_ffclock_getdata(struct thread *td,
+ struct freebsd32_ffclock_getdata_args *uap)
{
- struct ffclock_estimate cest;
- struct ffclock_estimate32 cest32;
+ struct ffclock_data cdat;
+ struct ffclock_data32 cdat32;
int error;
mtx_lock_spin(&ffclock_mtx);
- memcpy(&cest, &ffclock_estimate, sizeof(struct ffclock_estimate));
+ memcpy(&cdat, &ffclock_data, sizeof(struct ffclock_data));
mtx_unlock_spin(&ffclock_mtx);
- CP(cest.update_time, cest32.update_time, sec);
- memcpy(&cest32.update_time.frac, &cest.update_time.frac, sizeof(uint64_t));
- CP(cest, cest32, update_ffcount);
- CP(cest, cest32, leapsec_expected);
- CP(cest, cest32, period);
- CP(cest, cest32, errb_abs);
- CP(cest, cest32, errb_rate);
- CP(cest, cest32, status);
- CP(cest, cest32, secs_to_nextupdate);
- CP(cest, cest32, leapsec_total);
- CP(cest, cest32, leapsec_next);
-
- error = copyout(&cest32, uap->cest, sizeof(struct ffclock_estimate32));
+ CP(cdat.update_time, cdat32.update_time, sec);
+ memcpy(&cdat32.update_time.frac, &cdat.update_time.frac, sizeof(uint64_t));
+ CP(cdat, cdat32, update_ffcount);
+ CP(cdat, cdat32, leapsec_expected);
+ CP(cdat, cdat32, period);
+ CP(cdat, cdat32, errb_abs);
+ CP(cdat, cdat32, errb_rate);
+ CP(cdat, cdat32, status);
+ CP(cdat, cdat32, secs_to_nextupdate);
+ CP(cdat, cdat32, leapsec_total);
+ CP(cdat, cdat32, leapsec_next);
+
+ error = copyout(&cdat32, uap->cdat, sizeof(struct ffclock_data32));
return (error);
}
#else /* !FFCLOCK */
int
-freebsd32_ffclock_setestimate(struct thread *td,
- struct freebsd32_ffclock_setestimate_args *uap)
+freebsd32_ffclock_setdata(struct thread *td,
+ struct freebsd32_ffclock_setdata_args *uap)
{
return (ENOSYS);
}
int
-freebsd32_ffclock_getestimate(struct thread *td,
- struct freebsd32_ffclock_getestimate_args *uap)
+freebsd32_ffclock_getdata(struct thread *td,
+ struct freebsd32_ffclock_getdata_args *uap)
{
return (ENOSYS);
}
diff --git a/sys/compat/freebsd32/freebsd32_proto.h b/sys/compat/freebsd32/freebsd32_proto.h
--- a/sys/compat/freebsd32/freebsd32_proto.h
+++ b/sys/compat/freebsd32/freebsd32_proto.h
@@ -212,11 +212,11 @@
char rqtp_l_[PADL_(const struct timespec32 *)]; const struct timespec32 * rqtp; char rqtp_r_[PADR_(const struct timespec32 *)];
char rmtp_l_[PADL_(struct timespec32 *)]; struct timespec32 * rmtp; char rmtp_r_[PADR_(struct timespec32 *)];
};
-struct freebsd32_ffclock_setestimate_args {
- char cest_l_[PADL_(struct ffclock_estimate32 *)]; struct ffclock_estimate32 * cest; char cest_r_[PADR_(struct ffclock_estimate32 *)];
+struct freebsd32_ffclock_setdata_args {
+ char cdat_l_[PADL_(struct ffclock_data32 *)]; struct ffclock_data32 * cdat; char cdat_r_[PADR_(struct ffclock_data32 *)];
};
-struct freebsd32_ffclock_getestimate_args {
- char cest_l_[PADL_(struct ffclock_estimate32 *)]; struct ffclock_estimate32 * cest; char cest_r_[PADR_(struct ffclock_estimate32 *)];
+struct freebsd32_ffclock_getdata_args {
+ char cdat_l_[PADL_(struct ffclock_data32 *)]; struct ffclock_data32 * cdat; char cdat_r_[PADR_(struct ffclock_data32 *)];
};
struct freebsd32_clock_nanosleep_args {
char clock_id_l_[PADL_(clockid_t)]; clockid_t clock_id; char clock_id_r_[PADR_(clockid_t)];
@@ -729,8 +729,8 @@
int freebsd32_ktimer_settime(struct thread *, struct freebsd32_ktimer_settime_args *);
int freebsd32_ktimer_gettime(struct thread *, struct freebsd32_ktimer_gettime_args *);
int freebsd32_nanosleep(struct thread *, struct freebsd32_nanosleep_args *);
-int freebsd32_ffclock_setestimate(struct thread *, struct freebsd32_ffclock_setestimate_args *);
-int freebsd32_ffclock_getestimate(struct thread *, struct freebsd32_ffclock_getestimate_args *);
+int freebsd32_ffclock_setdata(struct thread *, struct freebsd32_ffclock_setdata_args *);
+int freebsd32_ffclock_getdata(struct thread *, struct freebsd32_ffclock_getdata_args *);
int freebsd32_clock_nanosleep(struct thread *, struct freebsd32_clock_nanosleep_args *);
int freebsd32_clock_getcpuclockid2(struct thread *, struct freebsd32_clock_getcpuclockid2_args *);
int freebsd32_aio_read(struct thread *, struct freebsd32_aio_read_args *);
@@ -1208,8 +1208,8 @@
#define FREEBSD32_SYS_AUE_freebsd32_ktimer_settime AUE_NULL
#define FREEBSD32_SYS_AUE_freebsd32_ktimer_gettime AUE_NULL
#define FREEBSD32_SYS_AUE_freebsd32_nanosleep AUE_NULL
-#define FREEBSD32_SYS_AUE_freebsd32_ffclock_setestimate AUE_NULL
-#define FREEBSD32_SYS_AUE_freebsd32_ffclock_getestimate AUE_NULL
+#define FREEBSD32_SYS_AUE_freebsd32_ffclock_setdata AUE_NULL
+#define FREEBSD32_SYS_AUE_freebsd32_ffclock_getdata AUE_NULL
#define FREEBSD32_SYS_AUE_freebsd32_clock_nanosleep AUE_NULL
#define FREEBSD32_SYS_AUE_freebsd32_clock_getcpuclockid2 AUE_NULL
#define FREEBSD32_SYS_AUE_freebsd32_aio_read AUE_AIO_READ
diff --git a/sys/compat/freebsd32/freebsd32_syscall.h b/sys/compat/freebsd32/freebsd32_syscall.h
--- a/sys/compat/freebsd32/freebsd32_syscall.h
+++ b/sys/compat/freebsd32/freebsd32_syscall.h
@@ -217,8 +217,8 @@
#define FREEBSD32_SYS_ktimer_getoverrun 239
#define FREEBSD32_SYS_freebsd32_nanosleep 240
#define FREEBSD32_SYS_ffclock_getcounter 241
-#define FREEBSD32_SYS_freebsd32_ffclock_setestimate 242
-#define FREEBSD32_SYS_freebsd32_ffclock_getestimate 243
+#define FREEBSD32_SYS_freebsd32_ffclock_setdata 242
+#define FREEBSD32_SYS_freebsd32_ffclock_getdata 243
#define FREEBSD32_SYS_freebsd32_clock_nanosleep 244
#define FREEBSD32_SYS_freebsd32_clock_getcpuclockid2 247
#define FREEBSD32_SYS_minherit 250
diff --git a/sys/compat/freebsd32/freebsd32_syscalls.c b/sys/compat/freebsd32/freebsd32_syscalls.c
--- a/sys/compat/freebsd32/freebsd32_syscalls.c
+++ b/sys/compat/freebsd32/freebsd32_syscalls.c
@@ -247,8 +247,8 @@
"ktimer_getoverrun", /* 239 = ktimer_getoverrun */
"freebsd32_nanosleep", /* 240 = freebsd32_nanosleep */
"ffclock_getcounter", /* 241 = ffclock_getcounter */
- "freebsd32_ffclock_setestimate", /* 242 = freebsd32_ffclock_setestimate */
- "freebsd32_ffclock_getestimate", /* 243 = freebsd32_ffclock_getestimate */
+ "freebsd32_ffclock_setdata", /* 242 = freebsd32_ffclock_setdata */
+ "freebsd32_ffclock_getdata", /* 243 = freebsd32_ffclock_getdata */
"freebsd32_clock_nanosleep", /* 244 = freebsd32_clock_nanosleep */
"#245", /* 245 = reserved for local use */
"#246", /* 246 = reserved for local use */
diff --git a/sys/compat/freebsd32/freebsd32_sysent.c b/sys/compat/freebsd32/freebsd32_sysent.c
--- a/sys/compat/freebsd32/freebsd32_sysent.c
+++ b/sys/compat/freebsd32/freebsd32_sysent.c
@@ -303,8 +303,8 @@
{ .sy_narg = AS(ktimer_getoverrun_args), .sy_call = (sy_call_t *)sys_ktimer_getoverrun, .sy_auevent = AUE_NULL, .sy_flags = SYF_CAPENABLED, .sy_thrcnt = SY_THR_STATIC }, /* 239 = ktimer_getoverrun */
{ .sy_narg = AS(freebsd32_nanosleep_args), .sy_call = (sy_call_t *)freebsd32_nanosleep, .sy_auevent = AUE_NULL, .sy_flags = SYF_CAPENABLED, .sy_thrcnt = SY_THR_STATIC }, /* 240 = freebsd32_nanosleep */
{ .sy_narg = AS(ffclock_getcounter_args), .sy_call = (sy_call_t *)sys_ffclock_getcounter, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 241 = ffclock_getcounter */
- { .sy_narg = AS(freebsd32_ffclock_setestimate_args), .sy_call = (sy_call_t *)freebsd32_ffclock_setestimate, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 242 = freebsd32_ffclock_setestimate */
- { .sy_narg = AS(freebsd32_ffclock_getestimate_args), .sy_call = (sy_call_t *)freebsd32_ffclock_getestimate, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 243 = freebsd32_ffclock_getestimate */
+ { .sy_narg = AS(freebsd32_ffclock_setdata_args), .sy_call = (sy_call_t *)freebsd32_ffclock_setdata, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 242 = freebsd32_ffclock_setdata */
+ { .sy_narg = AS(freebsd32_ffclock_getdata_args), .sy_call = (sy_call_t *)freebsd32_ffclock_getdata, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 243 = freebsd32_ffclock_getdata */
{ .sy_narg = AS(freebsd32_clock_nanosleep_args), .sy_call = (sy_call_t *)freebsd32_clock_nanosleep, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 244 = freebsd32_clock_nanosleep */
{ .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 245 = reserved for local use */
{ .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 246 = reserved for local use */
diff --git a/sys/compat/freebsd32/freebsd32_systrace_args.c b/sys/compat/freebsd32/freebsd32_systrace_args.c
--- a/sys/compat/freebsd32/freebsd32_systrace_args.c
+++ b/sys/compat/freebsd32/freebsd32_systrace_args.c
@@ -1203,17 +1203,17 @@
*n_args = 1;
break;
}
- /* freebsd32_ffclock_setestimate */
+ /* freebsd32_ffclock_setdata */
case 242: {
- struct freebsd32_ffclock_setestimate_args *p = params;
- uarg[a++] = (intptr_t)p->cest; /* struct ffclock_estimate32 * */
+ struct freebsd32_ffclock_setdata_args *p = params;
+ uarg[a++] = (intptr_t)p->cdat; /* struct ffclock_data32 * */
*n_args = 1;
break;
}
- /* freebsd32_ffclock_getestimate */
+ /* freebsd32_ffclock_getdata */
case 243: {
- struct freebsd32_ffclock_getestimate_args *p = params;
- uarg[a++] = (intptr_t)p->cest; /* struct ffclock_estimate32 * */
+ struct freebsd32_ffclock_getdata_args *p = params;
+ uarg[a++] = (intptr_t)p->cdat; /* struct ffclock_data32 * */
*n_args = 1;
break;
}
@@ -5263,21 +5263,21 @@
break;
};
break;
- /* freebsd32_ffclock_setestimate */
+ /* freebsd32_ffclock_setdata */
case 242:
switch (ndx) {
case 0:
- p = "userland struct ffclock_estimate32 *";
+ p = "userland struct ffclock_data32 *";
break;
default:
break;
};
break;
- /* freebsd32_ffclock_getestimate */
+ /* freebsd32_ffclock_getdata */
case 243:
switch (ndx) {
case 0:
- p = "userland struct ffclock_estimate32 *";
+ p = "userland struct ffclock_data32 *";
break;
default:
break;
@@ -9795,12 +9795,12 @@
if (ndx == 0 || ndx == 1)
p = "int";
break;
- /* freebsd32_ffclock_setestimate */
+ /* freebsd32_ffclock_setdata */
case 242:
if (ndx == 0 || ndx == 1)
p = "int";
break;
- /* freebsd32_ffclock_getestimate */
+ /* freebsd32_ffclock_getdata */
case 243:
if (ndx == 0 || ndx == 1)
p = "int";
diff --git a/sys/kern/init_sysent.c b/sys/kern/init_sysent.c
--- a/sys/kern/init_sysent.c
+++ b/sys/kern/init_sysent.c
@@ -302,8 +302,8 @@
{ .sy_narg = AS(ktimer_getoverrun_args), .sy_call = (sy_call_t *)sys_ktimer_getoverrun, .sy_auevent = AUE_NULL, .sy_flags = SYF_CAPENABLED, .sy_thrcnt = SY_THR_STATIC }, /* 239 = ktimer_getoverrun */
{ .sy_narg = AS(nanosleep_args), .sy_call = (sy_call_t *)sys_nanosleep, .sy_auevent = AUE_NULL, .sy_flags = SYF_CAPENABLED, .sy_thrcnt = SY_THR_STATIC }, /* 240 = nanosleep */
{ .sy_narg = AS(ffclock_getcounter_args), .sy_call = (sy_call_t *)sys_ffclock_getcounter, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 241 = ffclock_getcounter */
- { .sy_narg = AS(ffclock_setestimate_args), .sy_call = (sy_call_t *)sys_ffclock_setestimate, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 242 = ffclock_setestimate */
- { .sy_narg = AS(ffclock_getestimate_args), .sy_call = (sy_call_t *)sys_ffclock_getestimate, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 243 = ffclock_getestimate */
+ { .sy_narg = AS(ffclock_setdata_args), .sy_call = (sy_call_t *)sys_ffclock_setdata, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 242 = ffclock_setdata */
+ { .sy_narg = AS(ffclock_getdata_args), .sy_call = (sy_call_t *)sys_ffclock_getdata, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 243 = ffclock_getdata */
{ .sy_narg = AS(clock_nanosleep_args), .sy_call = (sy_call_t *)sys_clock_nanosleep, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC }, /* 244 = clock_nanosleep */
{ .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 245 = reserved for local use */
{ .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT }, /* 246 = reserved for local use */
diff --git a/sys/kern/kern_ffclock.c b/sys/kern/kern_ffclock.c
--- a/sys/kern/kern_ffclock.c
+++ b/sys/kern/kern_ffclock.c
@@ -51,7 +51,7 @@
FEATURE(ffclock, "Feedforward clock support");
-extern struct ffclock_estimate ffclock_estimate;
+extern struct ffclock_data ffclock_data;
extern int8_t ffclock_updated;
extern struct mtx ffclock_mtx;
@@ -71,7 +71,7 @@
ffclock_abstime(ffcounter *ffcount, struct bintime *bt,
struct bintime *error_bound, uint32_t flags)
{
- struct ffclock_estimate cest;
+ struct ffclock_data cdat;
ffcounter ffc;
ffcounter update_ffcount;
ffcounter ffdelta_error;
@@ -84,29 +84,29 @@
ffclock_convert_abs(ffc, bt, flags);
}
- /* Current ffclock estimate, use update_ffcount as generation number. */
+ /* Current ffclock data, use update_ffcount as generation number. */
do {
- update_ffcount = ffclock_estimate.update_ffcount;
- memcpy(&cest, &ffclock_estimate,sizeof(struct ffclock_estimate));
- } while (update_ffcount != ffclock_estimate.update_ffcount);
+ update_ffcount = ffclock_data.update_ffcount;
+ memcpy(&cdat, &ffclock_data, sizeof(struct ffclock_data));
+ } while (update_ffcount != ffclock_data.update_ffcount);
/*
* Leap second adjustment. Total as seen by the FFclock daemon since it
- * started. cest.leapsec_expected is the ffcounter prediction of when
+ * started. cdat.leapsec_expected is the ffcounter prediction of when
* the next leapsecond occurs.
*/
if ((flags & FFCLOCK_LEAPSEC) == FFCLOCK_LEAPSEC) {
- bt->sec -= cest.leapsec_total; // subtracting = including leaps
- if (cest.leapsec_expected != 0 && ffc > cest.leapsec_expected)
- bt->sec -= cest.leapsec_next;
+ bt->sec -= cdat.leapsec_total; // subtracting = including leaps
+ if (cdat.leapsec_expected != 0 && ffc > cdat.leapsec_expected)
+ bt->sec -= cdat.leapsec_next;
}
/* Compute error bound if a valid pointer has been passed. */
if (error_bound) {
- ffdelta_error = ffc - cest.update_ffcount;
+ ffdelta_error = ffc - cdat.update_ffcount;
ffclock_convert_diff(ffdelta_error, error_bound);
- bintime_mul(error_bound, cest.errb_rate * PS_AS_BINFRAC);
- bintime_addx(error_bound, cest.errb_abs * NS_AS_BINFRAC);
+ bintime_mul(error_bound, cdat.errb_rate * PS_AS_BINFRAC);
+ bintime_addx(error_bound, cdat.errb_abs * NS_AS_BINFRAC);
}
if (ffcount)
@@ -130,9 +130,9 @@
if (error_bound) {
do {
- update_ffcount = ffclock_estimate.update_ffcount;
- err_rate = ffclock_estimate.errb_rate;
- } while (update_ffcount != ffclock_estimate.update_ffcount);
+ update_ffcount = ffclock_data.update_ffcount;
+ err_rate = ffclock_data.errb_rate;
+ } while (update_ffcount != ffclock_data.update_ffcount);
ffclock_convert_diff(ffdelta, error_bound);
bintime_mul(error_bound, err_rate * PS_AS_BINFRAC);
@@ -395,34 +395,33 @@
/*
* System call allowing the synchronisation daemon to push new feedforward
- * clock estimates to the kernel. Acquire ffclock_mtx to prevent concurrent
+ * clock data to the kernel. Acquire ffclock_mtx to prevent concurrent
* updates and ensure data consistency.
- * NOTE: ffclock_updated signals the fftimehands that new estimates are
- * available. The updated estimates are picked up by the fftimehands on next
- * tick, which could take as long as 1/hz seconds (if ticks are not missed).
+ * NOTE: ffclock_updated signals the fftimehands that new data is available.
+ * The updated data is picked up by the fftimehands on next tick, which could
+ * take as long as 1/hz seconds (if ticks are not missed).
*/
#ifndef _SYS_SYSPROTO_H_
-struct ffclock_setestimate_args {
- struct ffclock_estimate *cest;
+struct ffclock_setdata_args {
+ struct ffclock_data *cdat;
};
#endif
/* ARGSUSED */
int
-sys_ffclock_setestimate(struct thread *td, struct ffclock_setestimate_args *uap)
+sys_ffclock_setdata(struct thread *td, struct ffclock_setdata_args *uap)
{
- struct ffclock_estimate cest;
+ struct ffclock_data cdat;
int error;
/* Reuse of PRIV_CLOCK_SETTIME. */
if ((error = priv_check(td, PRIV_CLOCK_SETTIME)) != 0)
return (error);
- if ((error = copyin(uap->cest, &cest, sizeof(struct ffclock_estimate)))
- != 0)
+ if ((error = copyin(uap->cdat, &cdat,sizeof(struct ffclock_data))) != 0)
return (error);
mtx_lock_spin(&ffclock_mtx);
- memcpy(&ffclock_estimate, &cest, sizeof(struct ffclock_estimate));
+ memcpy(&ffclock_data, &cdat, sizeof(struct ffclock_data));
ffclock_updated++;
mtx_unlock_spin(&ffclock_mtx);
@@ -430,26 +429,26 @@
}
/*
- * System call allowing userland applications to retrieve the clock estimates
+ * System call allowing userland applications to retrieve the clock data
* stored within the kernel. It is useful to kickstart the synchronisation
* daemon with the kernel's knowledge of hardware timecounter.
*/
#ifndef _SYS_SYSPROTO_H_
-struct ffclock_getestimate_args {
- struct ffclock_estimate *cest;
+struct ffclock_getdata_args {
+ struct ffclock_data *cdat;
};
#endif
/* ARGSUSED */
int
-sys_ffclock_getestimate(struct thread *td, struct ffclock_getestimate_args *uap)
+sys_ffclock_getdata(struct thread *td, struct ffclock_getdata_args *uap)
{
- struct ffclock_estimate cest;
+ struct ffclock_data cdat;
int error;
mtx_lock_spin(&ffclock_mtx);
- memcpy(&cest, &ffclock_estimate, sizeof(struct ffclock_estimate));
+ memcpy(&cdat, &ffclock_data, sizeof(struct ffclock_data));
mtx_unlock_spin(&ffclock_mtx);
- error = copyout(&cest, uap->cest, sizeof(struct ffclock_estimate));
+ error = copyout(&cdat, uap->cdat, sizeof(struct ffclock_data));
return (error);
}
@@ -463,14 +462,14 @@
}
int
-sys_ffclock_setestimate(struct thread *td, struct ffclock_setestimate_args *uap)
+sys_ffclock_setdata(struct thread *td, struct ffclock_setdata_args *uap)
{
return (ENOSYS);
}
int
-sys_ffclock_getestimate(struct thread *td, struct ffclock_getestimate_args *uap)
+sys_ffclock_getdata(struct thread *td, struct ffclock_getdata_args *uap)
{
return (ENOSYS);
diff --git a/sys/kern/kern_tc.c b/sys/kern/kern_tc.c
--- a/sys/kern/kern_tc.c
+++ b/sys/kern/kern_tc.c
@@ -518,14 +518,14 @@
* separately.
*/
-/* Feedforward clock estimates kept updated by the synchronization daemon. */
-struct ffclock_estimate ffclock_estimate;
+/* Feedforward clock data kept updated by the synchronization daemon. */
+struct ffclock_data ffclock_data; /* natFFC data from FFclock daemon. */
uint32_t ffclock_status; /* feedforward clock status. */
-int8_t ffclock_updated; /* New estimates are available. */
-struct mtx ffclock_mtx; /* Mutex on ffclock_estimate. */
+int8_t ffclock_updated; /* New data is available. */
+struct mtx ffclock_mtx; /* Mutex on ffclock_data. */
struct fftimehands {
- struct ffclock_estimate cest; /* natFFC daemon data */
+ struct ffclock_data cdat; /* natFFC daemon data */
struct bintime tick_time; /* natFFC */
struct bintime tick_time_mono; /* monoFFC */
struct bintime tick_time_diff; /* diffFFC */
@@ -611,7 +611,7 @@
ffclock_windup(unsigned int delta, struct bintime *reset_FBbootime,
struct bintime *reset_UTC)
{
- struct ffclock_estimate *cest;
+ struct ffclock_data *cdat;
struct fftimehands *ffth;
struct bintime bt, gap, upt;
ffcounter ffdelta;
@@ -622,7 +622,7 @@
ffth = fftimehands->next;
ogen = ffth->gen;
ffth->gen = 0;
- cest = &ffth->cest;
+ cdat = &ffth->cdat;
/* Move FF counter forward to existing tick start. */
ffdelta = (ffcounter)delta;
@@ -634,7 +634,7 @@
*/
if (reset_FBbootime) {
/* Acceptable to ignore a potentially pending update here. */
- memcpy(cest, &fftimehands->cest,sizeof(struct ffclock_estimate));
+ memcpy(cdat, &fftimehands->cdat,sizeof(struct ffclock_data));
/*
* Set value of ffclock_boottime to maximize Upclock continuity.
@@ -669,21 +669,21 @@
ffth->tick_time_diff = *reset_UTC;
/* Reset natFFC to reflect the reset, effected at tick-start. */
- cest->update_time = *reset_UTC;
- cest->update_ffcount = ffth->tick_ffcount;
- if (cest->period == 0) // if never set
- cest->period = ((1ULL << 63)/ \
+ cdat->update_time = *reset_UTC;
+ cdat->update_ffcount = ffth->tick_ffcount;
+ if (cdat->period == 0) // if never set
+ cdat->period = ((1ULL << 63)/ \
timehands->th_counter->tc_frequency) << 1;
- cest->errb_abs = 0;
- cest->errb_rate = 0;
- cest->status = FFCLOCK_STA_UNSYNC;
- cest->secs_to_nextupdate = 0; // no daemon update since reset
- cest->leapsec_expected = 0;
- cest->leapsec_total = 0;
- cest->leapsec_next = 0;
+ cdat->errb_abs = 0;
+ cdat->errb_rate = 0;
+ cdat->status = FFCLOCK_STA_UNSYNC;
+ cdat->secs_to_nextupdate = 0; // no daemon update since reset
+ cdat->leapsec_expected = 0;
+ cdat->leapsec_total = 0;
+ cdat->leapsec_next = 0;
mtx_lock_spin(&ffclock_mtx);
- memcpy(&ffclock_estimate, cest,sizeof(struct ffclock_estimate));
+ memcpy(&ffclock_data, cdat,sizeof(struct ffclock_data));
ffclock_updated = 0; // signal no daemon update to process
mtx_unlock_spin(&ffclock_mtx);
@@ -691,7 +691,7 @@
/* Reset remaining fftimehands members. */
ffth->tick_error.sec = ffth->tick_error.frac = 0;
- ffth->period_mono = cest->period;
+ ffth->period_mono = cdat->period;
upt = ffth->tick_time_mono;
bintime_sub(&upt, &ffth->ffclock_boottime);
@@ -710,9 +710,9 @@
/*
* Signal to ignore a stale daemon update following a RTC reset.
*/
- if (ffclock_updated > 0 && fftimehands->cest.secs_to_nextupdate == 0
- && bintime_cmp(&fftimehands->cest.update_time,
- &ffclock_estimate.update_time,>) ) {
+ if (ffclock_updated > 0 && fftimehands->cdat.secs_to_nextupdate == 0
+ && bintime_cmp(&fftimehands->cdat.update_time,
+ &ffclock_data.update_time,>) ) {
ffclock_updated = 0;
printf("Ignoring stale natFFC update following RTC reset.\n");
}
@@ -724,14 +724,14 @@
*/
if (ffclock_updated <= 0 && reset_FBbootime == NULL) {
- /* Update natFFC members {cest, tick_time{_diff}, tick_error} */
- memcpy(cest, &fftimehands->cest,sizeof(struct ffclock_estimate));
+ /* Update natFFC members {cdat, tick_time{_diff}, tick_error} */
+ memcpy(cdat, &fftimehands->cdat,sizeof(struct ffclock_data));
ffth->tick_time = fftimehands->tick_time;
ffth->tick_time_diff = fftimehands->tick_time_diff;
- ffclock_convert_delta(ffdelta, cest->period, &bt);
+ ffclock_convert_delta(ffdelta, cdat->period, &bt);
bintime_add(&ffth->tick_time, &bt);
bintime_add(&ffth->tick_time_diff, &bt);
- bintime_mul(&bt, cest->errb_rate * PS_AS_BINFRAC);
+ bintime_mul(&bt, cdat->errb_rate * PS_AS_BINFRAC);
bintime_add(&ffth->tick_error, &bt);
/* Update monoFFC members {period_mono, tick_time_mono}. */
@@ -747,9 +747,9 @@
*/
if (ffclock_updated == 0) {
bt = ffth->tick_time;
- bintime_sub(&bt, &cest->update_time);
+ bintime_sub(&bt, &cdat->update_time);
if (bt.sec > 3 * FFCLOCK_SKM_SCALE &&
- bt.sec > 3 * cest->secs_to_nextupdate)
+ bt.sec > 3 * cdat->secs_to_nextupdate)
ffclock_status |= FFCLOCK_STA_UNSYNC;
}
@@ -761,14 +761,14 @@
*/
if (ffclock_updated > 0) {
- /* Update natFFC members {cest, tick_time, tick_error}. */
- memcpy(cest, &ffclock_estimate,sizeof(struct ffclock_estimate));
- ffdelta = ffth->tick_ffcount - cest->update_ffcount;
- ffth->tick_time = cest->update_time;
- ffclock_convert_delta(ffdelta, cest->period, &bt);
+ /* Update natFFC members {cdat, tick_time, tick_error}. */
+ memcpy(cdat, &ffclock_data,sizeof(struct ffclock_data));
+ ffdelta = ffth->tick_ffcount - cdat->update_ffcount;
+ ffth->tick_time = cdat->update_time;
+ ffclock_convert_delta(ffdelta, cdat->period, &bt);
bintime_add(&ffth->tick_time, &bt);
- bintime_mul(&bt, cest->errb_rate * PS_AS_BINFRAC);
- bintime_addx(&bt, cest->errb_abs * NS_AS_BINFRAC);
+ bintime_mul(&bt, cdat->errb_rate * PS_AS_BINFRAC);
+ bintime_addx(&bt, cdat->errb_abs * NS_AS_BINFRAC);
ffth->tick_error = bt;
/*
@@ -776,7 +776,7 @@
* continuity over ticks.
*/
ffth->tick_time_diff = fftimehands->tick_time_diff;
- ffclock_convert_delta((ffcounter)delta, cest->period, &bt);
+ ffclock_convert_delta((ffcounter)delta, cdat->period, &bt);
bintime_add(&ffth->tick_time_diff, &bt);
/*
@@ -814,7 +814,7 @@
* If the jump is forward, then monoFFC remains monotonic.
*/
if (((ffclock_status & FFCLOCK_STA_UNSYNC) == FFCLOCK_STA_UNSYNC)
- && ((cest->status & FFCLOCK_STA_UNSYNC) == 0) ) {
+ && ((cdat->status & FFCLOCK_STA_UNSYNC) == 0) ) {
if (forward_jump) {
printf("ffwindup: forward");
bintime_add(&ffth->ffclock_boottime, &gap);
@@ -846,22 +846,22 @@
* is capped at 5000PPM (5ms/s). If there is no gap, the clocks
* will agree throughout the new tick.
*/
- ffth->period_mono = cest->period; // re-initialize
+ ffth->period_mono = cdat->period; // re-initialize
/* Keep default if no visible gap or no daemon updates yet. */
- if (bintime_isset(&gap) && cest->secs_to_nextupdate > 0) {
+ if (bintime_isset(&gap) && cdat->secs_to_nextupdate > 0) {
/* Calculate cap */
bt.sec = 0;
bt.frac = 5000000 * NS_AS_BINFRAC;
- bintime_mul(&bt, cest->secs_to_nextupdate);
+ bintime_mul(&bt, cdat->secs_to_nextupdate);
if (bintime_cmp(&gap, &bt, >))
gap = bt; // gap = min(gap, bt)
/* Convert secs_to_nextupdate to counter units. */
frac = 0;
frac -= 1; // approximate 2^64 with (2^64)-1 for ease
- ffdelta = (frac/cest->period) * cest->secs_to_nextupdate;
+ ffdelta = (frac/cdat->period) * cdat->secs_to_nextupdate;
/* Store the portion of gap per cycle in frac. */
frac = 0;
@@ -877,7 +877,7 @@
ffth->period_mono -= frac;
}
- ffclock_status = cest->status; // unsets FFCLOCK_STA_UNSYNC
+ ffclock_status = cdat->status; // unsets FFCLOCK_STA_UNSYNC
ffclock_updated = 0; // signal latest update done
}
@@ -902,7 +902,7 @@
ffclock_change_tc(struct timehands *th, unsigned int ncount)
{
struct fftimehands *ffth;
- struct ffclock_estimate *cest;
+ struct ffclock_data *cdat;
struct timecounter *tc;
uint8_t ogen;
ffcounter now;
@@ -913,7 +913,7 @@
ffth = fftimehands->next;
ogen = ffth->gen;
ffth->gen = 0;
- cest = &ffth->cest;
+ cdat = &ffth->cdat;
/*
* Origin setting: reset FFcounter to match start of the current tick.
@@ -934,26 +934,26 @@
(ffcounter)((unsigned int)now - ncount);
}
- memcpy(cest, &(fftimehands->cest), sizeof(struct ffclock_estimate));
- cest->update_ffcount = ffth->tick_ffcount;
- cest->secs_to_nextupdate = 0;
- cest->period = ((1ULL << 63) / tc->tc_frequency ) << 1;
- cest->errb_abs = 0;
- cest->errb_rate = 0;
- cest->status |= FFCLOCK_STA_UNSYNC;
- cest->leapsec_expected = 0;
- cest->leapsec_total = 0;
- cest->leapsec_next = 0;
+ memcpy(cdat, &(fftimehands->cdat), sizeof(struct ffclock_data));
+ cdat->update_ffcount = ffth->tick_ffcount;
+ cdat->secs_to_nextupdate = 0;
+ cdat->period = ((1ULL << 63) / tc->tc_frequency ) << 1;
+ cdat->errb_abs = 0;
+ cdat->errb_rate = 0;
+ cdat->status |= FFCLOCK_STA_UNSYNC;
+ cdat->leapsec_expected = 0;
+ cdat->leapsec_total = 0;
+ cdat->leapsec_next = 0;
ffth->tick_time = fftimehands->tick_time;
ffth->tick_error = fftimehands->tick_error;
ffth->tick_time_diff = fftimehands->tick_time_diff;
ffth->tick_time_mono = fftimehands->tick_time_mono;
- ffth->period_mono = cest->period;
+ ffth->period_mono = cdat->period;
/* Push the reset natFFC data to the global variable. */
mtx_lock_spin(&ffclock_mtx);
- memcpy(&ffclock_estimate, cest, sizeof(struct ffclock_estimate));
+ memcpy(&ffclock_data, cdat, sizeof(struct ffclock_data));
ffclock_updated--; // ensure next daemon update will be ignored
mtx_unlock_spin(&ffclock_mtx);
@@ -1028,7 +1028,7 @@
*bt = ffth->tick_time_diff;
else
*bt = ffth->tick_time;
- ffclock_convert_delta(ffdelta, ffth->cest.period, &bt2);
+ ffclock_convert_delta(ffdelta, ffth->cdat.period, &bt2);
}
if (ffcount > ffth->tick_ffcount)
@@ -1059,7 +1059,7 @@
do {
ffth = fftimehands;
gen = ffth->gen;
- ffclock_convert_delta(ffdelta, ffth->cest.period, bt);
+ ffclock_convert_delta(ffdelta, ffth->cdat.period, bt);
} while (gen == 0 || gen != ffth->gen);
}
@@ -1236,7 +1236,7 @@
#ifdef FFCLOCK
struct ffclock_info *ffi;
struct fftimehands *ffth;
- struct ffclock_estimate cest;
+ struct ffclock_data cdat;
#endif
delta = 0;
@@ -1261,10 +1261,10 @@
ffi->tick_time_diff = ffth->tick_time_diff;
ffi->tick_time_mono = ffth->tick_time_mono;
ffi->ffclock_boottime = ffth->ffclock_boottime;
- ffi->period = ffth->cest.period;
+ ffi->period = ffth->cdat.period;
ffi->period_mono = ffth->period_mono;
clock_snap->ffcount = ffth->tick_ffcount;
- cest = ffth->cest;
+ cdat = ffth->cdat;
#endif
atomic_thread_fence_acq();
} while (gen == 0 || gen != th->th_generation);
@@ -1287,17 +1287,17 @@
* Pre-calculate total leap adjustment appropriate to this ffcount. That
* is, total leaps so far and impending leap ffcount may have surpassed.
*/
- ffi->leapsec_adjustment = cest.leapsec_total;
- if (cest.leapsec_expected != 0 && clock_snap->ffcount >
- cest.leapsec_expected)
- ffi->leapsec_adjustment += cest.leapsec_next;
+ ffi->leapsec_adjustment = cdat.leapsec_total;
+ if (cdat.leapsec_expected != 0 && clock_snap->ffcount >
+ cdat.leapsec_expected)
+ ffi->leapsec_adjustment += cdat.leapsec_next;
/* Record feedforward clock status and error. */
- ffi->status = cest.status;
+ ffi->status = cdat.status;
ffi->error = ffth->tick_error;
if (!fast) {
- ffclock_convert_delta((ffcounter)delta, cest.period, &bt);
- bintime_mul(&bt, cest.errb_rate * PS_AS_BINFRAC);
+ ffclock_convert_delta((ffcounter)delta, cdat.period, &bt);
+ bintime_mul(&bt, cdat.errb_rate * PS_AS_BINFRAC);
bintime_add(&ffi->error, &bt);
}
#endif
@@ -2093,7 +2093,7 @@
#ifdef FFCLOCK
*ffcount = pps->capffth->tick_ffcount + tcount;
bt = pps->capffth->tick_time;
- ffclock_convert_delta(tcount, pps->capffth->cest.period, &bt);
+ ffclock_convert_delta(tcount, pps->capffth->cdat.period, &bt);
bintime_add(&bt, &pps->capffth->tick_time);
(*pseq_ffc)++;
bintime2timespec(&bt, tsp_ffc);
diff --git a/sys/kern/syscalls.c b/sys/kern/syscalls.c
--- a/sys/kern/syscalls.c
+++ b/sys/kern/syscalls.c
@@ -247,8 +247,8 @@
"ktimer_getoverrun", /* 239 = ktimer_getoverrun */
"nanosleep", /* 240 = nanosleep */
"ffclock_getcounter", /* 241 = ffclock_getcounter */
- "ffclock_setestimate", /* 242 = ffclock_setestimate */
- "ffclock_getestimate", /* 243 = ffclock_getestimate */
+ "ffclock_setdata", /* 242 = ffclock_setdata */
+ "ffclock_getdata", /* 243 = ffclock_getdata */
"clock_nanosleep", /* 244 = clock_nanosleep */
"#245", /* 245 = reserved for local use */
"#246", /* 246 = reserved for local use */
diff --git a/sys/kern/syscalls.master b/sys/kern/syscalls.master
--- a/sys/kern/syscalls.master
+++ b/sys/kern/syscalls.master
@@ -1428,13 +1428,13 @@
);
}
242 AUE_NULL STD {
- int ffclock_setestimate(
- _In_ _Contains_timet_ struct ffclock_estimate *cest
+ int ffclock_setdata(
+ _In_ _Contains_timet_ struct ffclock_data *cdat
);
}
243 AUE_NULL STD {
- int ffclock_getestimate(
- _Out_ _Contains_timet_ struct ffclock_estimate *cest
+ int ffclock_getdata(
+ _Out_ _Contains_timet_ struct ffclock_data *cdat
);
}
244 AUE_NULL STD {
diff --git a/sys/kern/systrace_args.c b/sys/kern/systrace_args.c
--- a/sys/kern/systrace_args.c
+++ b/sys/kern/systrace_args.c
@@ -1226,17 +1226,17 @@
*n_args = 1;
break;
}
- /* ffclock_setestimate */
+ /* ffclock_setdata */
case 242: {
- struct ffclock_setestimate_args *p = params;
- uarg[a++] = (intptr_t)p->cest; /* struct ffclock_estimate * */
+ struct ffclock_setdata_args *p = params;
+ uarg[a++] = (intptr_t)p->cdat; /* struct ffclock_data * */
*n_args = 1;
break;
}
- /* ffclock_getestimate */
+ /* ffclock_getdata */
case 243: {
- struct ffclock_getestimate_args *p = params;
- uarg[a++] = (intptr_t)p->cest; /* struct ffclock_estimate * */
+ struct ffclock_getdata_args *p = params;
+ uarg[a++] = (intptr_t)p->cdat; /* struct ffclock_data * */
*n_args = 1;
break;
}
@@ -5395,21 +5395,21 @@
break;
};
break;
- /* ffclock_setestimate */
+ /* ffclock_setdata */
case 242:
switch (ndx) {
case 0:
- p = "userland struct ffclock_estimate *";
+ p = "userland struct ffclock_data *";
break;
default:
break;
};
break;
- /* ffclock_getestimate */
+ /* ffclock_getdata */
case 243:
switch (ndx) {
case 0:
- p = "userland struct ffclock_estimate *";
+ p = "userland struct ffclock_data *";
break;
default:
break;
@@ -9955,12 +9955,12 @@
if (ndx == 0 || ndx == 1)
p = "int";
break;
- /* ffclock_setestimate */
+ /* ffclock_setdata */
case 242:
if (ndx == 0 || ndx == 1)
p = "int";
break;
- /* ffclock_getestimate */
+ /* ffclock_getdata */
case 243:
if (ndx == 0 || ndx == 1)
p = "int";
diff --git a/sys/sys/syscall.h b/sys/sys/syscall.h
--- a/sys/sys/syscall.h
+++ b/sys/sys/syscall.h
@@ -220,8 +220,8 @@
#define SYS_ktimer_getoverrun 239
#define SYS_nanosleep 240
#define SYS_ffclock_getcounter 241
-#define SYS_ffclock_setestimate 242
-#define SYS_ffclock_getestimate 243
+#define SYS_ffclock_setdata 242
+#define SYS_ffclock_getdata 243
#define SYS_clock_nanosleep 244
#define SYS_clock_getcpuclockid2 247
#define SYS_ntp_gettime 248
diff --git a/sys/sys/syscall.mk b/sys/sys/syscall.mk
--- a/sys/sys/syscall.mk
+++ b/sys/sys/syscall.mk
@@ -155,8 +155,8 @@
ktimer_getoverrun.o \
nanosleep.o \
ffclock_getcounter.o \
- ffclock_setestimate.o \
- ffclock_getestimate.o \
+ ffclock_setdata.o \
+ ffclock_getdata.o \
clock_nanosleep.o \
clock_getcpuclockid2.o \
ntp_gettime.o \
diff --git a/sys/sys/sysproto.h b/sys/sys/sysproto.h
--- a/sys/sys/sysproto.h
+++ b/sys/sys/sysproto.h
@@ -662,11 +662,11 @@
struct ffclock_getcounter_args {
char ffcount_l_[PADL_(ffcounter *)]; ffcounter * ffcount; char ffcount_r_[PADR_(ffcounter *)];
};
-struct ffclock_setestimate_args {
- char cest_l_[PADL_(struct ffclock_estimate *)]; struct ffclock_estimate * cest; char cest_r_[PADR_(struct ffclock_estimate *)];
+struct ffclock_setdata_args {
+ char cdat_l_[PADL_(struct ffclock_data *)]; struct ffclock_data * cdat; char cdat_r_[PADR_(struct ffclock_data *)];
};
-struct ffclock_getestimate_args {
- char cest_l_[PADL_(struct ffclock_estimate *)]; struct ffclock_estimate * cest; char cest_r_[PADR_(struct ffclock_estimate *)];
+struct ffclock_getdata_args {
+ char cdat_l_[PADL_(struct ffclock_data *)]; struct ffclock_data * cdat; char cdat_r_[PADR_(struct ffclock_data *)];
};
struct clock_nanosleep_args {
char clock_id_l_[PADL_(clockid_t)]; clockid_t clock_id; char clock_id_r_[PADR_(clockid_t)];
@@ -2018,8 +2018,8 @@
int sys_ktimer_getoverrun(struct thread *, struct ktimer_getoverrun_args *);
int sys_nanosleep(struct thread *, struct nanosleep_args *);
int sys_ffclock_getcounter(struct thread *, struct ffclock_getcounter_args *);
-int sys_ffclock_setestimate(struct thread *, struct ffclock_setestimate_args *);
-int sys_ffclock_getestimate(struct thread *, struct ffclock_getestimate_args *);
+int sys_ffclock_setdata(struct thread *, struct ffclock_setdata_args *);
+int sys_ffclock_getdata(struct thread *, struct ffclock_getdata_args *);
int sys_clock_nanosleep(struct thread *, struct clock_nanosleep_args *);
int sys_clock_getcpuclockid2(struct thread *, struct clock_getcpuclockid2_args *);
int sys_ntp_gettime(struct thread *, struct ntp_gettime_args *);
@@ -2968,8 +2968,8 @@
#define SYS_AUE_ktimer_getoverrun AUE_NULL
#define SYS_AUE_nanosleep AUE_NULL
#define SYS_AUE_ffclock_getcounter AUE_NULL
-#define SYS_AUE_ffclock_setestimate AUE_NULL
-#define SYS_AUE_ffclock_getestimate AUE_NULL
+#define SYS_AUE_ffclock_setdata AUE_NULL
+#define SYS_AUE_ffclock_getdata AUE_NULL
#define SYS_AUE_clock_nanosleep AUE_NULL
#define SYS_AUE_clock_getcpuclockid2 AUE_NULL
#define SYS_AUE_ntp_gettime AUE_NULL
diff --git a/sys/sys/timeffc.h b/sys/sys/timeffc.h
--- a/sys/sys/timeffc.h
+++ b/sys/sys/timeffc.h
@@ -40,12 +40,12 @@
#ifdef _KERNEL
/*
- * Feedforward clock estimate
+ * Feedforward clock data.
* Holds time mark as a ffcounter and conversion to bintime based on current
* timecounter period and offset estimate passed by the synchronization daemon.
* Provides time of last daemon update, clock status and bound on error.
*/
-struct ffclock_estimate {
+struct ffclock_data {
struct bintime update_time; /* FFclock time of last update. */
ffcounter update_ffcount; /* Counter value at last update. */
ffcounter leapsec_expected; /* Approx counter value of next leap. */
@@ -196,7 +196,7 @@
/*
* Feedforward clock routines.
*
- * These functions rely on the timecounters and ffclock_estimates stored in
+ * These functions rely on the timecounters and ffclock_data stored in
* fftimehands. Note that the error_bound parameter is not the error of the
* clock but an upper bound on the error of the absolute time or time interval
* returned.
@@ -239,7 +239,7 @@
/*
* Wrapper routines to convert a time interval specified in ffcounter units into
- * seconds using the current feedforward clock estimates.
+ * seconds using the current feedforward clock data.
*/
void ffclock_bindifftime(ffcounter ffdelta, struct bintime *bt);
void ffclock_nanodifftime(ffcounter ffdelta, struct timespec *tsp);
@@ -398,8 +398,8 @@
/* Feedforward Clock system calls. */
__BEGIN_DECLS
int ffclock_getcounter(ffcounter *ffcount);
-int ffclock_getestimate(struct ffclock_estimate *cest);
-int ffclock_setestimate(struct ffclock_estimate *cest);
+int ffclock_getdata(struct ffclock_data *cdat);
+int ffclock_setdata(struct ffclock_data *cdat);
__END_DECLS
#endif /* _KERNEL */

File Metadata

Mime Type
text/plain
Expires
Tue, Aug 18, 7:32 PM (17 h, 26 m)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
36905704
Default Alt Text
D42945.id131603.diff (44 KB)

Event Timeline