int uio_stat(uio_DirHandle *dir, const char *path, struct stat *statBuf) { uio_PDirHandle *pReadDir; uio_MountInfo *readMountInfo; char *name; int result; if (uio_getPhysicalAccess(dir, path, O_RDONLY, 0, &readMountInfo, &pReadDir, NULL, NULL, NULL, NULL, &name) == -1) { if (uio_statDir(dir, path, statBuf) == -1) { // errno is set return -1; } return 0; } if (pReadDir->pRoot->handler->stat == NULL) { uio_PDirHandle_unref(pReadDir); uio_free(name); errno = ENOSYS; return -1; } result = (pReadDir->pRoot->handler->stat)(pReadDir, name, statBuf); uio_PDirHandle_unref(pReadDir); uio_free(name); return result; }
static int listOneDir(DebugContext *debugContext, const char *arg) { uio_DirList *dirList; int i; const char *pattern; const char *cpath; char *buf = NULL; if (arg[0] == '\0') { cpath = arg; pattern = "*"; } else { pattern = strrchr(arg, '/'); if (pattern == NULL) { // No directory component in 'arg'. cpath = ""; pattern = arg; } else if (pattern[1] == '\0') { // 'arg' ends on / cpath = arg; pattern = "*"; } else { if (pattern == arg) { cpath = "/"; } else { buf = uio_malloc(pattern - arg + 1); memcpy(buf, arg, pattern - arg); buf[pattern - arg] = '\0'; cpath = buf; } pattern++; } } #ifdef HAVE_GLOB dirList = uio_getDirList(debugContext->cwd, cpath, pattern, match_MATCH_GLOB); #else if (pattern[0] == '*' && pattern[1] == '\0') { dirList = uio_getDirList(debugContext->cwd, cpath, "", match_MATCH_PREFIX); } else { dirList = uio_getDirList(debugContext->cwd, cpath, pattern, match_MATCH_LITERAL); } #endif if (dirList == NULL) { fprintf(debugContext->out, "Error in uio_getDirList(): %s.\n", strerror(errno)); if (buf != NULL) uio_free(buf); return 1; } for (i = 0; i < dirList->numNames; i++) fprintf(debugContext->out, "%s\n", dirList->names[i]); uio_DirList_free(dirList); if (buf != NULL) uio_free(buf); return 0; }
void uio_DirList_free(uio_DirList *dirList) { if (dirList->buffer) uio_free(dirList->buffer); if (dirList->names) uio_free((void *) dirList->names); uio_free(dirList); }
static inline void uio_StdioAccessHandle_delete(uio_StdioAccessHandle *handle) { if (handle->tempDir != NULL) uio_DirHandle_unref(handle->tempDir); if (handle->fileName != NULL) uio_free(handle->fileName); if (handle->tempRoot != NULL) uio_DirHandle_unref(handle->tempRoot); if (handle->tempDirName != NULL) uio_free(handle->tempDirName); uio_free(handle->stdioPath); uio_StdioAccessHandle_free(handle); }
void uio_debugInteractive(FILE *in, FILE *out, FILE *err) { char lineBuf[LINEBUFLEN]; size_t lineLen; int argc; char **argv; DebugContext debugContext; uio_bool interactive; memset(&debugContext, '\0', sizeof (DebugContext)); debugContext.exit = false; debugContext.in = in; debugContext.out = out; debugContext.err = err; debugContext.cwd = uio_openDir(repository, "/", 0); if (debugContext.cwd == NULL) { fprintf(err, "Fatal: Could not open working dir.\n"); abort(); } interactive = isatty(fileno(in)); do { if (interactive) fprintf(out, "> "); if (fgets(lineBuf, LINEBUFLEN, in) == NULL) { if (feof(in)) { // user pressed ^D break; } // error occured clearerr(in); continue; } lineLen = strlen(lineBuf); if (lineBuf[lineLen - 1] != '\n' && lineBuf[lineLen - 1] != '\r') { fprintf(err, "Too long command line.\n"); // TODO: read until EOL continue; } makeArgs(lineBuf, &argc, &argv); if (argc == 0) { uio_free(argv); continue; } debugCallCommand(&debugContext, argc, argv); uio_free(argv); } while (!debugContext.exit); if (interactive) fprintf(out, "\n"); uio_closeDir(debugContext.cwd); }
static inline void uio_GPFile_free(uio_GPFile *gPFile) { uio_free(gPFile); #ifdef uio_MEM_DEBUG uio_MemDebug_debugFree(uio_GPFile, (void *) gPFile); #endif }
static void uio_GPRoot_free(uio_GPRoot *gPRoot) { #ifdef uio_MEM_DEBUG uio_MemDebug_debugFree(uio_GPRoot, (void *) gPRoot); #endif uio_free(gPRoot); }
static inline void uio_GPDir_free(uio_GPDir *gPDir) { #ifdef uio_MEM_DEBUG uio_MemDebug_debugFree(uio_GPDir, (void *) gPDir); #endif uio_free(gPDir); }
static inline void uio_PFileHandle_free(uio_PFileHandle *pFileHandle) { #ifdef uio_MEM_DEBUG uio_MemDebug_debugFree(uio_PFileHandle, (void *) pFileHandle); #endif uio_free(pFileHandle); }
int uio_unRegisterFileSystem(uio_FileSystemID id) { uio_FileSystemInfo **ptr; uio_FileSystemInfo *temp; ptr = uio_getFileSystemInfoPtr(id); if (ptr == NULL) { errno = EINVAL; return -1; } if ((*ptr)->ref > 1) { errno = EBUSY; return -1; } if ((*ptr)->handler->unInit != NULL && ((*ptr)->handler->unInit() == -1)) { // errno is set return -1; } temp = *ptr; *ptr = (*ptr)->next; // uio_FileSystemHandler_unref(temp->handler); uio_free(temp->name); uio_FileSystemInfo_free(temp); return 0; }
static inline void uio_DirHandle_free(uio_DirHandle *dirHandle) { #ifdef uio_MEM_DEBUG uio_MemDebug_debugFree(uio_DirHandle, (void *) dirHandle); #endif uio_free(dirHandle); }
// Call if you want the memory used by the fileblock to be released, but // still want to use the fileblock later. If you don't need the fileblock, // call uio_closeFileBlock() instead. void uio_clearFileBlockBuffers(uio_FileBlock *block) { if (block->buffer != NULL) { uio_free(block->buffer); block->buffer = NULL; } }
int zfs_vn_rdwr(enum uio_rw rw, struct vnode *vp, caddr_t base, ssize_t len, offset_t offset, enum uio_seg seg, int ioflag, rlim64_t ulimit, cred_t *cr, ssize_t *residp) { uio_t *auio; int spacetype; int error=0; vfs_context_t vctx; spacetype = UIO_SEG_IS_USER_SPACE(seg) ? UIO_USERSPACE32 : UIO_SYSSPACE; vctx = vfs_context_create((vfs_context_t)0); auio = uio_create(1, 0, spacetype, rw); uio_reset(auio, offset, spacetype, rw); uio_addiov(auio, (uint64_t)(uintptr_t)base, len); if (rw == UIO_READ) { error = VNOP_READ(vp, auio, ioflag, vctx); } else { error = VNOP_WRITE(vp, auio, ioflag, vctx); } if (residp) { *residp = uio_resid(auio); } else { if (uio_resid(auio) && error == 0) error = EIO; } uio_free(auio); vfs_context_rele(vctx); return (error); }
static inline void uio_FileSystemInfo_free(uio_FileSystemInfo *fileSystemInfo) { #ifdef uio_MEM_DEBUG uio_MemDebug_debugFree(uio_FileSystemInfo, (void *) fileSystemInfo); #endif uio_free(fileSystemInfo); }
static inline void uio_Handle_free(uio_Handle *handle) { #ifdef uio_MEM_DEBUG uio_MemDebug_debugFree(uio_Handle, (void *) handle); #endif uio_free(handle); }
static inline void uio_MountInfo_free(uio_MountInfo *mountInfo) { #ifdef uio_MEM_DEBUG uio_MemDebug_debugFree(uio_MountInfo, (void *) mountInfo); #endif uio_free(mountInfo); }
static inline void uio_MountTreeItem_free(uio_MountTreeItem *mountTreeItem) { #ifdef uio_MEM_DEBUG uio_MemDebug_debugFree(uio_MountTreeItem, (void *) mountTreeItem); #endif uio_free(mountTreeItem); }
/* * Closes srcHandle if it's not -1. * Closes dstHandle if it's not -1. * Removes unlinkpath from the unlinkHandle dir if it's not NULL. * Frees 'buf' if not NULL. * Always returns -1. * errno is what was before the call. */ static int uio_copyError(uio_Handle *srcHandle, uio_Handle *dstHandle, uio_DirHandle *unlinkHandle, const char *unlinkPath, uio_uint8 *buf) { int savedErrno; savedErrno = errno; #ifdef DEBUG fprintf(stderr, "Error while copying: %s\n", strerror(errno)); #endif if (srcHandle != NULL) uio_close(srcHandle); if (dstHandle != NULL) uio_close(dstHandle); if (unlinkPath != NULL) uio_unlink(unlinkHandle, unlinkPath); if (buf != NULL) uio_free(buf); errno = savedErrno; return -1; }
static inline void uio_PathComp_free(uio_PathComp *pathComp) { #ifdef uio_MEM_DEBUG uio_MemDebug_debugFree(uio_PathComp, (void *) pathComp); #endif uio_free(pathComp); }
void match_freeRegex(match_RegexContext *context) { regfree(&context->native); if (context->errorString) uio_free(context->errorString); match_freeRegexContext(context); }
static inline void uio_MountHandle_free(uio_MountHandle *mountHandle) { #ifdef uio_MEM_DEBUG uio_MemDebug_debugFree(uio_MountHandle, (void *) mountHandle); #endif uio_free(mountHandle); }
static int vnop_strategy_9p(struct vnop_strategy_args *ap) { mount_t mp; struct buf *bp; node_9p *np; caddr_t addr; uio_t uio; int e, flags; TRACE(); bp = ap->a_bp; np = NTO9P(buf_vnode(bp)); flags = buf_flags(bp); uio = NULL; addr = NULL; mp = vnode_mount(buf_vnode(bp)); if (mp == NULL) return ENXIO; if ((e=buf_map(bp, &addr))) goto error; uio = uio_create(1, buf_blkno(bp) * vfs_statfs(mp)->f_bsize, UIO_SYSSPACE, ISSET(flags, B_READ)? UIO_READ: UIO_WRITE); if (uio == NULL) { e = ENOMEM; goto error; } uio_addiov(uio, CAST_USER_ADDR_T(addr), buf_count(bp)); if (ISSET(flags, B_READ)) { if((e=nread_9p(np, uio))) goto error; /* zero the rest of the page if we reached EOF */ if (uio_resid(uio) > 0) { bzero(addr+buf_count(bp)-uio_resid(uio), uio_resid(uio)); uio_update(uio, uio_resid(uio)); } } else { if ((e=nwrite_9p(np, uio))) goto error; } buf_setresid(bp, uio_resid(uio)); error: if (uio) uio_free(uio); if (addr) buf_unmap(bp); buf_seterror(bp, e); buf_biodone(bp); return e; }
void uio_PathComp_delete(uio_PathComp *pathComp) { uio_PathComp *next; while (pathComp != NULL) { next = pathComp->next; uio_free(pathComp->name); uio_PathComp_free(pathComp); pathComp = next; } }
UIO_API uio_object_destroy(uio_object_t obj) { assert(obj); struct UioObject* Obj = uio_Object_of(obj); assert(Obj->ref_count == 0); if (Obj->name) { uio_free(Obj->name); Obj->name = 0; } if (Obj->parent) { uio_object_drop(Obj->parent); Obj->parent = 0; } if (Obj->priv_size) { uio_free(Obj->priv_data); Obj->priv_data = 0; Obj->Priv_size = 0; } uio_free(Obj); return 0; }
void getfinderinfo(znode_t *zp, cred_t *cr, finderinfo_t *fip) { vnode_t *xdvp = NULLVP; vnode_t *xvp = NULLVP; struct uio *auio = NULL; struct componentname cn; int error; uint64_t xattr = 0; if (sa_lookup(zp->z_sa_hdl, SA_ZPL_XATTR(zp->z_zfsvfs), &xattr, sizeof(xattr)) || (xattr == 0)) { goto nodata; } auio = uio_create(1, 0, UIO_SYSSPACE, UIO_READ); if (auio == NULL) { goto nodata; } uio_addiov(auio, CAST_USER_ADDR_T(fip), sizeof (finderinfo_t)); /* * Grab the hidden attribute directory vnode. * * XXX - switch to embedded Finder Info when it becomes available */ if ((error = zfs_get_xattrdir(zp, &xdvp, cr, 0))) { goto out; } bzero(&cn, sizeof (cn)); cn.cn_nameiop = LOOKUP; cn.cn_flags = ISLASTCN; cn.cn_nameptr = XATTR_FINDERINFO_NAME; cn.cn_namelen = strlen(cn.cn_nameptr); if ((error = zfs_dirlook(VTOZ(xdvp), cn.cn_nameptr, &xvp, 0, NULL, &cn))) { goto out; } error = dmu_read_uio(zp->z_zfsvfs->z_os, VTOZ(xvp)->z_id, auio, sizeof (finderinfo_t)); out: if (auio) uio_free(auio); if (xvp) vnode_put(xvp); if (xdvp) vnode_put(xdvp); if (error == 0) return; nodata: bzero(fip, sizeof (finderinfo_t)); }
/* Generic read interface */ int afs_osi_Read(struct osi_file *afile, int offset, void *aptr, afs_int32 asize) { afs_ucred_t *oldCred; afs_size_t resid; afs_int32 code; #ifdef AFS_DARWIN80_ENV uio_t uio; #endif AFS_STATCNT(osi_Read); /** * If the osi_file passed in is NULL, panic only if AFS is not shutting * down. No point in crashing when we are already shutting down */ if (!afile) { if (afs_shuttingdown == AFS_RUNNING) osi_Panic("osi_Read called with null param"); else return -EIO; } if (offset != -1) afile->offset = offset; AFS_GUNLOCK(); #ifdef AFS_DARWIN80_ENV uio=uio_create(1, afile->offset, AFS_UIOSYS, UIO_READ); uio_addiov(uio, CAST_USER_ADDR_T(aptr), asize); code = VNOP_READ(afile->vnode, uio, IO_UNIT, afs_osi_ctxtp); resid = AFS_UIO_RESID(uio); uio_free(uio); #else code = gop_rdwr(UIO_READ, afile->vnode, (caddr_t) aptr, asize, afile->offset, AFS_UIOSYS, IO_UNIT, &afs_osi_cred, &resid); #endif AFS_GLOCK(); if (code == 0) { code = asize - resid; afile->offset += code; osi_DisableAtimes(afile->vnode); } else { afs_Trace2(afs_iclSetp, CM_TRACE_READFAILED, ICL_TYPE_INT32, resid, ICL_TYPE_INT32, code); if (code > 0) { code *= -1; } } return code; }
int uio_mkdir(uio_DirHandle *dir, const char *path, mode_t mode) { uio_PDirHandle *pReadDir, *pWriteDir; uio_MountInfo *readMountInfo, *writeMountInfo; char *name; uio_PDirHandle *newDirHandle; if (uio_getPhysicalAccess(dir, path, O_WRONLY | O_CREAT | O_EXCL, 0, &readMountInfo, &pReadDir, NULL, &writeMountInfo, &pWriteDir, NULL, &name) == -1) { // errno is set if (errno == EISDIR) errno = EEXIST; return -1; } uio_PDirHandle_unref(pReadDir); if (pWriteDir->pRoot->handler->mkdir == NULL) { uio_free(name); uio_PDirHandle_unref(pWriteDir); errno = ENOSYS; return -1; } newDirHandle = (pWriteDir->pRoot->handler->mkdir)(pWriteDir, name, mode); if (newDirHandle == NULL) { int savedErrno = errno; uio_free(name); uio_PDirHandle_unref(pWriteDir); errno = savedErrno; return -1; } uio_PDirHandle_unref(pWriteDir); uio_PDirHandle_unref(newDirHandle); uio_free(name); return 0; }
int uio_closeFileBlock(uio_FileBlock *block) { if (block->flags & uio_FB_USE_MMAP) { #if 0 if (block->buffer != NULL) uio_mmunmap(block->buffer); #endif } else { if (block->buffer != NULL) uio_free(block->buffer); } uio_Handle_unref(block->handle); uio_FileBlock_free(block); return 0; }
const char * match_errorStringRegex(match_RegexContext *context, int errorCode) { size_t errorStringLength; if (context->errorString != NULL) uio_free(context->errorString); errorStringLength = regerror(context->errorCode, &context->native, NULL, 0); context->errorString = uio_malloc(errorStringLength); regerror(context->errorCode, &context->native, context->errorString, errorStringLength); (void) errorCode; return context->errorString; }
/* Generic write interface */ int afs_osi_Write(struct osi_file *afile, afs_int32 offset, void *aptr, afs_int32 asize) { afs_ucred_t *oldCred; afs_size_t resid; afs_int32 code; #ifdef AFS_DARWIN80_ENV uio_t uio; #endif AFS_STATCNT(osi_Write); if (!afile) osi_Panic("afs_osi_Write called with null param"); if (offset != -1) afile->offset = offset; { AFS_GUNLOCK(); #ifdef AFS_DARWIN80_ENV uio=uio_create(1, afile->offset, AFS_UIOSYS, UIO_WRITE); uio_addiov(uio, CAST_USER_ADDR_T(aptr), asize); code = VNOP_WRITE(afile->vnode, uio, IO_UNIT, afs_osi_ctxtp); resid = AFS_UIO_RESID(uio); uio_free(uio); #else code = gop_rdwr(UIO_WRITE, afile->vnode, (caddr_t) aptr, asize, afile->offset, AFS_UIOSYS, IO_UNIT, &afs_osi_cred, &resid); #endif AFS_GLOCK(); } if (code == 0) { code = asize - resid; afile->offset += code; } else { if (code > 0) { code *= -1; } } if (afile->proc) { (*afile->proc) (afile, code); } return code; }