|
Hi,
As part of an IGMPv3 implementation on FreeBSD I
had to add a list to a datastructure (in_multi). This list can be set by users
(using ioctl) and be replaced later. While
replacing this list, there is the possibility (ad1) of a concurrent reader (the
process when an incoming packet has to be passed to a socket). So just
replacing this list and deleting the old one makes no sense.
There could think of two ways to implement
this:
1) a locking strategy: lock when updating and while
being used ... however, this slows down the process of incoming
packets
-or-
2) simply save the old list, and delete it at the
next replacement of the list (ad 2)
Or is there a common strategy in FreeBSD to handle
a situation like this ? Could anybody comment on this.
Thanks, Wilbert
Ad 1)
It is true that this replacement of the
list will *not* preempt in this case since the reader is delivery of
an ip packet to a socket, which is done at splnet(), while this routine
doesn't even use splimp(). But this precaution is just to make sure it will be
safe in the case of multi-processors. Or did I miss something ?
struct in_multi {
...
struct isf_entry *inm_sflist,
*inm_sfoldlist; /* source filter list
*/
...
};
While replacing the list, the old one is stored in
inm_sfoldlist, so current readers won't be harmed by invalid pointers while
deleting the list. At a next replacement, the old list is simply deleted since
the assumption is really valid that there won't be any readers of the old list.
(Not eve when a multi-threaded program starts to fool around with the
filterlist).
Btw. There will be a hashing schema over this
structure, to determine whether a source ip is in the set.
|
