自学教程：C++ uv__malloc函数代码示例

int uv_cpu_info(uv_cpu_info_t** cpu_infos, int* count) {  unsigned int ticks = (unsigned int)sysconf(_SC_CLK_TCK);  unsigned int multiplier = ((uint64_t)1000L / ticks);  unsigned int cur = 0;  uv_cpu_info_t* cpu_info;  u_int64_t* cp_times;  char model[512];  u_int64_t cpuspeed;  int numcpus;  size_t size;  int i;  size = sizeof(model);  if (sysctlbyname("machdep.cpu_brand", &model, &size, NULL, 0) &&      sysctlbyname("hw.model", &model, &size, NULL, 0)) {    return -errno;  }  size = sizeof(numcpus);  if (sysctlbyname("hw.ncpu", &numcpus, &size, NULL, 0))    return -errno;  *count = numcpus;  /* Only i386 and amd64 have machdep.tsc_freq */  size = sizeof(cpuspeed);  if (sysctlbyname("machdep.tsc_freq", &cpuspeed, &size, NULL, 0))    cpuspeed = 0;  size = numcpus * CPUSTATES * sizeof(*cp_times);  cp_times = uv__malloc(size);  if (cp_times == NULL)    return -ENOMEM;  if (sysctlbyname("kern.cp_time", cp_times, &size, NULL, 0))    return -errno;  *cpu_infos = uv__malloc(numcpus * sizeof(**cpu_infos));  if (!(*cpu_infos)) {    uv__free(cp_times);    uv__free(*cpu_infos);    return -ENOMEM;  }  for (i = 0; i < numcpus; i++) {    cpu_info = &(*cpu_infos)[i];    cpu_info->cpu_times.user = (uint64_t)(cp_times[CP_USER+cur]) * multiplier;    cpu_info->cpu_times.nice = (uint64_t)(cp_times[CP_NICE+cur]) * multiplier;    cpu_info->cpu_times.sys = (uint64_t)(cp_times[CP_SYS+cur]) * multiplier;    cpu_info->cpu_times.idle = (uint64_t)(cp_times[CP_IDLE+cur]) * multiplier;    cpu_info->cpu_times.irq = (uint64_t)(cp_times[CP_INTR+cur]) * multiplier;    cpu_info->model = uv__strdup(model);    cpu_info->speed = (int)(cpuspeed/(uint64_t) 1e6);    cur += CPUSTATES;  }  uv__free(cp_times);  return 0;}

int uv_cpu_info(uv_cpu_info_t** cpu_infos, int* count) {  uv_cpu_info_t* cpu_info;  perfstat_cpu_total_t ps_total;  perfstat_cpu_t* ps_cpus;  perfstat_id_t cpu_id;  int result, ncpus, idx = 0;  result = perfstat_cpu_total(NULL, &ps_total, sizeof(ps_total), 1);  if (result == -1) {    return UV_ENOSYS;  }  ncpus = result = perfstat_cpu(NULL, NULL, sizeof(perfstat_cpu_t), 0);  if (result == -1) {    return UV_ENOSYS;  }  ps_cpus = (perfstat_cpu_t*) uv__malloc(ncpus * sizeof(perfstat_cpu_t));  if (!ps_cpus) {    return UV_ENOMEM;  }  /* TODO(bnoordhuis) Check uv__strscpy() return value. */  uv__strscpy(cpu_id.name, FIRST_CPU, sizeof(cpu_id.name));  result = perfstat_cpu(&cpu_id, ps_cpus, sizeof(perfstat_cpu_t), ncpus);  if (result == -1) {    uv__free(ps_cpus);    return UV_ENOSYS;  }  *cpu_infos = (uv_cpu_info_t*) uv__malloc(ncpus * sizeof(uv_cpu_info_t));  if (!*cpu_infos) {    uv__free(ps_cpus);    return UV_ENOMEM;  }  *count = ncpus;  cpu_info = *cpu_infos;  while (idx < ncpus) {    cpu_info->speed = (int)(ps_total.processorHZ / 1000000);    cpu_info->model = uv__strdup(ps_total.description);    cpu_info->cpu_times.user = ps_cpus[idx].user;    cpu_info->cpu_times.sys = ps_cpus[idx].sys;    cpu_info->cpu_times.idle = ps_cpus[idx].idle;    cpu_info->cpu_times.irq = ps_cpus[idx].wait;    cpu_info->cpu_times.nice = 0;    cpu_info++;    idx++;  }  uv__free(ps_cpus);  return 0;}

