void posix2fsal_attributes(const struct stat *buffstat, struct attrlist *fsalattr) { FSAL_CLEAR_MASK(fsalattr->mask); /* Fills the output struct */ fsalattr->type = posix2fsal_type(buffstat->st_mode); FSAL_SET_MASK(fsalattr->mask, ATTR_TYPE); fsalattr->filesize = buffstat->st_size; FSAL_SET_MASK(fsalattr->mask, ATTR_SIZE); fsalattr->fsid = posix2fsal_fsid(buffstat->st_dev); FSAL_SET_MASK(fsalattr->mask, ATTR_FSID); fsalattr->fileid = buffstat->st_ino; FSAL_SET_MASK(fsalattr->mask, ATTR_FILEID); fsalattr->mode = unix2fsal_mode(buffstat->st_mode); FSAL_SET_MASK(fsalattr->mask, ATTR_MODE); fsalattr->numlinks = buffstat->st_nlink; FSAL_SET_MASK(fsalattr->mask, ATTR_NUMLINKS); fsalattr->owner = buffstat->st_uid; FSAL_SET_MASK(fsalattr->mask, ATTR_OWNER); fsalattr->group = buffstat->st_gid; FSAL_SET_MASK(fsalattr->mask, ATTR_GROUP); /* Use full timer resolution */ #ifdef LINUX fsalattr->atime = buffstat->st_atim; fsalattr->ctime = buffstat->st_ctim; fsalattr->mtime = buffstat->st_mtim; fsalattr->chgtime = (gsh_time_cmp(&buffstat->st_mtim, &buffstat->st_ctim) > 0) ? fsalattr->mtime : fsalattr->ctime; #elif FREEBSD fsalattr->atime = buffstat->st_atimespec; fsalattr->ctime = buffstat->st_ctimespec; fsalattr->mtime = buffstat->st_mtimespec; fsalattr->chgtime = (gsh_time_cmp(&buffstat->st_mtimespec, &buffstat->st_ctimespec) > 0) ? fsalattr->mtime : fsalattr->ctime; #endif FSAL_SET_MASK(fsalattr->mask, ATTR_ATIME); FSAL_SET_MASK(fsalattr->mask, ATTR_CTIME); FSAL_SET_MASK(fsalattr->mask, ATTR_MTIME); fsalattr->change = timespec_to_nsecs(&fsalattr->chgtime); FSAL_SET_MASK(fsalattr->mask, ATTR_CHGTIME); fsalattr->spaceused = buffstat->st_blocks * S_BLKSIZE; FSAL_SET_MASK(fsalattr->mask, ATTR_SPACEUSED); fsalattr->rawdev = posix2fsal_devt(buffstat->st_rdev); FSAL_SET_MASK(fsalattr->mask, ATTR_RAWDEV); }
fsal_status_t posix2fsal_attributes(const struct stat *buffstat, struct attrlist *fsalattr) { FSAL_CLEAR_MASK(fsalattr->mask); /* sanity checks */ if(!buffstat || !fsalattr) return fsalstat(ERR_FSAL_FAULT, 0); FSAL_CLEAR_MASK(fsalattr->mask); /* Fills the output struct */ fsalattr->type = posix2fsal_type(buffstat->st_mode); FSAL_SET_MASK(fsalattr->mask, ATTR_TYPE); fsalattr->filesize = buffstat->st_size; FSAL_SET_MASK(fsalattr->mask, ATTR_SIZE); fsalattr->fsid = posix2fsal_fsid(buffstat->st_dev); FSAL_SET_MASK(fsalattr->mask, ATTR_FSID); fsalattr->fileid = buffstat->st_ino; FSAL_SET_MASK(fsalattr->mask, ATTR_FILEID); fsalattr->mode = unix2fsal_mode(buffstat->st_mode); FSAL_SET_MASK(fsalattr->mask, ATTR_MODE); fsalattr->numlinks = buffstat->st_nlink; FSAL_SET_MASK(fsalattr->mask, ATTR_NUMLINKS); fsalattr->owner = buffstat->st_uid; FSAL_SET_MASK(fsalattr->mask, ATTR_OWNER); fsalattr->group = buffstat->st_gid; FSAL_SET_MASK(fsalattr->mask, ATTR_GROUP); fsalattr->atime = posix2fsal_time(buffstat->st_atime, 0); FSAL_SET_MASK(fsalattr->mask, ATTR_ATIME); fsalattr->ctime = posix2fsal_time(buffstat->st_ctime, 0); FSAL_SET_MASK(fsalattr->mask, ATTR_CTIME); fsalattr->mtime = posix2fsal_time(buffstat->st_mtime, 0); FSAL_SET_MASK(fsalattr->mask, ATTR_MTIME); fsalattr->chgtime = posix2fsal_time(MAX_2(buffstat->st_mtime, buffstat->st_ctime), 0); fsalattr->change = fsalattr->chgtime.tv_sec; FSAL_SET_MASK(fsalattr->mask, ATTR_CHGTIME); fsalattr->spaceused = buffstat->st_blocks * S_BLKSIZE; FSAL_SET_MASK(fsalattr->mask, ATTR_SPACEUSED); fsalattr->rawdev = posix2fsal_devt(buffstat->st_rdev); FSAL_SET_MASK(fsalattr->mask, ATTR_RAWDEV); return fsalstat(ERR_FSAL_NO_ERROR, 0); }
/** * @brief convert 'struct stat' to 'fsal_posixdb_fileinfo_t' * * @param buffstat * @param info * * @return */ fsal_status_t fsal_internal_posix2posixdb_fileinfo(struct stat *buffstat, fsal_posixdb_fileinfo_t * info) { /* sanity check */ if(!info || !buffstat) ReturnCode(ERR_FSAL_FAULT, 0); memset(info, 0, sizeof(fsal_posixdb_fileinfo_t)); info->devid = buffstat->st_dev; info->inode = buffstat->st_ino; info->nlink = (int)buffstat->st_nlink; info->ctime = buffstat->st_ctime; info->ftype = posix2fsal_type(buffstat->st_mode); ReturnCode(ERR_FSAL_NO_ERROR, 0); }
void stat2fsal_attributes(const struct stat *buffstat, struct attrlist *fsalattr) { /* Indicate which atrributes we have set without affecting the * other bits in the mask. */ fsalattr->valid_mask |= ATTRS_POSIX; fsalattr->supported = op_ctx->fsal_export->exp_ops.fs_supported_attrs( op_ctx->fsal_export); /* Fills the output struct */ fsalattr->type = posix2fsal_type(buffstat->st_mode); fsalattr->filesize = buffstat->st_size; fsalattr->fsid = posix2fsal_fsid(buffstat->st_dev); fsalattr->fileid = buffstat->st_ino; fsalattr->mode = unix2fsal_mode(buffstat->st_mode); fsalattr->numlinks = buffstat->st_nlink; fsalattr->owner = buffstat->st_uid; fsalattr->group = buffstat->st_gid; /** @todo: gfapi currently only fills in the legacy time_t fields * when it supports the timespec fields calls to this * function should be replaced with calls to * posix2fsal_attributes rather than changing this code. */ fsalattr->atime = posix2fsal_time(buffstat->st_atime, 0); fsalattr->ctime = posix2fsal_time(buffstat->st_ctime, 0); fsalattr->mtime = posix2fsal_time(buffstat->st_mtime, 0); fsalattr->chgtime = posix2fsal_time(MAX(buffstat->st_mtime, buffstat->st_ctime), 0); fsalattr->change = fsalattr->chgtime.tv_sec; fsalattr->spaceused = buffstat->st_blocks * S_BLKSIZE; fsalattr->rawdev = posix2fsal_devt(buffstat->st_rdev); }
fsal_status_t posix2fsal_attributes(struct stat * p_buffstat, fsal_attrib_list_t * p_fsalattr_out) { fsal_attrib_mask_t supp_attr, unsupp_attr; /* sanity checks */ if(!p_buffstat || !p_fsalattr_out) ReturnCode(ERR_FSAL_FAULT, 0); /* check that asked attributes are supported */ supp_attr = global_fs_info.supported_attrs; unsupp_attr = (p_fsalattr_out->asked_attributes) & (~supp_attr); if(unsupp_attr) { LogFullDebug(COMPONENT_FSAL, "Unsupported attributes: %#llX", unsupp_attr); ReturnCode(ERR_FSAL_ATTRNOTSUPP, 0); } /* Initialize ACL regardless of whether ACL was asked or not. * This is needed to make sure ACL attribute is initialized. */ p_fsalattr_out->acl = NULL; /* Fills the output struct */ if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_SUPPATTR)) { p_fsalattr_out->supported_attributes = supp_attr; } if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_TYPE)) { p_fsalattr_out->type = posix2fsal_type(p_buffstat->st_mode); } if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_SIZE)) { p_fsalattr_out->filesize = p_buffstat->st_size; } if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_FSID)) { p_fsalattr_out->fsid = posix2fsal_fsid(p_buffstat->st_dev); } if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_ACL)) { p_fsalattr_out->acl = NULL; } if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_FILEID)) { p_fsalattr_out->fileid = (fsal_u64_t) (p_buffstat->st_ino); } if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_MODE)) { p_fsalattr_out->mode = unix2fsal_mode(p_buffstat->st_mode); } if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_NUMLINKS)) { p_fsalattr_out->numlinks = p_buffstat->st_nlink; } if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_OWNER)) { p_fsalattr_out->owner = p_buffstat->st_uid; } if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_GROUP)) { p_fsalattr_out->group = p_buffstat->st_gid; } if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_ATIME)) { p_fsalattr_out->atime = posix2fsal_time(p_buffstat->st_atime); } if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_CTIME)) { p_fsalattr_out->ctime = posix2fsal_time(p_buffstat->st_ctime); } if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_MTIME)) { p_fsalattr_out->mtime = posix2fsal_time(p_buffstat->st_mtime); } if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_CHGTIME)) { p_fsalattr_out->chgtime = posix2fsal_time(MAX_2(p_buffstat->st_mtime, p_buffstat->st_ctime)); p_fsalattr_out->change = (uint64_t) p_fsalattr_out->chgtime.seconds ; } if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_SPACEUSED)) { p_fsalattr_out->spaceused = p_buffstat->st_blocks * S_BLKSIZE; } if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_RAWDEV)) { p_fsalattr_out->rawdev = posix2fsal_devt(p_buffstat->st_rdev); /* XXX: convert ? */ } /* mounted_on_fileid : if ( FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_MOUNTFILEID )){ p_fsalattr_out->mounted_on_fileid = hpss2fsal_64( p_hpss_attr_in->FilesetRootId ); } */ /* everything has been copied ! */ ReturnCode(ERR_FSAL_NO_ERROR, 0); }
/* Same function as posixstat64_2_fsal_attributes. When NFS4 ACL support * is enabled, this will replace posixstat64_2_fsal_attributes. */ fsal_status_t gpfsfsal_xstat_2_fsal_attributes(gpfsfsal_xstat_t *p_buffxstat, struct attrlist *p_fsalattr_out, bool use_acl) { struct stat *p_buffstat; /* sanity checks */ if (!p_buffxstat || !p_fsalattr_out) return fsalstat(ERR_FSAL_FAULT, 0); p_buffstat = &p_buffxstat->buffstat; LogDebug(COMPONENT_FSAL, "inode %ld", p_buffstat->st_ino); /* Fills the output struct */ if (FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_TYPE)) { p_fsalattr_out->type = posix2fsal_type(p_buffstat->st_mode); LogFullDebug(COMPONENT_FSAL, "type = 0x%x", p_fsalattr_out->type); } if (FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_SIZE)) { p_fsalattr_out->filesize = p_buffstat->st_size; LogFullDebug(COMPONENT_FSAL, "filesize = %llu", (unsigned long long)p_fsalattr_out->filesize); } if (FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_FSID)) { p_fsalattr_out->fsid = p_buffxstat->fsal_fsid; LogFullDebug(COMPONENT_FSAL, "fsid=0x%016"PRIx64".0x%016"PRIx64, p_fsalattr_out->fsid.major, p_fsalattr_out->fsid.minor); } if (FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_ACL)) { p_fsalattr_out->acl = NULL; if (use_acl && p_buffxstat->attr_valid & XATTR_ACL) { /* ACL is valid, so try to convert fsal acl. */ gpfs_acl_2_fsal_acl(p_fsalattr_out, (gpfs_acl_t *) p_buffxstat-> buffacl); } LogFullDebug(COMPONENT_FSAL, "acl = %p", p_fsalattr_out->acl); } if (FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_FILEID)) { p_fsalattr_out->fileid = (uint64_t) (p_buffstat->st_ino); LogFullDebug(COMPONENT_FSAL, "fileid = %lu", p_fsalattr_out->fileid); } if (FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_MODE)) { p_fsalattr_out->mode = unix2fsal_mode(p_buffstat->st_mode); LogFullDebug(COMPONENT_FSAL, "mode = %"PRIu32, p_fsalattr_out->mode); } if (FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_NUMLINKS)) { p_fsalattr_out->numlinks = p_buffstat->st_nlink; LogFullDebug(COMPONENT_FSAL, "numlinks = %u", p_fsalattr_out->numlinks); } if (FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_OWNER)) { p_fsalattr_out->owner = p_buffstat->st_uid; LogFullDebug(COMPONENT_FSAL, "owner = %lu", p_fsalattr_out->owner); } if (FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_GROUP)) { p_fsalattr_out->group = p_buffstat->st_gid; LogFullDebug(COMPONENT_FSAL, "group = %lu", p_fsalattr_out->group); } if (FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_ATIME)) { p_fsalattr_out->atime = posix2fsal_time(p_buffstat->st_atime, p_buffstat->st_atim.tv_nsec); LogFullDebug(COMPONENT_FSAL, "atime = %lu", p_fsalattr_out->atime.tv_sec); } if (FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_CTIME)) { p_fsalattr_out->ctime = posix2fsal_time(p_buffstat->st_ctime, p_buffstat->st_ctim.tv_nsec); LogFullDebug(COMPONENT_FSAL, "ctime = %lu", p_fsalattr_out->ctime.tv_sec); } if (FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_MTIME)) { p_fsalattr_out->mtime = posix2fsal_time(p_buffstat->st_mtime, p_buffstat->st_mtim.tv_nsec); LogFullDebug(COMPONENT_FSAL, "mtime = %lu", p_fsalattr_out->mtime.tv_sec); } if (FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_CHGTIME)) { if (p_buffstat->st_mtime == p_buffstat->st_ctime) { if (p_buffstat->st_mtim.tv_nsec > p_buffstat->st_ctim.tv_nsec) p_fsalattr_out->chgtime = posix2fsal_time(p_buffstat->st_mtime, p_buffstat->st_mtim. tv_nsec); else p_fsalattr_out->chgtime = posix2fsal_time(p_buffstat->st_ctime, p_buffstat->st_ctim. tv_nsec); } else if (p_buffstat->st_mtime > p_buffstat->st_ctime) { p_fsalattr_out->chgtime = posix2fsal_time(p_buffstat->st_mtime, p_buffstat->st_mtim.tv_nsec); } else { p_fsalattr_out->chgtime = posix2fsal_time(p_buffstat->st_ctime, p_buffstat->st_ctim.tv_nsec); } p_fsalattr_out->change = (uint64_t) p_fsalattr_out->chgtime.tv_sec + (uint64_t) p_fsalattr_out->chgtime.tv_nsec; LogFullDebug(COMPONENT_FSAL, "chgtime = %lu", p_fsalattr_out->chgtime.tv_sec); } if (FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_SPACEUSED)) { p_fsalattr_out->spaceused = p_buffstat->st_blocks * S_BLKSIZE; LogFullDebug(COMPONENT_FSAL, "spaceused = %llu", (unsigned long long)p_fsalattr_out->spaceused); } if (FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_RAWDEV)) { p_fsalattr_out->rawdev = posix2fsal_devt(p_buffstat->st_rdev); LogFullDebug(COMPONENT_FSAL, "rawdev major = %u, minor = %u", (unsigned int)p_fsalattr_out->rawdev.major, (unsigned int)p_fsalattr_out->rawdev.minor); } /* everything has been copied ! */ return fsalstat(ERR_FSAL_NO_ERROR, 0); }
/* Same function as posixstat64_2_fsal_attributes. When NFS4 ACL support * is enabled, this will replace posixstat64_2_fsal_attributes. */ fsal_status_t ptfsal_xstat_2_fsal_attributes(ptfsal_xstat_t * p_buffxstat, fsal_attrib_list_t * p_fsalattr_out) { fsal_attrib_mask_t supp_attr, unsupp_attr; struct stat64 *p_buffstat; /* sanity checks */ if(!p_buffxstat || !p_fsalattr_out) ReturnCode(ERR_FSAL_FAULT, 0); /* check that asked attributes are supported */ supp_attr = global_fs_info.supported_attrs; unsupp_attr = (p_fsalattr_out->asked_attributes) & (~supp_attr); if(unsupp_attr) { LogFullDebug(COMPONENT_FSAL, "Unsupported attributes: %#llX", unsupp_attr); ReturnCode(ERR_FSAL_ATTRNOTSUPP, 0); } p_buffstat = &p_buffxstat->buffstat; /* Initialize ACL regardless of whether ACL was asked or not. * This is needed to make sure ACL attribute is initialized. */ p_fsalattr_out->acl = NULL; /* Fills the output struct */ if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_SUPPATTR)) { p_fsalattr_out->supported_attributes = supp_attr; LogFullDebug(COMPONENT_FSAL, "supported_attributes = %llu", p_fsalattr_out->supported_attributes); } if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_TYPE)) { p_fsalattr_out->type = posix2fsal_type(p_buffstat->st_mode); LogFullDebug(COMPONENT_FSAL, "type = 0x%x", p_fsalattr_out->type); } if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_SIZE)) { p_fsalattr_out->filesize = p_buffstat->st_size; LogFullDebug(COMPONENT_FSAL, "filesize = %lu", p_fsalattr_out->filesize); } if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_FSID)) { p_fsalattr_out->fsid = posix2fsal_fsid(p_buffstat->st_dev); LogFullDebug(COMPONENT_FSAL, "fsid major = %llu, minor = %llu", p_fsalattr_out->fsid.major, p_fsalattr_out->fsid.minor); } if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_ACL)) { #ifndef _USE_NFS4_ACL p_fsalattr_out->acl = NULL; #else if((p_buffxstat->attr_valid & XATTR_ACL) == 0) { /* ACL is invalid. */ p_fsalattr_out->acl = NULL; } else { /* ACL is valid, so try to convert fsal acl. */ if(ptfs_acl_2_fsal_acl(p_fsalattr_out, (gpfs_acl_t *)p_buffxstat->buffacl) != ERR_FSAL_NO_ERROR) p_fsalattr_out->acl = NULL; } #endif /* _USE_NFS4_ACL */ LogFullDebug(COMPONENT_FSAL, "acl = %p", p_fsalattr_out->acl); } if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_FILEID)) { p_fsalattr_out->fileid = (fsal_u64_t) (p_buffstat->st_ino); LogFullDebug(COMPONENT_FSAL, "fileid = %llu", p_fsalattr_out->fileid); } if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_MODE)) { p_fsalattr_out->mode = unix2fsal_mode(p_buffstat->st_mode); LogFullDebug(COMPONENT_FSAL, "mode = %llu", (long long unsigned int) p_fsalattr_out->mode); } if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_NUMLINKS)) { p_fsalattr_out->numlinks = p_buffstat->st_nlink; LogFullDebug(COMPONENT_FSAL, "numlinks = %lu", p_fsalattr_out->numlinks); } if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_OWNER)) { p_fsalattr_out->owner = p_buffstat->st_uid; LogFullDebug(COMPONENT_FSAL, "owner = %u", p_fsalattr_out->owner); } if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_GROUP)) { p_fsalattr_out->group = p_buffstat->st_gid; LogFullDebug(COMPONENT_FSAL, "group = %u", p_fsalattr_out->group); } if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_ATIME)) { p_fsalattr_out->atime = posix2fsal_time(p_buffstat->st_atime, p_buffstat->st_atim.tv_nsec); LogFullDebug(COMPONENT_FSAL, "atime = %u", p_fsalattr_out->atime.seconds); } if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_CTIME)) { p_fsalattr_out->ctime = posix2fsal_time(p_buffstat->st_ctime, p_buffstat->st_ctim.tv_nsec); LogFullDebug(COMPONENT_FSAL, "ctime = %u", p_fsalattr_out->ctime.seconds); } if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_MTIME)) { p_fsalattr_out->mtime = posix2fsal_time(p_buffstat->st_mtime, p_buffstat->st_mtim.tv_nsec); LogFullDebug(COMPONENT_FSAL, "mtime = %u", p_fsalattr_out->mtime.seconds); } if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_CHGTIME)) { p_fsalattr_out->chgtime = posix2fsal_time(MAX_2(p_buffstat->st_mtime, p_buffstat->st_ctime), 0); p_fsalattr_out->change = (uint64_t) p_fsalattr_out->chgtime.seconds ; LogFullDebug(COMPONENT_FSAL, "chgtime = %u", p_fsalattr_out->chgtime.seconds); } if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_SPACEUSED)) { p_fsalattr_out->spaceused = p_buffstat->st_blocks * S_BLKSIZE; LogFullDebug(COMPONENT_FSAL, "spaceused = %lu", p_fsalattr_out->spaceused); } if(FSAL_TEST_MASK(p_fsalattr_out->asked_attributes, FSAL_ATTR_RAWDEV)) { p_fsalattr_out->rawdev = posix2fsal_devt(p_buffstat->st_rdev); LogFullDebug(COMPONENT_FSAL, "rawdev major = %u, minor = %u", (unsigned int) p_fsalattr_out->rawdev.major, (unsigned int) p_fsalattr_out->rawdev.minor); } /* everything has been copied ! */ ReturnCode(ERR_FSAL_NO_ERROR, 0); }
/** * FSAL_lookup : * Looks up for an object into a directory. * * Note : if parent handle and filename are NULL, * this retrieves root's handle. * * \param parent_directory_handle (input) * Handle of the parent directory to search the object in. * \param filename (input) * The name of the object to find. * \param p_context (input) * Authentication context for the operation (user,...). * \param object_handle (output) * The handle of the object corresponding to filename. * \param object_attributes (optional input/output) * Pointer to the attributes of the object we found. * As input, it defines the attributes that the caller * wants to retrieve (by positioning flags into this structure) * and the output is built considering this input * (it fills the structure according to the flags it contains). * It can be NULL (increases performances). * * \return - ERR_FSAL_NO_ERROR, if no error. * - Another error code else. * */ fsal_status_t PTFSAL_lookup(const struct req_op_context *p_context, struct fsal_obj_handle *parent, const char *p_filename, struct attrlist *p_object_attr, ptfsal_handle_t *fh) { fsal_status_t status; int parent_fd; struct attrlist *parent_dir_attrs; fsi_stat_struct buffstat; int rc; struct pt_fsal_obj_handle *parent_hdl; FSI_TRACE(FSI_DEBUG, "Begin##################################\n"); if (p_filename != NULL) FSI_TRACE(FSI_DEBUG, "FSI - fsal_lookup file [%s]\n", p_filename); if (parent != NULL) FSI_TRACE(FSI_DEBUG, "FSI - fsal_lookup parent dir\n"); if (!parent || !p_filename) return fsalstat(ERR_FSAL_FAULT, 0); parent_hdl = container_of(parent, struct pt_fsal_obj_handle, obj_handle); parent_dir_attrs = &parent_hdl->obj_handle.attributes; /* get directory metadata */ parent_dir_attrs->mask = p_context->fsal_export->exp_ops. fs_supported_attrs(p_context->fsal_export); status = fsal_internal_handle2fd_at(p_context, parent_hdl, &parent_fd, O_RDONLY); if (FSAL_IS_ERROR(status)) return status; FSI_TRACE(FSI_DEBUG, "FSI - lookup parent directory type = %d\n", parent_dir_attrs->type); /* Be careful about junction crossing, symlinks, hardlinks,... */ switch (parent_dir_attrs->type) { case DIRECTORY: /* OK */ break; case REGULAR_FILE: case SYMBOLIC_LINK: /* not a directory */ pt_close(parent); return fsalstat(ERR_FSAL_NOTDIR, 0); default: return fsalstat(ERR_FSAL_SERVERFAULT, 0); } /* get file handle, it it exists */ /* This might be a race, but it's the best we can currently do */ rc = ptfsal_stat_by_parent_name(p_context, parent_hdl, p_filename, &buffstat); if (rc < 0) { ptfsal_closedir_fd(p_context, p_context->fsal_export, parent_fd); return fsalstat(ERR_FSAL_NOENT, errno); } memset(fh->data.handle.f_handle, 0, sizeof(fh->data.handle.f_handle)); memcpy(&fh->data.handle.f_handle, &buffstat.st_persistentHandle.handle, FSI_CCL_PERSISTENT_HANDLE_N_BYTES); fh->data.handle.handle_size = FSI_CCL_PERSISTENT_HANDLE_N_BYTES; fh->data.handle.handle_key_size = OPENHANDLE_KEY_LEN; fh->data.handle.handle_version = OPENHANDLE_VERSION; fh->data.handle.handle_type = posix2fsal_type(buffstat.st_mode); /* get object attributes */ if (p_object_attr) { p_object_attr->mask = p_context->fsal_export->exp_ops. fs_supported_attrs(p_context->fsal_export); status = PTFSAL_getattrs(p_context->fsal_export, p_context, fh, p_object_attr); if (FSAL_IS_ERROR(status)) { FSAL_CLEAR_MASK(p_object_attr->mask); FSAL_SET_MASK(p_object_attr->mask, ATTR_RDATTR_ERR); } } ptfsal_closedir_fd(p_context, p_context->fsal_export, parent_fd); FSI_TRACE(FSI_DEBUG, "End##################################\n"); /* lookup complete ! */ return fsalstat(ERR_FSAL_NO_ERROR, 0); }
fsal_status_t posixstat64_2_fsal_attributes(struct stat *p_buffstat, struct attrlist *p_fsalattr_out) { /* sanity checks */ if (!p_buffstat || !p_fsalattr_out) return fsalstat(ERR_FSAL_FAULT, 0); /* Initialize ACL regardless of whether ACL was asked or not. * This is needed to make sure ACL attribute is initialized. */ p_fsalattr_out->acl = NULL; /* Fills the output struct */ if (FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_TYPE)) p_fsalattr_out->type = posix2fsal_type(p_buffstat->st_mode); if (FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_SIZE)) p_fsalattr_out->filesize = p_buffstat->st_size; if (FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_FSID)) p_fsalattr_out->fsid = posix2fsal_fsid(p_buffstat->st_dev); if (FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_ACL)) p_fsalattr_out->acl = NULL; if (FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_FILEID)) p_fsalattr_out->fileid = (uint64_t) (p_buffstat->st_ino); if (FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_MODE)) p_fsalattr_out->mode = unix2fsal_mode(p_buffstat->st_mode); if (FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_NUMLINKS)) p_fsalattr_out->numlinks = p_buffstat->st_nlink; if (FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_OWNER)) p_fsalattr_out->owner = p_buffstat->st_uid; if (FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_GROUP)) p_fsalattr_out->group = p_buffstat->st_gid; if (FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_ATIME)) { p_fsalattr_out->atime = posix2fsal_time(p_buffstat->st_atime, p_buffstat->st_atim.tv_nsec); } if (FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_CTIME)) { p_fsalattr_out->ctime = posix2fsal_time(p_buffstat->st_ctime, p_buffstat->st_ctim.tv_nsec); } if (FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_MTIME)) { p_fsalattr_out->mtime = posix2fsal_time(p_buffstat->st_mtime, p_buffstat->st_mtim.tv_nsec); } if (FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_CHGTIME)) { p_fsalattr_out->chgtime = posix2fsal_time(MAX (p_buffstat->st_mtime, p_buffstat->st_ctime), 0); p_fsalattr_out->change = (uint64_t) p_fsalattr_out->chgtime.tv_sec; } if (FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_SPACEUSED)) p_fsalattr_out->spaceused = p_buffstat->st_blocks * S_BLKSIZE; if (FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_RAWDEV)) p_fsalattr_out->rawdev = posix2fsal_devt(p_buffstat->st_rdev); /* everything has been copied ! */ return fsalstat(ERR_FSAL_NO_ERROR, 0); }
/* alloc_handle * allocate and fill in a handle * this uses malloc/free for the time being. */ static struct lustre_fsal_obj_handle *alloc_handle( struct lustre_file_handle *fh, struct fsal_filesystem *fs, struct stat *stat, const char *link_content, struct lustre_file_handle *dir_fh, const char *sock_name, struct fsal_export *exp_hdl) { struct lustre_fsal_obj_handle *hdl; fsal_status_t st; hdl = gsh_malloc(sizeof(struct lustre_fsal_obj_handle) + sizeof(struct lustre_file_handle)); if (hdl == NULL) return NULL; memset(hdl, 0, (sizeof(struct lustre_fsal_obj_handle) + sizeof(struct lustre_file_handle))); hdl->handle = (struct lustre_file_handle *)&hdl[1]; memcpy(hdl->handle, fh, sizeof(struct lustre_file_handle)); hdl->obj_handle.type = posix2fsal_type(stat->st_mode); hdl->dev = posix2fsal_devt(stat->st_dev); hdl->obj_handle.fs = fs; if (hdl->obj_handle.type == REGULAR_FILE) { hdl->u.file.fd = -1; /* no open on this yet */ hdl->u.file.openflags = FSAL_O_CLOSED; } else if (hdl->obj_handle.type == SYMBOLIC_LINK && link_content != NULL) { size_t len = strlen(link_content) + 1; hdl->u.symlink.link_content = gsh_malloc(len); if (hdl->u.symlink.link_content == NULL) goto spcerr; memcpy(hdl->u.symlink.link_content, link_content, len); hdl->u.symlink.link_size = len; } else if (hdl->obj_handle.type == SOCKET_FILE && dir_fh != NULL && sock_name != NULL) { hdl->u.sock.sock_dir = gsh_malloc(sizeof(struct lustre_file_handle)); if (hdl->u.sock.sock_dir == NULL) goto spcerr; memcpy(hdl->u.sock.sock_dir, dir_fh, sizeof(struct lustre_file_handle)); hdl->u.sock.sock_name = gsh_malloc(strlen(sock_name) + 1); if (hdl->u.sock.sock_name == NULL) goto spcerr; strcpy(hdl->u.sock.sock_name, sock_name); } hdl->obj_handle.attributes.mask = exp_hdl->ops->fs_supported_attrs(exp_hdl); st = posix2fsal_attributes(stat, &hdl->obj_handle.attributes); if (FSAL_IS_ERROR(st)) goto spcerr; fsal_obj_handle_init(&hdl->obj_handle, exp_hdl, posix2fsal_type(stat->st_mode)); return hdl; spcerr: if (hdl->obj_handle.type == SYMBOLIC_LINK) { if (hdl->u.symlink.link_content != NULL) gsh_free(hdl->u.symlink.link_content); } else if (hdl->obj_handle.type == SOCKET_FILE) { if (hdl->u.sock.sock_name != NULL) gsh_free(hdl->u.sock.sock_name); if (hdl->u.sock.sock_dir != NULL) gsh_free(hdl->u.sock.sock_dir); } gsh_free(hdl); /* elvis has left the building */ return NULL; }
/** * FSAL_lookup : * Looks up for an object into a directory. * * Note : if parent handle and filename are NULL, * this retrieves root's handle. * * \param parent_directory_handle (input) * Handle of the parent directory to search the object in. * \param filename (input) * The name of the object to find. * \param p_context (input) * Authentication context for the operation (user,...). * \param object_handle (output) * The handle of the object corresponding to filename. * \param object_attributes (optional input/output) * Pointer to the attributes of the object we found. * As input, it defines the attributes that the caller * wants to retrieve (by positioning flags into this structure) * and the output is built considering this input * (it fills the structure according to the flags it contains). * * \return - ERR_FSAL_NO_ERROR, if no error. * - Another error code else. * */ fsal_status_t XFSFSAL_lookup(fsal_handle_t * parent_handle, /* IN */ fsal_name_t * p_filename, /* IN */ fsal_op_context_t * context, /* IN */ fsal_handle_t * object_handle, /* OUT */ fsal_attrib_list_t * p_object_attributes /* [ IN/OUT ] */ ) { xfsfsal_handle_t * p_parent_directory_handle = (xfsfsal_handle_t *)parent_handle; xfsfsal_op_context_t * p_context = (xfsfsal_op_context_t *)context; xfsfsal_handle_t * p_object_handle = (xfsfsal_handle_t *)object_handle; int rc = 0 , errsv = 0 ; fsal_status_t status; struct stat buffstat; int parentfd; /* sanity checks * note : object_attributes is optionnal * parent_directory_handle may be null for getting FS root. */ if(!p_object_handle || !p_context) Return(ERR_FSAL_FAULT, 0, INDEX_FSAL_lookup); /* filename AND parent handle are NULL => lookup "/" */ if((p_parent_directory_handle && !p_filename) || (!p_parent_directory_handle && p_filename)) Return(ERR_FSAL_FAULT, 0, INDEX_FSAL_lookup); /* get information about root */ if(!p_parent_directory_handle) { /* get handle for the mount point */ memcpy(p_object_handle->data.handle_val, p_context->export_context->mnt_handle_val, p_context->export_context->mnt_handle_len); p_object_handle->data.handle_len = p_context->export_context->mnt_handle_len; /* get attributes, if asked */ if(p_object_attributes) { status = XFSFSAL_getattrs(p_object_handle, p_context, p_object_attributes); if(FSAL_IS_ERROR(status)) { FSAL_CLEAR_MASK(p_object_attributes->asked_attributes); FSAL_SET_MASK(p_object_attributes->asked_attributes, FSAL_ATTR_RDATTR_ERR); } } /* Done */ Return(ERR_FSAL_NO_ERROR, 0, INDEX_FSAL_lookup); } /* retrieve directory attributes */ TakeTokenFSCall(); status = fsal_internal_handle2fd(context, parent_handle, &parentfd, O_RDONLY); ReleaseTokenFSCall(); if(FSAL_IS_ERROR(status)) ReturnStatus(status, INDEX_FSAL_lookup); /* get directory metadata */ TakeTokenFSCall(); rc = fstat(parentfd, &buffstat); errsv = errno; ReleaseTokenFSCall(); if(rc) { close( parentfd ) ; if(errsv == ENOENT) Return(ERR_FSAL_STALE, errsv, INDEX_FSAL_lookup); else Return(posix2fsal_error(errsv), errsv, INDEX_FSAL_lookup); } /* Be careful about junction crossing, symlinks, hardlinks,... */ switch (posix2fsal_type(buffstat.st_mode)) { case FSAL_TYPE_DIR: // OK break; case FSAL_TYPE_JUNCTION: close( parentfd ) ; // This is a junction Return(ERR_FSAL_XDEV, 0, INDEX_FSAL_lookup); case FSAL_TYPE_FILE: case FSAL_TYPE_LNK: case FSAL_TYPE_XATTR: close( parentfd ) ; // not a directory Return(ERR_FSAL_NOTDIR, 0, INDEX_FSAL_lookup); default: close( parentfd ) ; Return(ERR_FSAL_SERVERFAULT, 0, INDEX_FSAL_lookup); } LogFullDebug(COMPONENT_FSAL, "lookup of inode=%"PRIu64"/%s", buffstat.st_ino, p_filename->name); /* check rights to enter into the directory */ status = fsal_check_access(context, FSAL_X_OK, &buffstat, NULL); if(FSAL_IS_ERROR(status)) ReturnStatus(status, INDEX_FSAL_lookup); status = xfsfsal_stat_by_name(context, parentfd, p_filename->name, object_handle, p_object_attributes); close(parentfd); ReturnStatus(status, INDEX_FSAL_lookup); }
/** * @brief convert GPFS xstat to FSAl attributes * * @param gpfs_buf Reference to GPFS stat buffer * @param fsal_attr Reference to attribute list * @param use_acl Bool whether ACL are used * @return FSAL status * * Same function as posixstat64_2_fsal_attributes. When NFS4 ACL support * is enabled, this will replace posixstat64_2_fsal_attributes. */ fsal_status_t gpfsfsal_xstat_2_fsal_attributes(gpfsfsal_xstat_t *gpfs_buf, struct attrlist *fsal_attr, bool use_acl) { struct stat *p_buffstat; /* sanity checks */ if (!gpfs_buf || !fsal_attr) return fsalstat(ERR_FSAL_FAULT, 0); p_buffstat = &gpfs_buf->buffstat; LogDebug(COMPONENT_FSAL, "inode %ld", p_buffstat->st_ino); /* Fills the output struct */ if (FSAL_TEST_MASK(fsal_attr->mask, ATTR_TYPE)) { fsal_attr->type = posix2fsal_type(p_buffstat->st_mode); LogFullDebug(COMPONENT_FSAL, "type = 0x%x", fsal_attr->type); } if (FSAL_TEST_MASK(fsal_attr->mask, ATTR_SIZE)) { fsal_attr->filesize = p_buffstat->st_size; LogFullDebug(COMPONENT_FSAL, "filesize = %llu", (unsigned long long)fsal_attr->filesize); } if (FSAL_TEST_MASK(fsal_attr->mask, ATTR_FSID)) { fsal_attr->fsid = gpfs_buf->fsal_fsid; LogFullDebug(COMPONENT_FSAL, "fsid=0x%016"PRIx64".0x%016"PRIx64, fsal_attr->fsid.major, fsal_attr->fsid.minor); } if (FSAL_TEST_MASK(fsal_attr->mask, ATTR_ACL)) { if (fsal_attr->acl != NULL) { /* We should never be passed attributes that have an * ACL attached, but just in case some future code * path changes that assumption, let's not release the * old ACL properly. */ int acl_status; acl_status = nfs4_acl_release_entry(fsal_attr->acl); if (acl_status != NFS_V4_ACL_SUCCESS) LogCrit(COMPONENT_FSAL, "Failed to release old acl, status=%d", acl_status); fsal_attr->acl = NULL; } if (use_acl && gpfs_buf->attr_valid & XATTR_ACL) { /* ACL is valid, so try to convert fsal acl. */ gpfs_acl_2_fsal_acl(fsal_attr, (gpfs_acl_t *) gpfs_buf->buffacl); } LogFullDebug(COMPONENT_FSAL, "acl = %p", fsal_attr->acl); } if (FSAL_TEST_MASK(fsal_attr->mask, ATTR_FILEID)) { fsal_attr->fileid = (uint64_t) (p_buffstat->st_ino); LogFullDebug(COMPONENT_FSAL, "fileid = %" PRIu64, fsal_attr->fileid); } if (FSAL_TEST_MASK(fsal_attr->mask, ATTR_MODE)) { fsal_attr->mode = unix2fsal_mode(p_buffstat->st_mode); LogFullDebug(COMPONENT_FSAL, "mode = %"PRIu32, fsal_attr->mode); } if (FSAL_TEST_MASK(fsal_attr->mask, ATTR_NUMLINKS)) { fsal_attr->numlinks = p_buffstat->st_nlink; LogFullDebug(COMPONENT_FSAL, "numlinks = %u", fsal_attr->numlinks); } if (FSAL_TEST_MASK(fsal_attr->mask, ATTR_OWNER)) { fsal_attr->owner = p_buffstat->st_uid; LogFullDebug(COMPONENT_FSAL, "owner = %" PRIu64, fsal_attr->owner); } if (FSAL_TEST_MASK(fsal_attr->mask, ATTR_GROUP)) { fsal_attr->group = p_buffstat->st_gid; LogFullDebug(COMPONENT_FSAL, "group = %" PRIu64, fsal_attr->group); } if (FSAL_TEST_MASK(fsal_attr->mask, ATTR_ATIME)) { fsal_attr->atime = posix2fsal_time(p_buffstat->st_atime, p_buffstat->st_atim.tv_nsec); LogFullDebug(COMPONENT_FSAL, "atime = %lu", fsal_attr->atime.tv_sec); } if (FSAL_TEST_MASK(fsal_attr->mask, ATTR_CTIME)) { fsal_attr->ctime = posix2fsal_time(p_buffstat->st_ctime, p_buffstat->st_ctim.tv_nsec); LogFullDebug(COMPONENT_FSAL, "ctime = %lu", fsal_attr->ctime.tv_sec); } if (FSAL_TEST_MASK(fsal_attr->mask, ATTR_MTIME)) { fsal_attr->mtime = posix2fsal_time(p_buffstat->st_mtime, p_buffstat->st_mtim.tv_nsec); LogFullDebug(COMPONENT_FSAL, "mtime = %lu", fsal_attr->mtime.tv_sec); } if (FSAL_TEST_MASK(fsal_attr->mask, ATTR_CHGTIME)) { if (p_buffstat->st_mtime == p_buffstat->st_ctime) { if (p_buffstat->st_mtim.tv_nsec > p_buffstat->st_ctim.tv_nsec) fsal_attr->chgtime = posix2fsal_time(p_buffstat->st_mtime, p_buffstat->st_mtim. tv_nsec); else fsal_attr->chgtime = posix2fsal_time(p_buffstat->st_ctime, p_buffstat->st_ctim. tv_nsec); } else if (p_buffstat->st_mtime > p_buffstat->st_ctime) { fsal_attr->chgtime = posix2fsal_time(p_buffstat->st_mtime, p_buffstat->st_mtim.tv_nsec); } else { fsal_attr->chgtime = posix2fsal_time(p_buffstat->st_ctime, p_buffstat->st_ctim.tv_nsec); } fsal_attr->change = (uint64_t) fsal_attr->chgtime.tv_sec + (uint64_t) fsal_attr->chgtime.tv_nsec; LogFullDebug(COMPONENT_FSAL, "chgtime = %lu", fsal_attr->chgtime.tv_sec); } if (FSAL_TEST_MASK(fsal_attr->mask, ATTR_SPACEUSED)) { fsal_attr->spaceused = p_buffstat->st_blocks * S_BLKSIZE; LogFullDebug(COMPONENT_FSAL, "spaceused = %llu", (unsigned long long)fsal_attr->spaceused); } if (FSAL_TEST_MASK(fsal_attr->mask, ATTR_RAWDEV)) { fsal_attr->rawdev = posix2fsal_devt(p_buffstat->st_rdev); LogFullDebug(COMPONENT_FSAL, "rawdev major = %u, minor = %u", (unsigned int)fsal_attr->rawdev.major, (unsigned int)fsal_attr->rawdev.minor); } /* everything has been copied ! */ return fsalstat(ERR_FSAL_NO_ERROR, 0); }
fsal_status_t posix2fsal_attributes(struct stat * p_buffstat, struct attrlist * p_fsalattr_out) { /* sanity checks */ if(!p_buffstat || !p_fsalattr_out) return fsalstat(ERR_FSAL_FAULT, 0); /* Initialize ACL regardless of whether ACL was asked or not. * This is needed to make sure ACL attribute is initialized. */ p_fsalattr_out->acl = NULL; /* Fills the output struct */ if(FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_TYPE)) { p_fsalattr_out->type = posix2fsal_type(p_buffstat->st_mode); } if(FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_SIZE)) { p_fsalattr_out->filesize = p_buffstat->st_size; } if(FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_FSID)) { p_fsalattr_out->fsid = posix2fsal_fsid(p_buffstat->st_dev); } if(FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_ACL)) { p_fsalattr_out->acl = NULL; } if(FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_FILEID)) { p_fsalattr_out->fileid = (uint64_t) (p_buffstat->st_ino); } if(FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_MODE)) { p_fsalattr_out->mode = unix2fsal_mode(p_buffstat->st_mode); } if(FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_NUMLINKS)) { p_fsalattr_out->numlinks = p_buffstat->st_nlink; } if(FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_OWNER)) { p_fsalattr_out->owner = p_buffstat->st_uid; } if(FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_GROUP)) { p_fsalattr_out->group = p_buffstat->st_gid; } if(FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_ATIME)) { p_fsalattr_out->atime = p_buffstat->st_atim; } if(FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_CTIME)) { p_fsalattr_out->ctime = p_buffstat->st_ctim; } if(FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_MTIME)) { p_fsalattr_out->mtime = p_buffstat->st_mtim; } if(FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_CHGTIME)) { p_fsalattr_out->chgtime = (gsh_time_cmp(&p_buffstat->st_mtim, &p_buffstat->st_ctim) > 0) ? p_buffstat->st_mtim : p_buffstat->st_ctim; /* XXX */ p_fsalattr_out->change = p_fsalattr_out->chgtime.tv_sec + p_fsalattr_out->chgtime.tv_nsec; } if(FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_SPACEUSED)) { p_fsalattr_out->spaceused = p_buffstat->st_blocks * S_BLKSIZE; } if(FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_RAWDEV)) { p_fsalattr_out->rawdev = posix2fsal_devt(p_buffstat->st_rdev); /* XXX: convert ? */ } /* mounted_on_fileid : if ( FSAL_TEST_MASK(p_fsalattr_out->mask, ATTR_MOUNTFILEID )){ p_fsalattr_out->mounted_on_fileid = hpss2fsal_64( p_hpss_attr_in->FilesetRootId ); } */ /* everything has been copied ! */ return fsalstat(ERR_FSAL_NO_ERROR, 0); }
static struct vfs_fsal_obj_handle *alloc_handle(int dirfd, vfs_file_handle_t *fh, struct fsal_filesystem *fs, struct stat *stat, vfs_file_handle_t *dir_fh, const char *path, struct fsal_export *exp_hdl) { struct vfs_fsal_export *myself = container_of(exp_hdl, struct vfs_fsal_export, export); struct vfs_fsal_obj_handle *hdl; fsal_status_t st; hdl = gsh_calloc(1, (sizeof(struct vfs_fsal_obj_handle) + sizeof(vfs_file_handle_t))); if (hdl == NULL) return NULL; hdl->handle = (vfs_file_handle_t *) &hdl[1]; memcpy(hdl->handle, fh, sizeof(vfs_file_handle_t)); hdl->obj_handle.type = posix2fsal_type(stat->st_mode); hdl->dev = posix2fsal_devt(stat->st_dev); hdl->up_ops = exp_hdl->up_ops; hdl->obj_handle.fs = fs; if (hdl->obj_handle.type == REGULAR_FILE) { hdl->u.file.fd = -1; /* no open on this yet */ hdl->u.file.openflags = FSAL_O_CLOSED; } else if (hdl->obj_handle.type == SYMBOLIC_LINK) { ssize_t retlink; size_t len = stat->st_size + 1; char *link_content = gsh_malloc(len); if (link_content == NULL) goto spcerr; retlink = vfs_readlink_by_handle(fh, dirfd, path, link_content, len); if (retlink < 0 || retlink == len) goto spcerr; link_content[retlink] = '\0'; hdl->u.symlink.link_content = link_content; hdl->u.symlink.link_size = len; } else if (vfs_unopenable_type(hdl->obj_handle.type)) { /* AF_UNIX sockets, character special, and block special files require craziness */ if (dir_fh == NULL) { int retval; vfs_alloc_handle(dir_fh); retval = vfs_fd_to_handle(dirfd, hdl->obj_handle.fs, fh); if (retval < 0) goto spcerr; } hdl->u.unopenable.dir = gsh_malloc(sizeof(vfs_file_handle_t)); if (hdl->u.unopenable.dir == NULL) goto spcerr; memcpy(hdl->u.unopenable.dir, dir_fh, sizeof(vfs_file_handle_t)); hdl->u.unopenable.name = gsh_strdup(path); if (hdl->u.unopenable.name == NULL) goto spcerr; } hdl->obj_handle.attributes.mask = exp_hdl->exp_ops.fs_supported_attrs(exp_hdl); st = posix2fsal_attributes(stat, &hdl->obj_handle.attributes); if (FSAL_IS_ERROR(st)) goto spcerr; hdl->obj_handle.attributes.fsid = fs->fsid; fsal_obj_handle_init(&hdl->obj_handle, exp_hdl, posix2fsal_type(stat->st_mode)); vfs_handle_ops_init(&hdl->obj_handle.obj_ops); vfs_sub_init_handle_ops(myself, &hdl->obj_handle.obj_ops); return hdl; spcerr: if (hdl->obj_handle.type == SYMBOLIC_LINK) { if (hdl->u.symlink.link_content != NULL) gsh_free(hdl->u.symlink.link_content); } else if (vfs_unopenable_type(hdl->obj_handle.type)) { if (hdl->u.unopenable.name != NULL) gsh_free(hdl->u.unopenable.name); if (hdl->u.unopenable.dir != NULL) gsh_free(hdl->u.unopenable.dir); } gsh_free(hdl); /* elvis has left the building */ return NULL; }
/** * FSAL_lookup : * Looks up for an object into a directory. * * Note : if parent handle and filename are NULL, * this retrieves root's handle. * * \param parent_directory_handle (input) * Handle of the parent directory to search the object in. * \param filename (input) * The name of the object to find. * \param p_context (input) * Authentication context for the operation (user,...). * \param object_handle (output) * The handle of the object corresponding to filename. * \param object_attributes (optional input/output) * Pointer to the attributes of the object we found. * As input, it defines the attributes that the caller * wants to retrieve (by positioning flags into this structure) * and the output is built considering this input * (it fills the structure according to the flags it contains). * It can be NULL (increases performances). * * \return - ERR_FSAL_NO_ERROR, if no error. * - Another error code else. * */ fsal_status_t LUSTREFSAL_lookup(fsal_handle_t * p_parent_directory_handle, /* IN */ fsal_name_t * p_filename, /* IN */ fsal_op_context_t * p_context, /* IN */ fsal_handle_t * p_object_handle, /* OUT */ fsal_attrib_list_t * p_object_attributes /* [ IN/OUT ] */ ) { int rc, errsv; fsal_status_t status; struct stat buffstat; fsal_path_t pathfsal; /* sanity checks * note : object_attributes is optionnal * parent_directory_handle may be null for getting FS root. */ if(!p_object_handle || !p_context) Return(ERR_FSAL_FAULT, 0, INDEX_FSAL_lookup); /* filename AND parent handle are NULL => lookup "/" */ if((p_parent_directory_handle && !p_filename) || (!p_parent_directory_handle && p_filename)) Return(ERR_FSAL_FAULT, 0, INDEX_FSAL_lookup); /* get information about root */ if(!p_parent_directory_handle) { /* get handle for the mount point */ FSAL_str2path(((lustrefsal_op_context_t *)p_context)->export_context->mount_point, ((lustrefsal_op_context_t *)p_context)->export_context->mnt_len, &pathfsal); TakeTokenFSCall(); status = fsal_internal_Path2Handle(p_context, &pathfsal, p_object_handle); ReleaseTokenFSCall(); if(FSAL_IS_ERROR(status)) ReturnStatus(status, INDEX_FSAL_lookup); /* get attributes, if asked */ if(p_object_attributes) { status = LUSTREFSAL_getattrs(p_object_handle, p_context, p_object_attributes); if(FSAL_IS_ERROR(status)) { FSAL_CLEAR_MASK(p_object_attributes->asked_attributes); FSAL_SET_MASK(p_object_attributes->asked_attributes, FSAL_ATTR_RDATTR_ERR); } } /* Done */ Return(ERR_FSAL_NO_ERROR, 0, INDEX_FSAL_lookup); } /* retrieve directory attributes */ status = fsal_internal_Handle2FidPath(p_context, p_parent_directory_handle, &pathfsal); if(FSAL_IS_ERROR(status)) ReturnStatus(status, INDEX_FSAL_lookup); /* get directory metadata */ TakeTokenFSCall(); rc = lstat(pathfsal.path, &buffstat); errsv = errno; ReleaseTokenFSCall(); if(rc) { if(errsv == ENOENT) Return(ERR_FSAL_STALE, errsv, INDEX_FSAL_lookup); else Return(posix2fsal_error(errsv), errsv, INDEX_FSAL_lookup); } /* Be careful about junction crossing, symlinks, hardlinks,... */ switch (posix2fsal_type(buffstat.st_mode)) { case FSAL_TYPE_DIR: // OK break; case FSAL_TYPE_JUNCTION: // This is a junction Return(ERR_FSAL_XDEV, 0, INDEX_FSAL_lookup); case FSAL_TYPE_FILE: case FSAL_TYPE_LNK: case FSAL_TYPE_XATTR: // not a directory Return(ERR_FSAL_NOTDIR, 0, INDEX_FSAL_lookup); default: Return(ERR_FSAL_SERVERFAULT, 0, INDEX_FSAL_lookup); } LogFullDebug(COMPONENT_FSAL, "lookup of %s/%s\n", pathfsal.path, p_filename->name); /* check rights to enter into the directory */ status = fsal_internal_testAccess(p_context, FSAL_X_OK, &buffstat, NULL); if(FSAL_IS_ERROR(status)) ReturnStatus(status, INDEX_FSAL_lookup); status = fsal_internal_appendNameToPath(&pathfsal, p_filename); if(FSAL_IS_ERROR(status)) ReturnStatus(status, INDEX_FSAL_lookup); /* get file handle, it it exists */ TakeTokenFSCall(); status = fsal_internal_Path2Handle(p_context, &pathfsal, p_object_handle); ReleaseTokenFSCall(); if(FSAL_IS_ERROR(status)) ReturnStatus(status, INDEX_FSAL_lookup); /* get object attributes */ if(p_object_attributes) { status = LUSTREFSAL_getattrs(p_object_handle, p_context, p_object_attributes); if(FSAL_IS_ERROR(status)) { FSAL_CLEAR_MASK(p_object_attributes->asked_attributes); FSAL_SET_MASK(p_object_attributes->asked_attributes, FSAL_ATTR_RDATTR_ERR); } } /* lookup complete ! */ Return(ERR_FSAL_NO_ERROR, 0, INDEX_FSAL_lookup); }