[GitHub] [incubator-nuttx] v01d opened a new issue #3337: INTERNAL VERSIONS OF USER FUNCTIONS

[GitBox <gi...@apache.org>]

v01d opened a new issue #3337:
URL: https://github.com/apache/incubator-nuttx/issues/3337


   ```
     Description: The internal NuttX logic uses the same interfaces as does
                  the application.  That sometime produces a problem because
                  there is "overloaded" functionality in those user interfaces
                  that are not desirable.
   
                  For example, having cancellation points hidden inside of the
                  OS can cause non-cancellation point interfaces to behave
                  strangely.
   
                  Here is another issue:  Internal OS functions should not set
                  errno and should never have to look at the errno value to
                  determine the cause of the failure.  The errno is provided
                  for compatibility with POSIX application interface
                  requirements and really doesn't need to be used within the
                  OS.
   
                  Both of these could be fixed if there were special internal
                  versions these functions.  For example, there could be a an
                  nxsem_wait() that does all of the same things as sem_wait()
                  was does not create a cancellation point and does not set
                  the errno value on failures.
   
                  Everything inside the OS would use nx_sem_wait().
                  Applications would call sem_wait() which would just be a
                  wrapper around nx_sem_wait() that adds the cancellation point
                  and that sets the errno value on failures.
   
                  On particularly difficult issue is the use of common memory
                  manager C, and NX libraries in the build.  For the PROTECTED
                  and KERNEL builds, this issue is resolved.  In that case,
                  The OS links with a different version of the libraries than
                  does the application:  The OS version would use the OS internal
                  interfaces and the application would use the standard
                  interfaces.
   
                  But for the FLAT build, both the OS and the applications use
                  the same library functions.  For applications, the library
                  functions *must* support errno's and cancellation and, hence,
                  these are also used within the OS.
   
                  But that raises yet another issue:  If the application
                  version of the libraries use the standard interfaces
                  internally, then they may generate unexpected cancellation
                  points.  For example, the memory management would take a
                  semaphore using sem_wait() to get exclusive access to the
                  heap.  That means that every call to malloc() and free()
                  would be a cancellation point, a clear POSIX violation.
   
                  Changes like that could clean up some of this internal
                  craziness.
   
                  UPDATE:
                  2017-10-03:  This change has been completed for the case of
                    semaphores used in the OS.  Still need to checkout signals
                    and messages queues that are also used in the OS.  Also
                    backed out commit b4747286b19d3b15193b2a5e8a0fe48fa0a8638c.
                  2017-10-06:  This change has been completed for the case of
                    signals used in the OS.  Still need to checkout messages
                    queues that are also used in the OS.
                  2017-10-10:  This change has been completed for the case of
                    message queue used in the OS.  I am keeping this issue
                    open because (1) there are some known remaining calls that
                    that will modify the errno (such as dup(), dup2(),
                    nxtask_activate(), kthread_create(), exec(), mq_open(),
                    mq_close(), and others) and (2) there may still be calls that
                    create cancellation points.  Need to check things like open(),
                    close(), read(), write(), and possibly others.
                  2018-01-30:  This change has been completed for the case of
                    scheduler functions used within the OS:  sched_getparam(),
                    sched_setparam(), sched_getscheduler(), sched_setschedule(),
                    and sched_setaffinity(),
                  2018-09-15:  This change has been completed for the case of
                    open() used within the OS.  There are places under libs/ and
                    boards/ that have not been converted.  I also note cases
                    where fopen() is called under libs/libc/netdb/.
                  2019-09-11:  built_isavail() no longer sets the errno variable.
   
     Status:      Open
     Priority:    Low.  Things are working OK the way they are.  But the design
                  could be improved and made a little more efficient with this
                  change.
   ```


-- 
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

For queries about this service, please contact Infrastructure at:
users@infra.apache.org