static int uv_split_path(const WCHAR* filename, WCHAR** dir,    WCHAR** file) {  size_t len, i;  if (filename == NULL) {    if (dir != NULL)      *dir = NULL;    *file = NULL;    return 0;  }  len = wcslen(filename);  i = len;  while (i > 0 && filename[--i] != '//' && filename[i] != '/');  if (i == 0) {    if (dir) {      *dir = (WCHAR*)uv__malloc((MAX_PATH + 1) * sizeof(WCHAR));      if (!*dir) {        uv_fatal_error(ERROR_OUTOFMEMORY, "uv__malloc");      }      if (!GetCurrentDirectoryW(MAX_PATH, *dir)) {        uv__free(*dir);        *dir = NULL;        return -1;      }    }    *file = wcsdup(filename);  } else {    if (dir) {      *dir = (WCHAR*)uv__malloc((i + 2) * sizeof(WCHAR));      if (!*dir) {        uv_fatal_error(ERROR_OUTOFMEMORY, "uv__malloc");      }      wcsncpy(*dir, filename, i + 1);      (*dir)[i + 1] = L'/0';    }    *file = (WCHAR*)uv__malloc((len - i) * sizeof(WCHAR));    if (!*file) {      uv_fatal_error(ERROR_OUTOFMEMORY, "uv__malloc");    }    wcsncpy(*file, filename + i + 1, len - i - 1);    (*file)[len - i - 1] = L'/0';  }  return 0;}

int uv_fs_read(uv_loop_t* loop, uv_fs_t* req,               uv_file file,               const uv_buf_t bufs[],               unsigned int nbufs,               int64_t off,               uv_fs_cb cb) {  INIT(READ);  if (bufs == NULL || nbufs == 0)    return UV_EINVAL;  req->file = file;  req->nbufs = nbufs;  req->bufs = req->bufsml;  if (nbufs > ARRAY_SIZE(req->bufsml))    req->bufs = uv__malloc(nbufs * sizeof(*bufs));  if (req->bufs == NULL)    return UV_ENOMEM;  memcpy(req->bufs, bufs, nbufs * sizeof(*bufs));  req->off = off;  POST;}

