static bool
record_exec_dir (struct exec_val *execp)
{
if (!execp->state.todo)
{
/* working directory not already known, so must be a *dir variant,
and this must be the first arg we added. However, this may
be -execdir foo {} \; (i.e. not multiple). */
assert (!execp->state.todo);
/* Record the WD. If we're using -L or fts chooses to do so for
any other reason, state.cwd_dir_fd may in fact not be the
directory containing the target file. When this happens,
rel_path will contain directory components (since it is the
path from state.cwd_dir_fd to the target file).
We deal with this by extracting any directory part and using
that to adjust what goes into execp->wd_for_exec.
*/
if (strchr (state.rel_pathname, '/'))
{
char *dir = mdir_name (state.rel_pathname);
bool result = initialise_wd_for_exec (execp, state.cwd_dir_fd, dir);
free (dir);
return result;
}
else
{
return initialise_wd_for_exec (execp, state.cwd_dir_fd, ".");
}
}
return true;
}
/*
* Create pool of type VIR_STORAGE_POOL_DIR with
* path to the VM, if it's not exists.
*/
static virStoragePoolObjPtr
parallelsPoolAddByDomain(virConnectPtr conn, virDomainObjPtr dom)
{
parallelsConnPtr privconn = conn->privateData;
parallelsDomObjPtr pdom = dom->privateData;
virStoragePoolObjListPtr pools = &privconn->pools;
char *poolPath;
virStoragePoolObjPtr pool = NULL;
size_t j;
poolPath = mdir_name(pdom->home);
if (!poolPath) {
virReportOOMError();
return NULL;
}
for (j = 0; j < pools->count; j++) {
if (STREQ(poolPath, pools->objs[j]->def->target.path)) {
pool = pools->objs[j];
break;
}
}
if (!pool)
pool = parallelsPoolCreateByPath(conn, poolPath);
VIR_FREE(poolPath);
return pool;
}
char *
dir_name (char const *file)
{
char *result = mdir_name (file);
if (!result)
xalloc_die ();
return result;
}
/*
* virtTPMGetTPMStorageDir:
*
* @storagepath: directory for swtpm's persistent state
*
* Derive the 'TPMStorageDir' from the storagepath by searching
* for the last '/'.
*/
static char *
qemuTPMGetTPMStorageDir(const char *storagepath)
{
char *ret = mdir_name(storagepath);
if (!ret)
virReportOOMError();
return ret;
}
int
vmwareExtractVersion(struct vmware_driver *driver)
{
int ret = -1;
virCommandPtr cmd = NULL;
char * outbuf = NULL;
char *bin = NULL;
char *vmwarePath = NULL;
if ((vmwarePath = mdir_name(driver->vmrun)) == NULL)
goto cleanup;
switch (driver->type) {
case VMWARE_DRIVER_PLAYER:
if (virAsprintf(&bin, "%s/%s", vmwarePath, "vmplayer") < 0)
goto cleanup;
break;
case VMWARE_DRIVER_WORKSTATION:
if (virAsprintf(&bin, "%s/%s", vmwarePath, "vmware") < 0)
goto cleanup;
break;
case VMWARE_DRIVER_FUSION:
if (virAsprintf(&bin, "%s/%s", vmwarePath, "vmware-vmx") < 0)
goto cleanup;
break;
default:
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("invalid driver type for version detection"));
goto cleanup;
}
cmd = virCommandNewArgList(bin, "-v", NULL);
virCommandSetOutputBuffer(cmd, &outbuf);
virCommandSetErrorBuffer(cmd, &outbuf);
if (virCommandRun(cmd, NULL) < 0)
goto cleanup;
if (vmwareParseVersionStr(driver->type, outbuf, &driver->version) < 0)
goto cleanup;
ret = 0;
cleanup:
virCommandFree(cmd);
VIR_FREE(outbuf);
VIR_FREE(bin);
VIR_FREE(vmwarePath);
return ret;
}
int
vmwareExtractPid(const char * vmxPath)
{
char *vmxDir = NULL;
char *logFilePath = NULL;
FILE *logFile = NULL;
char line[1024];
char *tmp = NULL;
int pid_value = -1;
if ((vmxDir = mdir_name(vmxPath)) == NULL)
goto cleanup;
if (virAsprintf(&logFilePath, "%s/vmware.log",
vmxDir) < 0) {
virReportOOMError();
goto cleanup;
}
if ((logFile = fopen(logFilePath, "r")) == NULL)
goto cleanup;
if (!fgets(line, sizeof(line), logFile)) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("unable to read vmware log file"));
goto cleanup;
}
if ((tmp = strstr(line, " pid=")) == NULL) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("cannot find pid in vmware log file"));
goto cleanup;
}
tmp += strlen(" pid=");
/* Although 64-bit windows allows 64-bit pid_t, a domain id has to be
* 32 bits. For now, we just reject pid values that overflow int. */
if (virStrToLong_i(tmp, &tmp, 10, &pid_value) < 0 || *tmp != ' ') {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("cannot parse pid in vmware log file"));
goto cleanup;
}
cleanup:
VIR_FREE(vmxDir);
VIR_FREE(logFilePath);
VIR_FORCE_FCLOSE(logFile);
return pid_value;
}
static int
link_immediate (char const *file1, char const *file2)
{
char *target = areadlink (file1);
if (target)
{
/* A symlink cannot be modified in-place. Therefore, creating
an identical symlink behaves like a hard link to a symlink,
except for incorrect st_ino and st_nlink. However, we must
be careful of EXDEV. */
struct stat st1;
struct stat st2;
char *dir = mdir_name (file2);
if (!dir)
{
free (target);
errno = ENOMEM;
return -1;
}
if (lstat (file1, &st1) == 0 && stat (dir, &st2) == 0)
{
if (st1.st_dev == st2.st_dev)
{
int result = symlink (target, file2);
int saved_errno = errno;
free (target);
free (dir);
errno = saved_errno;
return result;
}
free (target);
free (dir);
errno = EXDEV;
return -1;
}
free (target);
free (dir);
}
if (errno == ENOMEM)
return -1;
return link (file1, file2);
}
static virStorageSourcePtr
testStorageFileGetMetadata(const char *path,
int format,
uid_t uid, gid_t gid,
bool allow_probe)
{
virStorageSourcePtr ret = NULL;
if (VIR_ALLOC(ret) < 0)
return NULL;
ret->type = VIR_STORAGE_TYPE_FILE;
ret->format = format;
if (VIR_STRDUP(ret->relPath, path) < 0)
goto error;
if (!(ret->relDir = mdir_name(path))) {
virReportOOMError();
goto error;
}
if (!(ret->path = canonicalize_file_name(path))) {
virReportError(VIR_ERR_INTERNAL_ERROR, "failed to resolve '%s'", path);
goto error;
}
if (virStorageFileGetMetadata(ret, uid, gid, allow_probe) < 0)
goto error;
return ret;
error:
virStorageSourceFree(ret);
return NULL;
}
static int virLockManagerSanlockSetupLockspace(void)
{
int fd = -1;
struct stat st;
int rv;
struct sanlk_lockspace ls;
char *path = NULL;
char *dir = NULL;
int retries = LOCKSPACE_RETRIES;
if (virAsprintf(&path, "%s/%s",
driver->autoDiskLeasePath,
VIR_LOCK_MANAGER_SANLOCK_AUTO_DISK_LOCKSPACE) < 0) {
virReportOOMError();
goto error;
}
memcpy(ls.name, VIR_LOCK_MANAGER_SANLOCK_AUTO_DISK_LOCKSPACE, SANLK_NAME_LEN);
ls.host_id = 0; /* Doesn't matter for initialization */
ls.flags = 0;
if (!virStrcpy(ls.host_id_disk.path, path, SANLK_PATH_LEN)) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("Lockspace path '%s' exceeded %d characters"),
path, SANLK_PATH_LEN);
goto error;
}
ls.host_id_disk.offset = 0;
/* Stage 1: Ensure the lockspace file exists on disk, has
* space allocated for it and is initialized with lease
*/
if (stat(path, &st) < 0) {
int perms = 0600;
VIR_DEBUG("Lockspace %s does not yet exist", path);
if (!(dir = mdir_name(path))) {
virReportOOMError();
goto error;
}
if (stat(dir, &st) < 0 || !S_ISDIR(st.st_mode)) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("Unable to create lockspace %s: parent directory"
" does not exist or is not a directory"),
path);
goto error;
}
if (driver->group != -1)
perms |= 0060;
if ((fd = open(path, O_WRONLY|O_CREAT|O_EXCL, perms)) < 0) {
if (errno != EEXIST) {
virReportSystemError(errno,
_("Unable to create lockspace %s"),
path);
goto error;
}
VIR_DEBUG("Someone else just created lockspace %s", path);
} else {
/* chown() the path to make sure sanlock can access it */
if ((driver->user != -1 || driver->group != -1) &&
(fchown(fd, driver->user, driver->group) < 0)) {
virReportSystemError(errno,
_("cannot chown '%s' to (%u, %u)"),
path,
(unsigned int) driver->user,
(unsigned int) driver->group);
goto error_unlink;
}
if ((rv = sanlock_align(&ls.host_id_disk)) < 0) {
if (rv <= -200)
virReportError(VIR_ERR_INTERNAL_ERROR,
_("Unable to query sector size %s: error %d"),
path, rv);
else
virReportSystemError(-rv,
_("Unable to query sector size %s"),
path);
goto error_unlink;
}
/*
* Pre allocate enough data for 1 block of leases at preferred alignment
*/
if (safezero(fd, 0, rv) < 0) {
virReportSystemError(errno,
_("Unable to allocate lockspace %s"),
path);
goto error_unlink;
}
if (VIR_CLOSE(fd) < 0) {
virReportSystemError(errno,
_("Unable to save lockspace %s"),
path);
goto error_unlink;
}
if ((rv = sanlock_init(&ls, NULL, 0, 0)) < 0) {
if (rv <= -200)
virReportError(VIR_ERR_INTERNAL_ERROR,
_("Unable to initialize lockspace %s: error %d"),
path, rv);
else
virReportSystemError(-rv,
_("Unable to initialize lockspace %s"),
path);
goto error_unlink;
}
VIR_DEBUG("Lockspace %s has been initialized", path);
}
} else if (S_ISREG(st.st_mode)) {
/* okay, the lease file exists. Check the permissions */
if (((driver->user != -1 && driver->user != st.st_uid) ||
(driver->group != -1 && driver->group != st.st_gid)) &&
(chown(path, driver->user, driver->group) < 0)) {
virReportSystemError(errno,
_("cannot chown '%s' to (%u, %u)"),
path,
(unsigned int) driver->user,
(unsigned int) driver->group);
goto error;
}
if ((driver->group != -1 && (st.st_mode & 0060) != 0060) &&
chmod(path, 0660) < 0) {
virReportSystemError(errno,
_("cannot chmod '%s' to 0660"),
path);
goto error;
}
}
ls.host_id = driver->hostID;
/* Stage 2: Try to register the lockspace with the daemon. If the lockspace
* is already registered, we should get EEXIST back in which case we can
* just carry on with life. If EINPROGRESS is returned, we have two options:
* either call a sanlock API that blocks us until lockspace changes state,
* or we can fallback to polling.
*/
retry:
if ((rv = sanlock_add_lockspace(&ls, 0)) < 0) {
if (-rv == EINPROGRESS && --retries) {
#ifdef HAVE_SANLOCK_INQ_LOCKSPACE
/* we have this function which blocks until lockspace change the
* state. It returns 0 if lockspace has been added, -ENOENT if it
* hasn't. */
VIR_DEBUG("Inquiring lockspace");
if (sanlock_inq_lockspace(&ls, SANLK_INQ_WAIT) < 0)
VIR_DEBUG("Unable to inquire lockspace");
#else
/* fall back to polling */
VIR_DEBUG("Sleeping for %dms", LOCKSPACE_SLEEP);
usleep(LOCKSPACE_SLEEP * 1000);
#endif
VIR_DEBUG("Retrying to add lockspace (left %d)", retries);
goto retry;
}
if (-rv != EEXIST) {
if (rv <= -200)
virReportError(VIR_ERR_INTERNAL_ERROR,
_("Unable to add lockspace %s: error %d"),
path, rv);
else
virReportSystemError(-rv,
_("Unable to add lockspace %s"),
path);
goto error;
} else {
VIR_DEBUG("Lockspace %s is already registered", path);
}
} else {
VIR_DEBUG("Lockspace %s has been registered", path);
}
VIR_FREE(path);
VIR_FREE(dir);
return 0;
error_unlink:
unlink(path);
error:
VIR_FORCE_CLOSE(fd);
VIR_FREE(path);
VIR_FREE(dir);
return -1;
}
static int
linkat_follow (int fd1, char const *file1, int fd2, char const *file2)
{
char *name = (char *) file1;
char *target;
int result;
int i = MAXSYMLINKS;
/* There is no realpathat. */
while (i-- && (target = areadlinkat (fd1, name)))
{
if (IS_ABSOLUTE_FILE_NAME (target))
{
if (name != file1)
free (name);
name = target;
}
else
{
char *dir = mdir_name (name);
if (name != file1)
free (name);
if (!dir)
{
free (target);
errno = ENOMEM;
return -1;
}
name = mfile_name_concat (dir, target, NULL);
free (dir);
free (target);
if (!name)
{
errno = ENOMEM;
return -1;
}
}
}
if (i < 0)
{
target = NULL;
errno = ELOOP;
}
if (!target && errno != EINVAL)
{
if (name != file1)
{
int saved_errno = errno;
free (name);
errno = saved_errno;
}
return -1;
}
result = linkat (fd1, name, fd2, file2, 0);
if (name != file1)
{
int saved_errno = errno;
free (name);
errno = saved_errno;
}
return result;
}
static int
link_follow (char const *file1, char const *file2)
{
char *name = (char *) file1;
char *target;
int result;
int i = MAXSYMLINKS;
/* Using realpath or canonicalize_file_name is too heavy-handed: we
don't need an absolute name, and we don't need to resolve
intermediate symlinks, just the basename of each iteration. */
while (i-- && (target = areadlink (name)))
{
if (IS_ABSOLUTE_FILE_NAME (target))
{
if (name != file1)
free (name);
name = target;
}
else
{
char *dir = mdir_name (name);
if (name != file1)
free (name);
if (!dir)
{
free (target);
errno = ENOMEM;
return -1;
}
name = mfile_name_concat (dir, target, NULL);
free (dir);
free (target);
if (!name)
{
errno = ENOMEM;
return -1;
}
}
}
if (i < 0)
{
target = NULL;
errno = ELOOP;
}
if (!target && errno != EINVAL)
{
if (name != file1)
{
int saved_errno = errno;
free (name);
errno = saved_errno;
}
return -1;
}
result = link (name, file2);
if (name != file1)
{
int saved_errno = errno;
free (name);
errno = saved_errno;
}
return result;
}
extern char *dir_name(const char *__T36622528); static void __zvm_this_file_init(void); static __attribute__((__constructor__)) void __zvm_file_constructor(void); char *dir_name( const char *file)
{ auto char *__T36771408; auto int __zvm_memchk_nesting_nr; auto void *__zvm_prev_stack_end; auto char *__T36741768 = 0xaaaaaaaaaaaaaaaa;
auto char *result;
# 33
__zvm_memchk_nesting_nr = (__zvm_memchk_push_function("dir_name", 0, "/home/release/apps/grep2.5.3/grep-2.9/lib/dirname.c", 32)); __zvm_memchk_add_stack_object("/home/release/apps/grep2.5.3/grep-2.9/lib/dirname.c", ((int)32), ((void *)((unsigned long)(&result))), ((unsigned long)8), ((unsigned long)1), ((const char *)((unsigned long)"result")), ((int)__zvm_memchk_nesting_nr)); __ZVM_DECL_LOCAL_MLS(); __zvm_mls_scope_in(__zvm_cc_var, 1, file, (__zvm_varinfo + 1U)); __ZVM_PUSH_FUNC_INIT((__zvm_funcinfo + 2U)); __zcov_update_counter(0); __ZVM_PUSH_FUNC((__zvm_funcinfo + 0U));
result = (((void *)(__zvm_mls_set_instrumented(__zvm_cc_var))) , ((char *)(__zvm_mls_ptr_init((mdir_name(file)))))); {
if ((!(result != ((char *)0)))) { __zcov_update_counter(1); __ZVM_PUSH_FUNC((__zvm_funcinfo + 1U));
xalloc_die(); } else { __zcov_update_counter(2); } } __zcov_update_counter(3); { ((void *)(__zvm_mls_set_instrumented(__zvm_cc_var))) , ((char *)(__zvm_mls_ptr_assignment((__zvm_varinfo + 2U), __zvm_cc_var, (&__T36741768), result, 0))); __zvm_mls_scope_out("/home/release/apps/grep2.5.3/grep-2.9/lib/dirname.c", 35, __zvm_cc_var, __zvm_mls_return_unused, 1, 4, 0, __T36771408, "Unknown", __T36741768, "Unknown", result, "result", file, "file"); __ZVM_POP_FUNC_END(); { __T36771408 = __T36741768; __zvm_memchk_pop_function("dir_name", __zvm_memchk_nesting_nr); return __T36771408; } }
} static void __zvm_this_file_init(void) { } static __attribute__((__constructor__)) void __zvm_file_constructor(void) { __zvm_file_ctr(((void *)__zvm_dirnames)); __zvm_this_file_init(); __zvm_local_init_inline(); __zvm_dr_varinfo_init(((void *)__zvm_varinfo), zvm_file_option); __zvm_update_align(4U); }