faraphel/chrony
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

ntp: allocate source records dynamically

Browse source 
This removes the limit on maximum number of added NTP sources.
This commit is contained in:
Miroslav Lichvar 2014-09-24 14:49:51 +02:00
parent d92583ed33
commit 9e71932c2e
1 changed files with 155 additions and 94 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

249
ntp_sources.c
View file

@ -31,6 +31,7 @@
#include "sysincl.h" #include "sysincl.h"
#include "array.h"
#include "ntp_sources.h" #include "ntp_sources.h"
#include "ntp_core.h" #include "ntp_core.h"
#include "util.h" #include "util.h"
@ -50,18 +51,12 @@ typedef struct {
NCR_Instance data; /* Data for the protocol engine for this source */ NCR_Instance data; /* Data for the protocol engine for this source */
} SourceRecord; } SourceRecord;
#define N_RECORDS 256 /* Hash table of SourceRecord, the size should be a power of two */
static ARR_Instance records;
/* Fixed size table, because we use a hard coded hash algorithm. It
is rather unlikely we would have anything approaching this number
of sources. */
static SourceRecord records[N_RECORDS];
/* Number of sources in the hash table */
static int n_sources; static int n_sources;
/* The largest number of sources we want to have stored in the hash table */
#define MAX_SOURCES 64
/* Flag indicating new sources will be started automatically when added */ /* Flag indicating new sources will be started automatically when added */
static int auto_start_sources = 0; static int auto_start_sources = 0;
@ -88,6 +83,7 @@ static NSR_SourceResolvingEndHandler resolving_end_handler = NULL;
/* Forward prototypes */ /* Forward prototypes */
static void resolve_sources(void *arg); static void resolve_sources(void *arg);
static void rehash_records(void);
static void static void
slew_sources(struct timeval *raw, slew_sources(struct timeval *raw,
@ -104,16 +100,23 @@ static int initialised = 0;
/* ================================================== */ /* ================================================== */
static SourceRecord *
get_record(unsigned index)
{
return (SourceRecord *)ARR_GetElement(records, index);
}
/* ================================================== */
void void
NSR_Initialise(void) NSR_Initialise(void)
{ {
int i;
for (i=0; i<N_RECORDS; i++) {
records[i].remote_addr = NULL;
}
n_sources = 0; n_sources = 0;
initialised = 1; initialised = 1;
records = ARR_CreateInstance(sizeof (SourceRecord));
rehash_records();
LCL_AddParameterChangeHandler(slew_sources, NULL); LCL_AddParameterChangeHandler(slew_sources, NULL);
} }
@ -122,16 +125,20 @@ NSR_Initialise(void)
void void
NSR_Finalise(void) NSR_Finalise(void)
{ {
int i; SourceRecord *record;
struct UnresolvedSource *us; struct UnresolvedSource *us;
unsigned int i;
for (i = 0; i < N_RECORDS; i++) { for (i = 0; i < ARR_GetSize(records); i++) {
if (!records[i].remote_addr) record = get_record(i);
if (!record->remote_addr)
continue; continue;
records[i].remote_addr = NULL; record->remote_addr = NULL;
NCR_DestroyInstance(records[i].data); NCR_DestroyInstance(record->data);
} }
ARR_DestroyInstance(records);
while (unresolved_sources) { while (unresolved_sources) {
us = unresolved_sources; us = unresolved_sources;
unresolved_sources = us->next; unresolved_sources = us->next;
@ -159,12 +166,13 @@ NSR_Finalise(void)
static void static void
find_slot(NTP_Remote_Address *remote_addr, int *slot, int *found) find_slot(NTP_Remote_Address *remote_addr, int *slot, int *found)
{ {
SourceRecord *record;
uint32_t hash; uint32_t hash;
unsigned int i, size; unsigned int i, size;
unsigned short port; unsigned short port;
uint8_t *ip6; uint8_t *ip6;
size = N_RECORDS; size = ARR_GetSize(records);
switch (remote_addr->ip_addr.family) { switch (remote_addr->ip_addr.family) {
case IPADDR_INET6: case IPADDR_INET6:
@ -187,13 +195,14 @@ find_slot(NTP_Remote_Address *remote_addr, int *slot, int *found)
for (i = 0; i < size / 2; i++) { for (i = 0; i < size / 2; i++) {
/* Use quadratic probing */ /* Use quadratic probing */
*slot = (hash + (i + i * i) / 2) % size; *slot = (hash + (i + i * i) / 2) % size;
record = get_record(*slot);
if (!records[*slot].remote_addr) if (!record->remote_addr)
break; break;
if (!UTI_CompareIPs(&records[*slot].remote_addr->ip_addr, if (!UTI_CompareIPs(&record->remote_addr->ip_addr,
&remote_addr->ip_addr, NULL)) { &remote_addr->ip_addr, NULL)) {
*found = records[*slot].remote_addr->port == port ? 2 : 1; *found = record->remote_addr->port == port ? 2 : 1;
return; return;
} }
} }
@ -203,10 +212,58 @@ find_slot(NTP_Remote_Address *remote_addr, int *slot, int *found)
/* ================================================== */ /* ================================================== */
/* Check if hash table of given size is sufficient to contain sources */
static int
check_hashtable_size(unsigned int sources, unsigned int size)
{
return sources * 2 + 1 < size;
}
/* ================================================== */
static void
rehash_records(void)
{
SourceRecord *record, *temp_records;
unsigned int i, old_size, new_size;
int slot, found;
old_size = ARR_GetSize(records);
temp_records = MallocArray(SourceRecord, old_size);
memcpy(temp_records, ARR_GetElements(records), old_size * sizeof (SourceRecord));
/* The size of the hash table is always a power of two */
for (new_size = 4; !check_hashtable_size(n_sources, new_size); new_size *= 2)
;
ARR_SetSize(records, new_size);
for (i = 0; i < new_size; i++)
get_record(i)->remote_addr = NULL;
for (i = 0; i < old_size; i++) {
if (!temp_records[i].remote_addr)
continue;
find_slot(temp_records[i].remote_addr, &slot, &found);
assert(!found);
record = get_record(slot);
record->remote_addr = temp_records[i].remote_addr;
record->data = temp_records[i].data;
}
Free(temp_records);
}
/* ================================================== */
/* Procedure to add a new source */ /* Procedure to add a new source */
NSR_Status NSR_Status
NSR_AddSource(NTP_Remote_Address *remote_addr, NTP_Source_Type type, SourceParameters *params) NSR_AddSource(NTP_Remote_Address *remote_addr, NTP_Source_Type type, SourceParameters *params)
{ {
SourceRecord *record;
int slot, found; int slot, found;
assert(initialised); assert(initialised);
@ -216,17 +273,25 @@ NSR_AddSource(NTP_Remote_Address *remote_addr, NTP_Source_Type type, SourceParam
if (found) { if (found) {
return NSR_AlreadyInUse; return NSR_AlreadyInUse;
} else { } else {
if (n_sources == MAX_SOURCES) { if (remote_addr->ip_addr.family != IPADDR_INET4 &&
return NSR_TooManySources;
} else if (remote_addr->ip_addr.family != IPADDR_INET4 &&
remote_addr->ip_addr.family != IPADDR_INET6) { remote_addr->ip_addr.family != IPADDR_INET6) {
return NSR_InvalidAF; return NSR_InvalidAF;
} else { } else {
n_sources++; n_sources++;
records[slot].data = NCR_GetInstance(remote_addr, type, params); /* Will need params passing through */
records[slot].remote_addr = NCR_GetRemoteAddress(records[slot].data); if (!check_hashtable_size(n_sources, ARR_GetSize(records))) {
rehash_records();
find_slot(remote_addr, &slot, &found);
}
assert(!found);
record = get_record(slot);
record->data = NCR_GetInstance(remote_addr, type, params);
record->remote_addr = NCR_GetRemoteAddress(record->data);
if (auto_start_sources) if (auto_start_sources)
NCR_StartInstance(records[slot].data); NCR_StartInstance(record->data);
return NSR_Success; return NSR_Success;
} }
} }
@ -376,12 +441,12 @@ NSR_ResolveSources(void)
void NSR_StartSources(void) void NSR_StartSources(void)
{ {
int i; unsigned int i;
for (i = 0; i < N_RECORDS; i++) { for (i = 0; i < ARR_GetSize(records); i++) {
if (!records[i].remote_addr) if (!get_record(i)->remote_addr)
continue; continue;
NCR_StartInstance(records[i].data); NCR_StartInstance(get_record(i)->data);
} }
} }
@ -401,8 +466,7 @@ void NSR_AutoStartSources(void)
NSR_Status NSR_Status
NSR_RemoveSource(NTP_Remote_Address *remote_addr) NSR_RemoveSource(NTP_Remote_Address *remote_addr)
{ {
int i, slot, found; int slot, found;
SourceRecord temp_records[N_RECORDS];
assert(initialised); assert(initialised);
@ -412,28 +476,13 @@ NSR_RemoveSource(NTP_Remote_Address *remote_addr)
} }
n_sources--; n_sources--;
records[slot].remote_addr = NULL; get_record(slot)->remote_addr = NULL;
NCR_DestroyInstance(records[slot].data); NCR_DestroyInstance(get_record(slot)->data);
/* Rehash the table to make sure there are no broken probe sequences. /* Rehash the table to make sure there are no broken probe sequences.
This is costly, but it's not expected to happen frequently. */ This is costly, but it's not expected to happen frequently. */
memcpy(temp_records, records, sizeof (records)); rehash_records();
for (i = 0; i < N_RECORDS; i++) {
records[i].remote_addr = NULL;
}
for (i = 0; i < N_RECORDS; i++) {
if (!temp_records[i].remote_addr)
continue;
find_slot(temp_records[i].remote_addr, &slot, &found);
assert(!found);
records[slot].remote_addr = temp_records[i].remote_addr;
records[slot].data = temp_records[i].data;
}
return NSR_Success; return NSR_Success;
} }
@ -443,13 +492,15 @@ NSR_RemoveSource(NTP_Remote_Address *remote_addr)
void void
NSR_RemoveAllSources(void) NSR_RemoveAllSources(void)
{ {
int i; SourceRecord *record;
unsigned int i;
for (i = 0; i < N_RECORDS; i++) { for (i = 0; i < ARR_GetSize(records); i++) {
if (!records[i].remote_addr) record = get_record(i);
if (!record->remote_addr)
continue; continue;
NCR_DestroyInstance(records[i].data); NCR_DestroyInstance(record->data);
records[i].remote_addr = NULL; record->remote_addr = NULL;
} }
} }
@ -466,7 +517,7 @@ NSR_ProcessReceive(NTP_Packet *message, struct timeval *now, double now_err, NTP
find_slot(remote_addr, &slot, &found); find_slot(remote_addr, &slot, &found);
if (found == 2) { /* Must match IP address AND port number */ if (found == 2) { /* Must match IP address AND port number */
NCR_ProcessKnown(message, now, now_err, records[slot].data, NCR_ProcessKnown(message, now, now_err, get_record(slot)->data,
local_addr->sock_fd, length); local_addr->sock_fd, length);
} else { } else {
NCR_ProcessUnknown(message, now, now_err, remote_addr, local_addr, length); NCR_ProcessUnknown(message, now, now_err, remote_addr, local_addr, length);
@ -483,14 +534,16 @@ slew_sources(struct timeval *raw,
LCL_ChangeType change_type, LCL_ChangeType change_type,
void *anything) void *anything)
{ {
int i; SourceRecord *record;
unsigned int i;
for (i=0; i<N_RECORDS; i++) { for (i = 0; i < ARR_GetSize(records); i++) {
if (records[i].remote_addr) { record = get_record(i);
if (record->remote_addr) {
if (change_type == LCL_ChangeUnknownStep) { if (change_type == LCL_ChangeUnknownStep) {
NCR_ResetInstance(records[i].data); NCR_ResetInstance(record->data);
} else { } else {
NCR_SlewTimes(records[i].data, cooked, dfreq, doffset); NCR_SlewTimes(record->data, cooked, dfreq, doffset);
} }
} }
} }
@ -501,18 +554,20 @@ slew_sources(struct timeval *raw,
int int
NSR_TakeSourcesOnline(IPAddr *mask, IPAddr *address) NSR_TakeSourcesOnline(IPAddr *mask, IPAddr *address)
{ {
int i; SourceRecord *record;
unsigned int i;
int any; int any;
NSR_ResolveSources(); NSR_ResolveSources();
any = 0; any = 0;
for (i=0; i<N_RECORDS; i++) { for (i = 0; i < ARR_GetSize(records); i++) {
if (records[i].remote_addr) { record = get_record(i);
if (record->remote_addr) {
if (address->family == IPADDR_UNSPEC || if (address->family == IPADDR_UNSPEC ||
!UTI_CompareIPs(&records[i].remote_addr->ip_addr, address, mask)) { !UTI_CompareIPs(&record->remote_addr->ip_addr, address, mask)) {
any = 1; any = 1;
NCR_TakeSourceOnline(records[i].data); NCR_TakeSourceOnline(record->data);
} }
} }
} }
@ -534,27 +589,29 @@ NSR_TakeSourcesOnline(IPAddr *mask, IPAddr *address)
int int
NSR_TakeSourcesOffline(IPAddr *mask, IPAddr *address) NSR_TakeSourcesOffline(IPAddr *mask, IPAddr *address)
{ {
int i, any, syncpeer; SourceRecord *record, *syncpeer;
unsigned int i, any;
any = 0; any = 0;
syncpeer = -1; syncpeer = NULL;
for (i=0; i<N_RECORDS; i++) { for (i = 0; i < ARR_GetSize(records); i++) {
if (records[i].remote_addr) { record = get_record(i);
if (record->remote_addr) {
if (address->family == IPADDR_UNSPEC || if (address->family == IPADDR_UNSPEC ||
!UTI_CompareIPs(&records[i].remote_addr->ip_addr, address, mask)) { !UTI_CompareIPs(&record->remote_addr->ip_addr, address, mask)) {
any = 1; any = 1;
if (NCR_IsSyncPeer(records[i].data)) { if (NCR_IsSyncPeer(record->data)) {
syncpeer = i; syncpeer = record;
continue; continue;
} }
NCR_TakeSourceOffline(records[i].data); NCR_TakeSourceOffline(record->data);
} }
} }
} }
/* Take sync peer offline as last to avoid reference switching */ /* Take sync peer offline as last to avoid reference switching */
if (syncpeer >= 0) { if (syncpeer >= 0) {
NCR_TakeSourceOffline(records[syncpeer].data); NCR_TakeSourceOffline(syncpeer->data);
} }
if (address->family == IPADDR_UNSPEC) { if (address->family == IPADDR_UNSPEC) {
@ -583,7 +640,7 @@ NSR_ModifyMinpoll(IPAddr *address, int new_minpoll)
if (found == 0) { if (found == 0) {
return 0; return 0;
} else { } else {
NCR_ModifyMinpoll(records[slot].data, new_minpoll); NCR_ModifyMinpoll(get_record(slot)->data, new_minpoll);
return 1; return 1;
} }
} }
@ -602,7 +659,7 @@ NSR_ModifyMaxpoll(IPAddr *address, int new_maxpoll)
if (found == 0) { if (found == 0) {
return 0; return 0;
} else { } else {
NCR_ModifyMaxpoll(records[slot].data, new_maxpoll); NCR_ModifyMaxpoll(get_record(slot)->data, new_maxpoll);
return 1; return 1;
} }
} }
@ -621,7 +678,7 @@ NSR_ModifyMaxdelay(IPAddr *address, double new_max_delay)
if (found == 0) { if (found == 0) {
return 0; return 0;
} else { } else {
NCR_ModifyMaxdelay(records[slot].data, new_max_delay); NCR_ModifyMaxdelay(get_record(slot)->data, new_max_delay);
return 1; return 1;
} }
} }
@ -640,7 +697,7 @@ NSR_ModifyMaxdelayratio(IPAddr *address, double new_max_delay_ratio)
if (found == 0) { if (found == 0) {
return 0; return 0;
} else { } else {
NCR_ModifyMaxdelayratio(records[slot].data, new_max_delay_ratio); NCR_ModifyMaxdelayratio(get_record(slot)->data, new_max_delay_ratio);
return 1; return 1;
} }
} }
@ -659,7 +716,7 @@ NSR_ModifyMaxdelaydevratio(IPAddr *address, double new_max_delay_dev_ratio)
if (found == 0) { if (found == 0) {
return 0; return 0;
} else { } else {
NCR_ModifyMaxdelaydevratio(records[slot].data, new_max_delay_dev_ratio); NCR_ModifyMaxdelaydevratio(get_record(slot)->data, new_max_delay_dev_ratio);
return 1; return 1;
} }
} }
@ -678,7 +735,7 @@ NSR_ModifyMinstratum(IPAddr *address, int new_min_stratum)
if (found == 0) { if (found == 0) {
return 0; return 0;
} else { } else {
NCR_ModifyMinstratum(records[slot].data, new_min_stratum); NCR_ModifyMinstratum(get_record(slot)->data, new_min_stratum);
return 1; return 1;
} }
} }
@ -697,7 +754,7 @@ NSR_ModifyPolltarget(IPAddr *address, int new_poll_target)
if (found == 0) { if (found == 0) {
return 0; return 0;
} else { } else {
NCR_ModifyPolltarget(records[slot].data, new_poll_target); NCR_ModifyPolltarget(get_record(slot)->data, new_poll_target);
return 1; return 1;
} }
} }
@ -708,16 +765,18 @@ int
NSR_InitiateSampleBurst(int n_good_samples, int n_total_samples, NSR_InitiateSampleBurst(int n_good_samples, int n_total_samples,
IPAddr *mask, IPAddr *address) IPAddr *mask, IPAddr *address)
{ {
int i; SourceRecord *record;
unsigned int i;
int any; int any;
any = 0; any = 0;
for (i=0; i<N_RECORDS; i++) { for (i = 0; i < ARR_GetSize(records); i++) {
if (records[i].remote_addr) { record = get_record(i);
if (record->remote_addr) {
if (address->family == IPADDR_UNSPEC || if (address->family == IPADDR_UNSPEC ||
!UTI_CompareIPs(&records[i].remote_addr->ip_addr, address, mask)) { !UTI_CompareIPs(&record->remote_addr->ip_addr, address, mask)) {
any = 1; any = 1;
NCR_InitiateSampleBurst(records[i].data, n_good_samples, n_total_samples); NCR_InitiateSampleBurst(record->data, n_good_samples, n_total_samples);
} }
} }
} }
@ -740,7 +799,7 @@ NSR_ReportSource(RPT_SourceReport *report, struct timeval *now)
rem_addr.port = 0; rem_addr.port = 0;
find_slot(&rem_addr, &slot, &found); find_slot(&rem_addr, &slot, &found);
if (found) { if (found) {
NCR_ReportSource(records[slot].data, report, now); NCR_ReportSource(get_record(slot)->data, report, now);
} else { } else {
report->poll = 0; report->poll = 0;
report->latest_meas_ago = 0; report->latest_meas_ago = 0;
@ -752,7 +811,8 @@ NSR_ReportSource(RPT_SourceReport *report, struct timeval *now)
void void
NSR_GetActivityReport(RPT_ActivityReport *report) NSR_GetActivityReport(RPT_ActivityReport *report)
{ {
int i; SourceRecord *record;
unsigned int i;
struct UnresolvedSource *us; struct UnresolvedSource *us;
report->online = 0; report->online = 0;
@ -760,9 +820,10 @@ NSR_GetActivityReport(RPT_ActivityReport *report)
report->burst_online = 0; report->burst_online = 0;
report->burst_offline = 0; report->burst_offline = 0;
for (i=0; i<N_RECORDS; i++) { for (i = 0; i < ARR_GetSize(records); i++) {
if (records[i].remote_addr) { record = get_record(i);
NCR_IncrementActivityCounters(records[i].data, &report->online, &report->offline, if (record->remote_addr) {
NCR_IncrementActivityCounters(record->data, &report->online, &report->offline,
&report->burst_online, &report->burst_offline); &report->burst_online, &report->burst_offline);
} }
} }