motorhead/qemu
1
0
Fork 0
mirror of https://github.com/Motorhead1991/qemu.git synced 2025-08-03 15:53:54 -06:00
Code Issues Projects Releases Packages Wiki Activity Actions

* Support for jemalloc

Browse source 
* qemu_mutex_lock_iothread "No such process" fix
 * cutils: qemu_strto* wrappers
 * iohandler.c simplification
 * Many other fixes and misc patches.
 
 And some MTTCG work (with Emilio's fixes squashed):
 * Signal-free TCG kick
 * Removing spinlock in favor of QemuMutex
 * User-mode emulation multi-threading fixes/docs
 -----BEGIN PGP SIGNATURE-----
 Version: GnuPG v2
 
 iQEcBAABCAAGBQJV8Tk7AAoJEL/70l94x66Ds3QH/3bi0RRR2NtKIXAQrGo5tfuD
 NPMu1K5Hy+/26AC6mEVNRh4kh7dPH5E4NnDGbxet1+osvmpjxAjc2JrxEybhHD0j
 fkpzqynuBN6cA2Gu5GUNoKzxxTmi2RrEYigWDZqCftRXBeO2Hsr1etxJh9UoZw5H
 dgpU3j/n0Q8s08jUJ1o789knZI/ckwL4oXK4u2KhSC7ZTCWhJT7Qr7c0JmiKReaF
 JEYAsKkQhICVKRVmC8NxML8U58O8maBjQ62UN6nQpVaQd0Yo/6cstFTZsRrHMHL3
 7A2Tyg862cMvp+1DOX3Bk02yXA+nxnzLF8kUe0rYo6llqDBDStzqyn1j9R0qeqA=
 =nB06
 -----END PGP SIGNATURE-----

Merge remote-tracking branch 'remotes/bonzini/tags/for-upstream' into staging

* Support for jemalloc
* qemu_mutex_lock_iothread "No such process" fix
* cutils: qemu_strto* wrappers
* iohandler.c simplification
* Many other fixes and misc patches.

And some MTTCG work (with Emilio's fixes squashed):
* Signal-free TCG kick
* Removing spinlock in favor of QemuMutex
* User-mode emulation multi-threading fixes/docs

# gpg: Signature made Thu 10 Sep 2015 09:03:07 BST using RSA key ID 78C7AE83
# gpg: Good signature from "Paolo Bonzini <bonzini@gnu.org>"
# gpg:                 aka "Paolo Bonzini <pbonzini@redhat.com>"

* remotes/bonzini/tags/for-upstream: (44 commits)
  cutils: work around platform differences in strto{l,ul,ll,ull}
  cpu-exec: fix lock hierarchy for user-mode emulation
  exec: make mmap_lock/mmap_unlock globally available
  tcg: comment on which functions have to be called with mmap_lock held
  tcg: add memory barriers in page_find_alloc accesses
  remove unused spinlock.
  replace spinlock by QemuMutex.
  cpus: remove tcg_halt_cond and tcg_cpu_thread globals
  cpus: protect work list with work_mutex
  scripts/dump-guest-memory.py: fix after RAMBlock change
  configure: Add support for jemalloc
  add macro file for coccinelle
  configure: factor out adding disas configure
  vhost-scsi: fix wrong vhost-scsi firmware path
  checkpatch: remove tests that are not relevant outside the kernel
  checkpatch: adapt some tests to QEMU
  CODING_STYLE: update mixed declaration rules
  qmp: Add example usage of strto*l() qemu wrapper
  cutils: Add qemu_strtoull() wrapper
  cutils: Add qemu_strtoll() wrapper
  ...

Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
This commit is contained in:
Peter Maydell 2015-09-14 16:13:16 +01:00
commit a2aa09e181
56 changed files with 2049 additions and 1043 deletions
Download patch file Download diff file Expand all files Collapse all files

150
util/cutils.c
View file

@ -353,6 +353,156 @@ int64_t strtosz(const char *nptr, char **end)
return strtosz_suffix(nptr, end, STRTOSZ_DEFSUFFIX_MB);
}
/**
* Helper function for qemu_strto*l() functions.
*/
static int check_strtox_error(const char *p, char *endptr, const char **next,
int err)
{
/* If no conversion was performed, prefer BSD behavior over glibc
* behavior.
*/
if (err == 0 && endptr == p) {
err = EINVAL;
}
if (!next && *endptr) {
return -EINVAL;
}
if (next) {
*next = endptr;
}
return -err;
}
/**
* QEMU wrappers for strtol(), strtoll(), strtoul(), strotull() C functions.
*
* Convert ASCII string @nptr to a long integer value
* from the given @base. Parameters @nptr, @endptr, @base
* follows same semantics as strtol() C function.
*
* Unlike from strtol() function, if @endptr is not NULL, this
* function will return -EINVAL whenever it cannot fully convert
* the string in @nptr with given @base to a long. This function returns
* the result of the conversion only through the @result parameter.
*
* If NULL is passed in @endptr, then the whole string in @ntpr
* is a number otherwise it returns -EINVAL.
*
* RETURN VALUE
* Unlike from strtol() function, this wrapper returns either
* -EINVAL or the errno set by strtol() function (e.g -ERANGE).
* If the conversion overflows, -ERANGE is returned, and @result
* is set to the max value of the desired type
* (e.g. LONG_MAX, LLONG_MAX, ULONG_MAX, ULLONG_MAX). If the case
* of underflow, -ERANGE is returned, and @result is set to the min
* value of the desired type. For strtol(), strtoll(), @result is set to
* LONG_MIN, LLONG_MIN, respectively, and for strtoul(), strtoull() it
* is set to 0.
*/
int qemu_strtol(const char *nptr, const char **endptr, int base,
long *result)
{
char *p;
int err = 0;
if (!nptr) {
if (endptr) {
*endptr = nptr;
}
err = -EINVAL;
} else {
errno = 0;
*result = strtol(nptr, &p, base);
err = check_strtox_error(nptr, p, endptr, errno);
}
return err;
}
/**
* Converts ASCII string to an unsigned long integer.
*
* If string contains a negative number, value will be converted to
* the unsigned representation of the signed value, unless the original
* (nonnegated) value would overflow, in this case, it will set @result
* to ULONG_MAX, and return ERANGE.
*
* The same behavior holds, for qemu_strtoull() but sets @result to
* ULLONG_MAX instead of ULONG_MAX.
*
* See qemu_strtol() documentation for more info.
*/
int qemu_strtoul(const char *nptr, const char **endptr, int base,
unsigned long *result)
{
char *p;
int err = 0;
if (!nptr) {
if (endptr) {
*endptr = nptr;
}
err = -EINVAL;
} else {
errno = 0;
*result = strtoul(nptr, &p, base);
/* Windows returns 1 for negative out-of-range values. */
if (errno == ERANGE) {
*result = -1;
}
err = check_strtox_error(nptr, p, endptr, errno);
}
return err;
}
/**
* Converts ASCII string to a long long integer.
*
* See qemu_strtol() documentation for more info.
*/
int qemu_strtoll(const char *nptr, const char **endptr, int base,
int64_t *result)
{
char *p;
int err = 0;
if (!nptr) {
if (endptr) {
*endptr = nptr;
}
err = -EINVAL;
} else {
errno = 0;
*result = strtoll(nptr, &p, base);
err = check_strtox_error(nptr, p, endptr, errno);
}
return err;
}
/**
* Converts ASCII string to an unsigned long long integer.
*
* See qemu_strtol() documentation for more info.
*/
int qemu_strtoull(const char *nptr, const char **endptr, int base,
uint64_t *result)
{
char *p;
int err = 0;
if (!nptr) {
if (endptr) {
*endptr = nptr;
}
err = -EINVAL;
} else {
errno = 0;
*result = strtoull(nptr, &p, base);
/* Windows returns 1 for negative out-of-range values. */
if (errno == ERANGE) {
*result = -1;
}
err = check_strtox_error(nptr, p, endptr, errno);
}
return err;
}
/**
* parse_uint:
*