Samba 3.0.22 Porting by Vidya Sagar

3
However, MPE interfaces such as intrinsic(s) and CI commands escape to the POSIX name server when the file name
begins with the “.” or “/” escape characters.
File Access and Security: In MPE/iX, POSIX 1003.1 file permission bits have not been implemented as a separate
access control mechanism. Instead, POSIX 1003.1 functions support the file permission bits via the MPE ACD
mechanism. ACDs themselves have been enhanced to enable the ACD mechanism to operate as a POSIX 1003.1
additional access control mechanism and to provide directory access control.
POSIX 1003.1 applications use POSIX file permission bits to specify access permissions and are unaware that file
permission bits are implemented on top of the ACD mechanism. On the other hand, MPE applications never deal with
POSIX file permission bits; they deal with ACDs, the file access matrix, and lockwords. When a POSIX 1003.1 interface
such as open() creates a file, an ACD is assigned to the file as part of the file creation operation. When the POSIX 1003.1
function chmod() is invoked to set access permissions for a file or directory, ACD information is manipulated. Similarly, the
stat() and fstat() functions evaluate an ACD and map the access permissions granted by the ACD into file permission bits
using this mapping in reverse.
Process Management: In MPE/iX, if a parent process terminates without waiting for all of its child processes to terminate,
the resulting "orphaned" child processes are terminated immediately prior to termination of the parent process. The
implementation does not allow orphaned child processes to be adopted by a system process. Your application should not
rely upon orphaned child processes being adopted by a system process. No user process can be a controlling process.
Only system processes, such as the MPE/iX Command Interpreter (CI), are allowed to be controlling processes.
Signals: In MPE/iX, signals cannot be delivered to a process while that process is executing system code. The signal
remains pending until control returns to the calling process. A sending process cannot rely on timely delivery of a signal if
the target process is executing system code. For example, if a signal is generated for a process when the process is
executing a call to read() or write(), the signal remains pending until the function call returns either after successful
transfer of data or when an error is encountered. If multiple occurrences of a signal are generated while that signal is
blocked and pending, each occurrence of the signal is left pending. If the signal is later unblocked, multiple instances of
that signal can be delivered to the process.
Refer Implementation details of POSIX on MPE/iX [5] for more details and design considerations of POSIX on MPE.
GNU tools/utilities
This section is intended to provide some basic idea about the GNU tools and various assorted ‘Open Source’ utilities
which are used to compile and build any open source freeware portable application.
It is often quite cumbersome to distribute a portable software package in a way that takes care of all the dependencies. To
solve this problem GNU provides various tools and utilities. A few of the most important are discussed briefly here and will
be referenced also in the
porting section of this document.
gcc: GNU c and c++ compiler. The gcc compiler was ported on MPE/iX by Mark Klein and can be downloaded from
http://jazz.external.hp.com/src/gnu/gnuframe.html. It contains all the necessary tools required for a POSIX compliant
software package to be built.
make: make is a powerful and very useful utility to maintain a set of program generated and interdependent files. The
UNIX
make utility was originally designed for maintaining C program files in order to prevent unnecessary recompilation.
However,
make is eminently useful for maintaining any set of files with interdependencies. For example, make can be
used to maintain C++ or HTML source code. In fact, NIS (Network Information Service) uses make to maintain user
information. The make utility provides a way of codifying the relationships between files as well as the commands that
need to be generated to bring files up to date when they are changed. The make utility provides a powerful,
nonprocedural, template-based way to maintain files. You tell
make what needs to be done and supply some rules, and
make figures out the rest.
makefiles: A makefile is set of make commands i.e build rules governing the compile, link and installation of the
software package. The makefile describes what set of files can be built and how to build those files. Four types of lines
are allowable in a makefile: target lines, shell command lines, macro lines, and
make directive lines (such as include).
Comments in a makefile are denoted by the pound sign (
#). When you invoke make, it looks for a file named makefile in