static ssize_t uv__fs_readlink(uv_fs_t* req) {  ssize_t len;  char* buf;  len = uv__fs_pathmax_size(req->path);  buf = uv__malloc(len + 1);  if (buf == NULL) {    errno = ENOMEM;    return -1;  }#if defined(__MVS__)  len = os390_readlink(req->path, buf, len);#else  len = readlink(req->path, buf, len);#endif  if (len == -1) {    uv__free(buf);    return -1;  }  buf[len] = '/0';  req->ptr = buf;  return 0;}

static int uv_utf8_to_utf16_alloc(const char* s, WCHAR** ws_ptr) {  int ws_len, r;  WCHAR* ws;  ws_len = MultiByteToWideChar(CP_UTF8,                               0,                               s,                               -1,                               NULL,                               0);  if (ws_len <= 0) {    return GetLastError();  }  ws = (WCHAR*) uv__malloc(ws_len * sizeof(WCHAR));  if (ws == NULL) {    return ERROR_OUTOFMEMORY;  }  r = MultiByteToWideChar(CP_UTF8,                          0,                          s,                          -1,                          ws,                          ws_len);  assert(r == ws_len);  *ws_ptr = ws;  return 0;}

static ssize_t uv__fs_realpath(uv_fs_t* req) {  char* buf;#if defined(_POSIX_VERSION) && _POSIX_VERSION >= 200809L  buf = realpath(req->path, NULL);  if (buf == NULL)    return -1;#else  ssize_t len;  len = uv__fs_pathmax_size(req->path);  buf = uv__malloc(len + 1);  if (buf == NULL) {    errno = ENOMEM;    return -1;  }  if (realpath(req->path, buf) == NULL) {    uv__free(buf);    return -1;  }#endif  req->ptr = buf;  return 0;}

/* TODO: support barrier_attr */int pthread_barrier_init(pthread_barrier_t* barrier,                         const void* barrier_attr,                         unsigned count) {  int rc;  _uv_barrier* b;  if (barrier == NULL || count == 0)    return EINVAL;  if (barrier_attr != NULL)    return ENOTSUP;  b = (_uv_barrier*)uv__malloc(sizeof(*b));  if (b == NULL)    return ENOMEM;  b->in = 0;  b->out = 0;  b->threshold = count;  if ((rc = pthread_mutex_init(&b->mutex, NULL)) != 0)    goto error2;  if ((rc = pthread_cond_init(&b->cond, NULL)) != 0)    goto error;  barrier->b = b;  return 0;error:  pthread_mutex_destroy(&b->mutex);error2:  uv__free(b);  return rc;}

static ssize_t uv__fs_readlink(uv_fs_t* req) {  ssize_t len;  char* buf;  len = pathconf(req->path, _PC_PATH_MAX);  if (len == -1) {#if defined(PATH_MAX)    len = PATH_MAX;#else    len = 4096;#endif  }  buf = uv__malloc(len + 1);  if (buf == NULL) {    errno = ENOMEM;    return -1;  }  len = readlink(req->path, buf, len);  if (len == -1) {    uv__free(buf);    return -1;  }  buf[len] = '/0';  req->ptr = buf;  return 0;}

static int uv__get_process_title() {  WCHAR title_w[MAX_TITLE_LENGTH];  int length;  if (!GetConsoleTitleW(title_w, sizeof(title_w) / sizeof(WCHAR))) {    return -1;  }  /* Find out what the size of the buffer is that we need */  length = uv_utf16_to_utf8(title_w, -1, NULL, 0);  if (!length) {    return -1;  }  assert(!process_title);  process_title = (char*)uv__malloc(length);  if (!process_title) {    uv_fatal_error(ERROR_OUTOFMEMORY, "uv__malloc");  }  /* Do utf16 -> utf8 conversion here */  if (!uv_utf16_to_utf8(title_w, -1, process_title, length)) {    uv__free(process_title);    return -1;  }  return 0;}

int uv_barrier_init(uv_barrier_t* barrier, unsigned int count) {  struct _uv_barrier* b;  int rc;  if (barrier == NULL || count == 0)    return UV_EINVAL;  b = uv__malloc(sizeof(*b));  if (b == NULL)    return UV_ENOMEM;  b->in = 0;  b->out = 0;  b->threshold = count;  rc = uv_mutex_init(&b->mutex);  if (rc != 0)    goto error2;  rc = uv_cond_init(&b->cond);  if (rc != 0)    goto error;  barrier->b = b;  return 0;error:  uv_mutex_destroy(&b->mutex);error2:  uv__free(b);  return rc;}

int uv_getaddrinfo(uv_loop_t* loop,                   uv_getaddrinfo_t* req,                   uv_getaddrinfo_cb cb,                   const char* hostname,                   const char* service,                   const struct addrinfo* hints) {  size_t hostname_len;  size_t service_len;  size_t hints_len;  size_t len;  char* buf;  if (req == NULL || (hostname == NULL && service == NULL))    return -EINVAL;  hostname_len = hostname ? strlen(hostname) + 1 : 0;  service_len = service ? strlen(service) + 1 : 0;  hints_len = hints ? sizeof(*hints) : 0;  buf = uv__malloc(hostname_len + service_len + hints_len);  if (buf == NULL)    return -ENOMEM;  uv__req_init(loop, req, UV_GETADDRINFO);  req->loop = loop;  req->cb = cb;  req->addrinfo = NULL;  req->hints = NULL;  req->service = NULL;  req->hostname = NULL;  req->retcode = 0;  /* order matters, see uv_getaddrinfo_done() */  len = 0;  if (hints) {    req->hints = memcpy(buf + len, hints, sizeof(*hints));    len += sizeof(*hints);  }  if (service) {    req->service = memcpy(buf + len, service, service_len);    len += service_len;  }  if (hostname)    req->hostname = memcpy(buf + len, hostname, hostname_len);  if (cb) {    uv__work_submit(loop,                    &req->work_req,                    uv__getaddrinfo_work,                    uv__getaddrinfo_done);    return 0;  } else {    uv__getaddrinfo_work(&req->work_req);    uv__getaddrinfo_done(&req->work_req, 0);    return req->retcode;  }}

int uv_fs_write(uv_loop_t* loop,                uv_fs_t* req,                uv_file file,                const uv_buf_t bufs[],                unsigned int nbufs,                int64_t off,                uv_fs_cb cb) {  INIT(WRITE);  if (bufs == NULL || nbufs == 0)    return -EINVAL;  req->file = file;  req->nbufs = nbufs;  req->bufs = req->bufsml;  if (nbufs > ARRAY_SIZE(req->bufsml))    req->bufs = uv__malloc(nbufs * sizeof(*bufs));  if (req->bufs == NULL) {    if (cb != NULL)      uv__req_unregister(loop, req);    return -ENOMEM;  }  memcpy(req->bufs, bufs, nbufs * sizeof(*bufs));  req->off = off;  POST;}

int uv_cpu_info(uv_cpu_info_t** cpu_infos, int* count) {  unsigned int ticks = (unsigned int)sysconf(_SC_CLK_TCK),               multiplier = ((uint64_t)1000L / ticks), cpuspeed;  uint64_t info[CPUSTATES];  char model[512];  int numcpus = 1;  int which[] = {CTL_HW,HW_MODEL,0};  size_t size;  int i;  uv_cpu_info_t* cpu_info;  size = sizeof(model);  if (sysctl(which, 2, &model, &size, NULL, 0))    return -errno;  which[1] = HW_NCPU;  size = sizeof(numcpus);  if (sysctl(which, 2, &numcpus, &size, NULL, 0))    return -errno;  *cpu_infos = uv__malloc(numcpus * sizeof(**cpu_infos));  if (!(*cpu_infos))    return -ENOMEM;  *count = numcpus;  which[1] = HW_CPUSPEED;  size = sizeof(cpuspeed);  if (sysctl(which, 2, &cpuspeed, &size, NULL, 0)) {    SAVE_ERRNO(uv__free(*cpu_infos));    return -errno;  }  size = sizeof(info);  which[0] = CTL_KERN;  which[1] = KERN_CPTIME2;  for (i = 0; i < numcpus; i++) {    which[2] = i;    size = sizeof(info);    if (sysctl(which, 3, &info, &size, NULL, 0)) {      SAVE_ERRNO(uv__free(*cpu_infos));      return -errno;    }    cpu_info = &(*cpu_infos)[i];    cpu_info->cpu_times.user = (uint64_t)(info[CP_USER]) * multiplier;    cpu_info->cpu_times.nice = (uint64_t)(info[CP_NICE]) * multiplier;    cpu_info->cpu_times.sys = (uint64_t)(info[CP_SYS]) * multiplier;    cpu_info->cpu_times.idle = (uint64_t)(info[CP_IDLE]) * multiplier;    cpu_info->cpu_times.irq = (uint64_t)(info[CP_INTR]) * multiplier;    cpu_info->model = uv__strdup(model);    cpu_info->speed = cpuspeed;  }  return 0;}

/* * Check whether AHAFS is mounted. * Returns 0 if AHAFS is mounted, or an error code < 0 on failure */static int uv__is_ahafs_mounted(void){  char rawbuf[FILENAME_MAX+1];  int rv, i = 2;  struct vmount *p;  int size_multiplier = 10;  size_t siz = sizeof(struct vmount)*size_multiplier;  struct vmount *vmt;  const char *dev = "/aha";  char *obj, *stub;  p = uv__malloc(siz);  if (p == NULL)    return UV__ERR(errno);  /* Retrieve all mounted filesystems */  rv = mntctl(MCTL_QUERY, siz, (char*)p);  if (rv < 0)    return UV__ERR(errno);  if (rv == 0) {    /* buffer was not large enough, reallocate to correct size */    siz = *(int*)p;    uv__free(p);    p = uv__malloc(siz);    if (p == NULL)      return UV__ERR(errno);    rv = mntctl(MCTL_QUERY, siz, (char*)p);    if (rv < 0)      return UV__ERR(errno);  }  /* Look for dev in filesystems mount info */  for(vmt = p, i = 0; i < rv; i++) {    obj = vmt2dataptr(vmt, VMT_OBJECT);     /* device */    stub = vmt2dataptr(vmt, VMT_STUB);      /* mount point */    if (EQ(obj, dev) || EQ(uv__rawname(obj, &rawbuf), dev) || EQ(stub, dev)) {      uv__free(p);  /* Found a match */      return 0;    }    vmt = (struct vmount *) ((char *) vmt + vmt->vmt_length);  }  /* /aha is required for monitoring filesystem changes */  return -1;}

int uv_exepath(char* buffer, size_t* size_ptr) {  int utf8_len, utf16_buffer_len, utf16_len;  WCHAR* utf16_buffer;  int err;  if (buffer == NULL || size_ptr == NULL || *size_ptr == 0) {    return UV_EINVAL;  }  if (*size_ptr > 32768) {    /* Windows paths can never be longer than this. */    utf16_buffer_len = 32768;  } else {    utf16_buffer_len = (int) *size_ptr;  }  utf16_buffer = (WCHAR*) uv__malloc(sizeof(WCHAR) * utf16_buffer_len);  if (!utf16_buffer) {    return UV_ENOMEM;  }  /* Get the path as UTF-16. */  utf16_len = GetModuleFileNameW(NULL, utf16_buffer, utf16_buffer_len);  if (utf16_len <= 0) {    err = GetLastError();    goto error;  }  /* utf16_len contains the length, *not* including the terminating null. */  utf16_buffer[utf16_len] = L'/0';  /* Convert to UTF-8 */  utf8_len = WideCharToMultiByte(CP_UTF8,                                 0,                                 utf16_buffer,                                 -1,                                 buffer,                                 *size_ptr > INT_MAX ? INT_MAX : (int) *size_ptr,                                 NULL,                                 NULL);  if (utf8_len == 0) {    err = GetLastError();    goto error;  }  uv__free(utf16_buffer);  /* utf8_len *does* include the terminating null at this point, but the */  /* returned size shouldn't. */  *size_ptr = utf8_len - 1;  return 0; error:  uv__free(utf16_buffer);  return uv_translate_sys_error(err);}

int uv_fs_event_start(uv_fs_event_t* handle,                      uv_fs_event_cb cb,                      const char* path,                      unsigned int flags) {  struct watcher_list* w;  int events;  int err;  int wd;  if (uv__is_active(handle))    return -EINVAL;  err = init_inotify(handle->loop);  if (err)    return err;  events = UV__IN_ATTRIB         | UV__IN_CREATE         | UV__IN_MODIFY         | UV__IN_DELETE         | UV__IN_DELETE_SELF         | UV__IN_MOVE_SELF         | UV__IN_MOVED_FROM         | UV__IN_MOVED_TO;  wd = uv__inotify_add_watch(handle->loop->inotify_fd, path, events);  if (wd == -1)    return -errno;  w = find_watcher(handle->loop, wd);  if (w)    goto no_insert;  w = uv__malloc(sizeof(*w) + strlen(path) + 1);  if (w == NULL)    return -ENOMEM;  w->wd = wd;  w->path = strcpy((char*)(w + 1), path);  QUEUE_INIT(&w->watchers);  w->iterating = 0;  RB_INSERT(watcher_root, CAST(&handle->loop->inotify_watchers), w);no_insert:  uv__handle_start(handle);  QUEUE_INSERT_TAIL(&w->watchers, &handle->watchers);  handle->path = w->path;  handle->cb = cb;  handle->wd = wd;  return 0;}

int uv_cpu_info(uv_cpu_info_t** cpu_infos, int* count) {  unsigned int ticks = (unsigned int)sysconf(_SC_CLK_TCK),               multiplier = ((uint64_t)1000L / ticks);  char model[512];  uint64_t cpuspeed;  size_t size;  unsigned int i;  natural_t numcpus;  mach_msg_type_number_t msg_type;  processor_cpu_load_info_data_t *info;  uv_cpu_info_t* cpu_info;  size = sizeof(model);  if (sysctlbyname("machdep.cpu.brand_string", &model, &size, NULL, 0) &&      sysctlbyname("hw.model", &model, &size, NULL, 0)) {    return -errno;  }  size = sizeof(cpuspeed);  if (sysctlbyname("hw.cpufrequency", &cpuspeed, &size, NULL, 0))    return -errno;  if (host_processor_info(mach_host_self(), PROCESSOR_CPU_LOAD_INFO, &numcpus,                          (processor_info_array_t*)&info,                          &msg_type) != KERN_SUCCESS) {    return -EINVAL;  /* FIXME(bnoordhuis) Translate error. */  }  *cpu_infos = uv__malloc(numcpus * sizeof(**cpu_infos));  if (!(*cpu_infos)) {    vm_deallocate(mach_task_self(), (vm_address_t)info, msg_type);    return -ENOMEM;  }  *count = numcpus;  for (i = 0; i < numcpus; i++) {    cpu_info = &(*cpu_infos)[i];    cpu_info->cpu_times.user = (uint64_t)(info[i].cpu_ticks[0]) * multiplier;    cpu_info->cpu_times.nice = (uint64_t)(info[i].cpu_ticks[3]) * multiplier;    cpu_info->cpu_times.sys = (uint64_t)(info[i].cpu_ticks[1]) * multiplier;    cpu_info->cpu_times.idle = (uint64_t)(info[i].cpu_ticks[2]) * multiplier;    cpu_info->cpu_times.irq = 0;    cpu_info->model = uv__strdup(model);    cpu_info->speed = cpuspeed/1000000;  }  vm_deallocate(mach_task_self(), (vm_address_t)info, msg_type);  return 0;}

int uv__udp_send(uv_udp_send_t* req,                 uv_udp_t* handle,                 const uv_buf_t bufs[],                 unsigned int nbufs,                 const struct sockaddr* addr,                 unsigned int addrlen,                 uv_udp_send_cb send_cb) {  int err;  int empty_queue;  assert(nbufs > 0);  err = uv__udp_maybe_deferred_bind(handle, addr->sa_family, 0);  if (err)    return err;  /* It's legal for send_queue_count > 0 even when the write_queue is empty;   * it means there are error-state requests in the write_completed_queue that   * will touch up send_queue_size/count later.   */  empty_queue = (handle->send_queue_count == 0);  uv__req_init(handle->loop, req, UV_UDP_SEND);  assert(addrlen <= sizeof(req->addr));  memcpy(&req->addr, addr, addrlen);  req->send_cb = send_cb;  req->handle = handle;  req->nbufs = nbufs;  req->bufs = req->bufsml;  if (nbufs > ARRAY_SIZE(req->bufsml))    req->bufs = uv__malloc(nbufs * sizeof(bufs[0]));  if (req->bufs == NULL)    return -ENOMEM;  memcpy(req->bufs, bufs, nbufs * sizeof(bufs[0]));  handle->send_queue_size += uv__count_bufs(req->bufs, req->nbufs);  handle->send_queue_count++;  QUEUE_INSERT_TAIL(&handle->write_queue, &req->queue);  uv__handle_start(handle);  if (empty_queue && !(handle->flags & UV_UDP_PROCESSING)) {    uv__udp_sendmsg(handle);  } else {    uv__io_start(handle->loop, &handle->io_watcher, UV__POLLOUT);  }  return 0;}

static int uv_relative_path(const WCHAR* filename,                            const WCHAR* dir,	                    WCHAR** relpath) {  int dirlen = wcslen(dir);  int filelen = wcslen(filename);  if (dir[dirlen - 1] == '//')    dirlen--;  *relpath = uv__malloc((MAX_PATH + 1) * sizeof(WCHAR));  if (!*relpath)    uv_fatal_error(ERROR_OUTOFMEMORY, "uv__malloc");  wcsncpy(*relpath, filename + dirlen + 1, filelen - dirlen - 1);  (*relpath)[filelen - dirlen - 1] = L'/0';  return 0;}

static void uv_relative_path(const WCHAR* filename,                             const WCHAR* dir,                             WCHAR** relpath) {  size_t relpathlen;  size_t filenamelen = wcslen(filename);  size_t dirlen = wcslen(dir);  if (dirlen > 0 && dir[dirlen - 1] == '//')    dirlen--;  relpathlen = filenamelen - dirlen - 1;  *relpath = uv__malloc((relpathlen + 1) * sizeof(WCHAR));  if (!*relpath)    uv_fatal_error(ERROR_OUTOFMEMORY, "uv__malloc");  wcsncpy(*relpath, filename + dirlen + 1, relpathlen);  (*relpath)[relpathlen] = L'/0';}

int uv_set_process_title(const char* title) {  int err;  int length;  WCHAR* title_w = NULL;  uv__once_init();  /* Find out how big the buffer for the wide-char title must be */  length = uv_utf8_to_utf16(title, NULL, 0);  if (!length) {    err = GetLastError();    goto done;  }  /* Convert to wide-char string */  title_w = (WCHAR*)uv__malloc(sizeof(WCHAR) * length);  if (!title_w) {    uv_fatal_error(ERROR_OUTOFMEMORY, "uv__malloc");  }  length = uv_utf8_to_utf16(title, title_w, length);  if (!length) {    err = GetLastError();    goto done;  }  /* If the title must be truncated insert a /0 terminator there */  if (length > MAX_TITLE_LENGTH) {    title_w[MAX_TITLE_LENGTH - 1] = L'/0';  }  if (!SetConsoleTitleW(title_w)) {    err = GetLastError();    goto done;  }  EnterCriticalSection(&process_title_lock);  uv__free(process_title);  process_title = strdup(title);  LeaveCriticalSection(&process_title_lock);  err = 0;done:  uv__free(title_w);  return uv_translate_sys_error(err);}

int uv_thread_create(uv_thread_t *tid, void (*entry)(void *arg), void *arg) {  struct thread_ctx* ctx;  int err;  pthread_attr_t* attr;#if defined(__APPLE__)  pthread_attr_t attr_storage;  struct rlimit lim;#endif  ctx = uv__malloc(sizeof(*ctx));  if (ctx == NULL)    return UV_ENOMEM;  ctx->entry = entry;  ctx->arg = arg;  /* On OSX threads other than the main thread are created with a reduced stack   * size by default, adjust it to RLIMIT_STACK.   */#if defined(__APPLE__)  if (getrlimit(RLIMIT_STACK, &lim))    abort();  attr = &attr_storage;  if (pthread_attr_init(attr))    abort();  if (lim.rlim_cur != RLIM_INFINITY &&      lim.rlim_cur >= PTHREAD_STACK_MIN) {    if (pthread_attr_setstacksize(attr, lim.rlim_cur))      abort();  }#else  attr = NULL;#endif  err = pthread_create(tid, attr, uv__thread_start, ctx);  if (attr != NULL)    pthread_attr_destroy(attr);  if (err)    uv__free(ctx);  return -err;}

static void init_threads(void) {  unsigned int i;  const char* val;  nthreads = ARRAY_SIZE(default_threads);  val = getenv("UV_THREADPOOL_SIZE");  if (val != NULL)    nthreads = atoi(val);  if (nthreads == 0)    nthreads = 1;  if (nthreads > MAX_THREADPOOL_SIZE)    nthreads = MAX_THREADPOOL_SIZE;  threads = default_threads;  if (nthreads > ARRAY_SIZE(default_threads)) {    threads = uv__malloc(nthreads * sizeof(threads[0]));    if (threads == NULL) {      nthreads = ARRAY_SIZE(default_threads);      threads = default_threads;    }  }  if (uv_cond_init(&cond))    abort();  if (uv_mutex_init(&mutex))    abort();  QUEUE_INIT(&wq);  for (i = 0; i < nthreads; i++) {#ifndef _WIN32    struct data_t *data = malloc(sizeof(struct data_t));    memset(data, '/0', sizeof(struct data_t));    data->nr = i;    if (uv_thread_create(threads + i, worker, data))      abort();#else    if (uv_thread_create(threads + i, worker, NULL))      abort();#endif	}  initialized = 1;}

int uv_thread_create(uv_thread_t *tid, void (*entry)(void *arg), void *arg) {  struct thread_ctx* ctx;  int err;  ctx = uv__malloc(sizeof(*ctx));  if (ctx == NULL)    return UV_ENOMEM;  ctx->entry = entry;  ctx->arg = arg;  err = pthread_create(tid, NULL, uv__thread_start, ctx);  if (err)    uv__free(ctx);  return -err;}

static void init_threads(void) {  unsigned int i;  const char* val;  uv_sem_t sem;  nthreads = ARRAY_SIZE(default_threads);  val = getenv("UV_THREADPOOL_SIZE");  if (val != NULL)    nthreads = atoi(val);  if (nthreads == 0)    nthreads = 1;  if (nthreads > MAX_THREADPOOL_SIZE)    nthreads = MAX_THREADPOOL_SIZE;  threads = default_threads;  if (nthreads > ARRAY_SIZE(default_threads)) {    threads = (uv_thread_t*)uv__malloc(nthreads * sizeof(threads[0]));    if (threads == NULL) {      nthreads = ARRAY_SIZE(default_threads);      threads = default_threads;    }  }  if (uv_cond_init(&cond))    abort();  if (uv_mutex_init(&mutex))    abort();  QUEUE_INIT(&wq);  if (uv_sem_init(&sem, 0))    abort();  for (i = 0; i < nthreads; i++)    if (uv_thread_create(threads + i, worker, &sem))      abort();  for (i = 0; i < nthreads; i++)    uv_sem_wait(&sem);  uv_sem_destroy(&sem);}

static ssize_t uv__fs_realpath(uv_fs_t* req) {  ssize_t len;  char* buf;  len = uv__fs_pathmax_size(req->path);  buf = uv__malloc(len + 1);  if (buf == NULL) {    errno = ENOMEM;    return -1;  }  if (realpath(req->path, buf) == NULL) {    uv__free(buf);    return -1;  }  req->ptr = buf;  return 0;}

void pushRQ(requests_t *r, void *req, uint64_t io, uint64_t compute, uint64_t wallclock, uint64_t wait, ArrayList_t *e) {  if (r->cnt < 100) {    r->cnt++;    return;  }  item_t *item = (item_t *) uv__malloc(sizeof(item_t));  if (!item)    return;  item->req = req;  item->io = io;  item->compute = compute;  item->wallclock = wallclock;  item->wait = wait;  if (e != NULL) {    cloneArrayList(e, &item->events);  } else    initArrayList(&item->events);  item->next = NULL;  push_req_queue(r, item);}

static int uv__custom_sem_init(uv_sem_t* sem_, unsigned int value) {  int err;  uv_semaphore_t* sem;  sem = (uv_semaphore_t*)uv__malloc(sizeof(*sem));  if (sem == NULL)    return UV_ENOMEM;  if ((err = uv_mutex_init(&sem->mutex)) != 0) {    uv__free(sem);    return err;  }  if ((err = uv_cond_init(&sem->cond)) != 0) {    uv_mutex_destroy(&sem->mutex);    uv__free(sem);    return err;  }  sem->value = value;  *(uv_semaphore_t**)sem_ = sem;  return 0;}

static void init_once(void) {  unsigned int i;  const char* val;  nthreads = ARRAY_SIZE(default_threads);  val = getenv("UV_THREADPOOL_SIZE");  if (val != NULL)    nthreads = atoi(val);  if (nthreads == 0)    nthreads = 1;  if (nthreads > MAX_THREADPOOL_SIZE)    nthreads = MAX_THREADPOOL_SIZE;  threads = default_threads;  if (nthreads > ARRAY_SIZE(default_threads)) {    threads = uv__malloc(nthreads * sizeof(threads[0]));    if (threads == NULL) {      nthreads = ARRAY_SIZE(default_threads);      threads = default_threads;    }  }  if (uv_cond_init(&cond))    abort();  if (uv_mutex_init(&mutex))    abort();  QUEUE_INIT(&wq);  for (i = 0; i < nthreads; i++)    if (uv_thread_create(threads + i, worker, NULL))      abort();  initialized = 1;}