Date: Fri, 22 Jan 2016 11:15:18 +0200 From: Boris Astardzhiev <boris.astardzhiev@gmail.com> To: Bruce Evans <brde@optusnet.com.au> Cc: Konstantin Belousov <kostikbel@gmail.com>, threads@freebsd.org, Jilles Tjoelker <jilles@stack.nl>, net@freebsd.org Subject: Re: Does FreeBSD have sendmmsg or recvmmsg system calls? Message-ID: <CAP=KkTw=ML=oPo2OgFfmor_nsL3om6HvmTQjKNMrOiU_dmWc2g@mail.gmail.com> In-Reply-To: <20160121233040.E1864@besplex.bde.org> References: <CAP=KkTxVaqZvigg78Dg%2Bv8kuTCaZyky8x15NHqD9uabuRKRkMw@mail.gmail.com> <20160116195657.GJ3942@kib.kiev.ua> <20160116202534.GK3942@kib.kiev.ua> <20160117211853.GA37847@stack.nl> <20160118044826.GS3942@kib.kiev.ua> <CAP=KkTy3J=k7hokGhohcGXv%2BWLnaxJmiAPxqmX9FHt7k0=Dp7Q@mail.gmail.com> <20160118140811.GW3942@kib.kiev.ua> <CAP=KkTzLCOnJVqt5F3ZuuZUiwkmWcne2Ynpi6-daE2jTzSBtfw@mail.gmail.com> <20160120073154.GB3942@kib.kiev.ua> <CAP=KkTx3dAUuSBrJiwNAAe%2BhHSG4j5Qp7sAcgtOgmVi8a12k1A@mail.gmail.com> <20160121093509.GK3942@kib.kiev.ua> <20160121233040.E1864@besplex.bde.org>
next in thread | previous in thread | raw e-mail | index | archive | help
--001a114715826cd8660529e8a863
Content-Type: text/plain; charset=UTF-8
be>None of the above. Plain recvmsg() returns ssize_t and its len arg has
be>type size_t. That is excessively typedefed and excessively large with
be>64-bit ssize_t, but it is silly for the multiple-message variant to use
be>smaller types.
be>
be>Otherwise, all the integer types should be int.
It seems logical. I'll convert the ret easily to ssize_t and the vector
length
to size_t. Now it differs from the Linux prototype but I guess it's okay.
be>The errno method (and not checking ret at all) is best if for syscalls
that
be>return -1 for a non-error. It is not needed here.
Fixing it.
kb> I do not see any sense in making the functions with signature or
semantic
kb> different from Linux version. Right now, the goal of including the
patch
kb> is compatibility.
Regarding recvmmsg() -
I tried to implement MSG_WAITFORONE and the timeout stuff using pselect(2)
due to the timespec structure. I could have used ppoll and I'm not sure
which
of these two is more appropriate or maybe there's another approach?
Now it has timeout just as in the Linux prototype.
Comments are welcomed.
See patch.
Best regards,
Boris Astardzhiev
On Thu, Jan 21, 2016 at 3:27 PM, Bruce Evans <brde@optusnet.com.au> wrote:
> On Thu, 21 Jan 2016, Konstantin Belousov wrote:
>
> On Wed, Jan 20, 2016 at 10:29:47AM +0200, Boris Astardzhiev wrote:
>>
>
> kb>Shouldn't i and rcvd be unsigned as well ? Shouldn't return value
>>> kb>also be unsigned ?
>>> I think i and rcvd should be unsigned whereas ret should not - after all
>>> if an error occurred we get -1.
>>>
>> I looked at the real signatures and man pages for the Linux functions,
>> finally. There is indeed the timeout arg, the MSG_WAITFORONE flag for
>> recvmmsg(3), and Linux uses ints for what would be naturally size_t.
>>
>
> It knows better than POSIX, so has restored the v7 types :-). Probably
> not intentionally.
>
> FreeBSD-1 used the v7 types for recv* in FreeBSD-1, but this was changed
> in 4.4BSD-Lite1.
>
> kb>> + rcvd = 0;
>>> kb>> + for (i = 0; i < vlen; i++) {
>>> kb>> + errno = 0;
>>> kb>> + ret = __sys_recvmsg(s, &msgvec[i].msg_hdr, flags);
>>> kb>> + if (ret < 0 || errno != 0) {
>>> kb>I do not see why do you need to clear errno before, and then do this
>>> test.
>>> kb>Just check ret == -1, in which case errno was set from the immediate
>>> syscall.
>>> kb>
>>> kb>> + if (rcvd != 0) {
>>> kb>> + /* We've received messages. Let caller
>>> know. */
>>> kb>> + errno = 0;
>>> kb>This cleaning is not needed as well. For successfull functions
>>> returns,
>>> kb>errno value is undefined.
>>>
>>> Wouldn't I confuse apps if they check errno in the follow case - I want
>>> to
>>> receive two messages. The first __sys_recvmsg succeeds and then for the
>>> second __sys_recvmsg fails. Thus errno will be != 0 and I'm telling the
>>> app
>>> that I have received one message by returning 1 but errno will be != 0.
>>> Is this correct?
>>>
>>
>> errno value is only defined after the function explicitely returned error.
>> Apps which test for errno without testing for error are wrong.
>>
>
> Mostly such tests find wrong implementations. Only low quality
> implmentations set error for non-errors.
>
> I checked some details:
>
> - both C99 and POSIX.1-2001 forbid setting errno to 0 in library functions
>
> - C99 and draft C11 explicitly say that errno may be clobbered for
> non-errors by functions that are not documented to set errno. It
> intends to also say that errno may not be clobbered for non-errors by
> functions are documented to set errno, but actually says nothing
> about this case (except in a footnote, it says "Thus [the usual
> method of setting errno before the call and checking it after
> ``should'' be used to check for errors]." Footnotes are not part
> of the standard, so this also says nothing. But it gives the intent.
>
> - C99 doesn't say anything specific about this for strtol. But strtol
> needs errno to not be set on non-error for its API. This gives the
> intent of the documentation for errno in the standard itself.
>
> - POSIX.1-2001 says that applications "should" only be examined when it is
> indicated to be valid by a function's return value. This is wrong for
> all functions where errno is part of the API (like strtol), and it
> would be inconsistent with C99 and C11 if these standards said what they
> intend to say, for many more functions. First, all of the C99 functions
> that are documented to set errno. Then, if POSIX follows the spirit of
> the intent of C99, then just about all POSIX functions must not clobber
> errno for non-errors, since (unlike in C99) just about all functions in
> POSIX are documented to set errno.
>
> - POSIX.1-2001 apparently agrees with me that C99 doesn't say what it
> intends to say. It explicitly says that strtol shall not change "t
> setting of" errno on success, and marks this as an extension of C99.
>
> - I couldn't find even a buggy generic clause in POSIX.1-2001 saying
> what C99 intends to say even for the C99 parts of POSIX. If there
> were such a clause, then strtol wouldn't need a special extension.
> This means that some other C99 functions need special clauses, and
> there are likely to be bugs in this since some don't really need
> them except to conform with C99's intentions.
>
> - not many C99 functions are specified to set errno. The main ones
> are the strtol family, math functions (most can set ERANGE or EDOM),
> and wide character functions (many can set EILSEQ). POSIX.1-2001
> seems to be missing a special clause for the first wide character
> function that I looked at -- fputwc(). For math functions, it has
> special statements ad nauseum (about 20 lines per function for
> duplicated for 20-50 functions).
>
> Bruce
>
--001a114715826cd8660529e8a863
Content-Type: text/plain; charset=US-ASCII; name="sendrecvmmsg-libconly4.diff"
Content-Disposition: attachment; filename="sendrecvmmsg-libconly4.diff"
Content-Transfer-Encoding: base64
X-Attachment-Id: f_ijpgx4140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--001a114715826cd8660529e8a863--
Want to link to this message? Use this URL: <https://mail-archive.FreeBSD.org/cgi/mid.cgi?CAP=KkTw=ML=oPo2OgFfmor_nsL3om6HvmTQjKNMrOiU_dmWc2g>