| Age | Commit message (Collapse) | Author |
|---|
|
All operations will now yield appropriately, allowing them to be used
freely in concurrent applications. This commit also deprecates the
functions listed below, although they won't raise deprecation
warnings until OTP 21:
zlib:adler32
zlib:crc32
zlib:inflateChunk
zlib:getBufSize
zlib:setBufSize
The behavior of throwing an error when a dictionary is required for
decompression has also been deprecated.
|
|
* sverker/refactor:
erts: Introduce struct binary_internals
erts: Introduce erts_bin_release
erts: Init refc=1 in erts_bin_drv_alloc*
erts: Init refc=1 in erts_bin_nrml_alloc
erts: Remove deliberate leak of hipe fun entries
erts: Remove hipe_bifs:remove_refs_from/1
Refactor hipe specific code to use ErtsCodeInfo
erts: Refactor ErtsCodeInfo.native
|
|
* lukas/erts/print_complex_crash_slogan/OTP-14303:
erts: Print more complex terms in crash reason
|
|
which serves no purpose after all the
hipe load&purge fixes merged at
32729cab75325de58bf127e6e8836348071b8682
|
|
|
|
|
|
|
|
Strictly speaking 'true' and 'false' arguments is not necessary,
but it should work if supplied.
|
|
'rickard/new-purge-strategy/OTP-13833' into maint
* rickard/fun-purge-bug/OTP-13809:
Fix purge of code
Reclaim literal area after purge has completed
Separate literal area from code
Conflicts:
erts/doc/src/erlang.xml
erts/emulator/beam/beam_bif_load.c
erts/emulator/beam/erl_init.c
erts/preloaded/ebin/init.beam
|
|
Ensure that we cannot get any dangling pointers into code that
has been purged. This is done by a two phase purge. At first
phase all fun entries pointing into the code to purge are marked
for purge. All processes trying to call these funs will be suspended
and by this we avoid getting new direct references into the code.
When all processes has been checked, these processes are resumed.
The new purge strategy now also completely ignore the existence of
indirect references to the code (funs). If such exist, they will
cause bad fun exceptions to the caller, but will not prevent a
soft purge or cause a kill of a process having such live references
during a hard purge. This since it is impossible to give any
guarantees that no processes in the system have such indirect
references. Even when the system is completely clean from such
references, new ones can appear via distribution and/or disk.
|
|
When init:stop is called it walks the application hierarchy
and terminates each process. Some of these processes may do
something while terminating and sometimes that something
needs to load some new code in order to work. When this happens
the code_server could just be in the process of terminating
or the erl_prim_loader could be active. In both these cases
the request to load the new code would cause a deadlock in the
termination of the system.
This commit fixes this by init rejecting attempts to load new code
when init:stop has been called and fixing a termination race in
the code_server.
This however means that the process that tried to do something
when told to terminate (for instance logging that it is terminating)
will crash instead of loading the code.
|
|
as erlang:halt does it for us now
|
|
just to make things simpler.
|
|
|
|
Usage: erl -profile_boot ...
|
|
Add the possibility to use modules as trace data receivers. The functions
in the module have to be nifs as otherwise complex trace probes will be
very hard to handle (complex means trace probes for ports for example).
This commit changes the way that the ptab->tracer field works from always
being an immediate, to now be NIL if no tracer is present or else be
the tuple {TracerModule, TracerState} where TracerModule is an atom that
is later used to lookup the appropriate tracer callbacks to call and
TracerState is just passed to the tracer callback. The default process and
port tracers have been rewritten to use the new API.
This commit also changes the order which trace messages are delivered to the
potential tracer process. Any enif_send done in a tracer module may be delayed
indefinitely because of lock order issues. If a message is delayed any other
trace message send from that process is also delayed so that order is preserved
for each traced entity. This means that for some trace events (i.e. send/receive)
the events may come in an unintuitive order (receive before send) to the
trace receiver. Timestamps are taken when the trace message is generated so
trace messages from differented processes may arrive with the timestamp
out of order.
Both the erlang:trace and seq_trace:set_system_tracer accept the new tracer
module tracers and also the backwards compatible arguments.
OTP-10267
|
|
* henrik/update-copyrightyear:
update copyright-year
|
|
Use erlang:prepare_loading/1 and erlang:finish_loading/1 to load
modules in parallel to potentially decrease start-up times.
|
|
fetch_loaded/1 returns a list of tuples, not a list of atoms.
|
|
|
|
Problem: erlang:purge_module/1 is not safe in the sense
that very bad things may happen if the code to be purged
is still referred to by live processes.
Introduce erts_internal:purge_module which is the same as the old
erlang:purge_module BIF (except it returns false if no such old module).
Implement erlang:purge_module in Erlang and let it invoke
erts_code_purger for safe purging where all clogging processes
first are killed.
|
|
There is no need to use the concat/1 function since all arguments
that are passed to it have known types.
|
|
The 'init' module fetches command line parameters and passes them
to erl_prim_loader:start/3.
The code can be simplified if 'init' calls a new
erl_prim_loader:start/0 function that itself fetches the necessary
command line parameters. Also remove the documentation for the start()
function, since it there is no way that it can be usefully called by
a user application.
While we are at it, also get rid of '-id' command line parameter,
which is fetched and stored but never actually used.
|
|
erl_prim_loader:get_files/2 was an optimization introduced before the
SMP emulator (that is, before R11). The idea was to use the async
threads in the efile driver to read multiple BEAM files from the disk
in parallel.
In a modern computer with the SMP emulator, loading a BEAM module
seems to be more time-consuming than reading it from disk. To optimize
loading we would need to load several modules in parallel. We could
modify get_files/2 so that it would support parallel loading, but it
is cleaner to first remove get_files/2 and then (in a future commit),
introduce new functions to support parallel loading.
|
|
The compact wall of arguments makes it hard to see what is actually
happening in eval_script().
Collect the arguments into a record.
|
|
Expansion of $ROOT in paths are handled specially compared to boot
variables. There is no reason $ROOT can't be handled as a boot
variable.
We can simplify the expansion of boot variables if we spend a little
extra effort upfront collecting all boot variables into a map.
Make the error checking for -boot_var arguments stricter. Only allow
-boot_var followed by exactly two arguments to help users catch
errors earlier.
|
|
The last clause in start_it/1 calls a function in some module.
It goes to great length to catch any exception and pass them on
unchanged, and if there was a normal return, it will just return
the return value. It can been seen that the entire 'catch'
construction with the reference trick is totally unnecessary.
|
|
The get_flag/3 function which returns a default value if the
flag doesn't exist, is implemented in terms of get_flag/2
which throws an exception if the flag doesn't exist.
get_flag/3 is frequently used for the flags that don't exist,
which means that means that an exception will be generated and
catched for no good reason.
Reimplement get_flag/3 so that it doesn't have to call get_flag/2
and catch an exception. Eliminate the get_flag/2 function by
writing a special purpose function for the only time it's used,
that is for retrieving the value for the -root flag. As a
side-effect, we will get a nicer error message if there is
something wrong with the -root flag.
Similarly, simplify get_flag_list/3 and remove get_flag_list/2.
We can also eliminate search/3 and use the lists:keyfind/3
BIF instead.
|
|
The handling of flags has been incrementally messed up over
time, leading to convoluted code. Rewrite the parsing and
lookup of flags. By using the appropriate data structures,
the code will become simpler.
|
|
On load handler process not being launched on a restart, NIF's
such as asn1rt_nif require it to be present for correct loading.
|
|
|
|
|
|
|
|
If file:name_native_encoding() returns 'utf8', any arguments following
the -run option are assumed to be encoded in UTF-8. -eval should
treat is argument the same way.
|
|
When release_handler makes a release permanent, it calls
init:make_permanent/2 in order to set the path to the config and boot
file. The paths are coverterd to binaries, and this commit changes
this conversion from using lists_to_binary/1 to using
unicode:characters_to_binary/3 with the encoding set according to the
file name encoding mode (+fnu/fna/fnl).
|
|
|
|
OTP-10702
Arguments to functions started with the -s option to erl were
converted to atoms with list_to_atom(binary_to_list(Bin)) and thus
were always seen as latin1 encoded.
For other arguments to erl the conversion (to string) would take into
account the file name translation mode (set with +fnl, +fnu or +fna
switch to erl) and try to convert using
unicode:characters_to_list/2. The reason behind this is that it must
be possible to give paths and filenames on the command line and get
the expected encoding.
With the same reasoning, this commit changes the behaviour for
arguments to functions started with the -s option to also take
into account the file name translation mode. The arguments are now
converted to atoms by
list_to_atom(unicode:characters_to_list(Bin,file:native_name_encoding())
|
|
|
|
This is a workaround for init:restart.
The root problem is that delete/purge_module does not
clean up internal hipe bookkeeping (hipe_mfa_info's)
properly.
Symptom: Execution of deallocated beam code.
|
|
Putenv and getenv needs to convert to the proper environment
strings in Unicode depending on platform and user settings for filename
encoding. Also erlexec needs to pass environment strings in an appropriate
way for kernel to pick up. All environment strings on the command
line, as well as home directory, is now passed in UTF8 on windows
and in whatever encoding you have on Unix, kernel tries to convert all
parameters and environments from UTF8 before making strings.
|
|
|
|
An incorrect spec, rpc:yield/1, has been fixed.
|
|
While at it, introduced a state() type and used it in some place.
|
|
|
|
In embedded mode, all on_load handlers will be called after
loading all modules but before starting any servers. Therefore,
if an on_load handler calls any function in the code module that
calls the code server (such as code:priv_dir/1), there will be a
deadlock because the code server has not yet been started.
Fix this problem by invoking the on_load handlers after
having started most servers in the kernel application.
|
|
* ks/erts:
hipe_bif0.c: Remove $Id$
erts/preloaded: Add types and specs
|
|
|
|
An on_load function is supposed to return 'true' to indicate
that the module should be loaded, and 'false' if it should be
unloaded. But returning any other term, as well as causing an
exception, will also unload the module.
Since we don't like boolean values mixed with other values,
change the expected return value as follows:
* If 'ok' is returned, the module will remain loaded and become
callable.
* If any other value is returned (or an exception is generated),
the module will be unloaded. Also, if the returned value is
not an atom, send a warning message to the error_logger
(using error_logger:warning_msg/2).
The new interpretation of the return value means that an on_load
function can now directly return the return value from
erlang:load_nif/2.
|
|
|
