static int streams_xattr_fstat(vfs_handle_struct *handle, files_struct *fsp,
SMB_STRUCT_STAT *sbuf)
{
struct smb_filename *smb_fname_base = NULL;
int ret = -1;
struct stream_io *io = (struct stream_io *)
VFS_FETCH_FSP_EXTENSION(handle, fsp);
if (io == NULL || fsp->base_fsp == NULL) {
return SMB_VFS_NEXT_FSTAT(handle, fsp, sbuf);
}
DBG_DEBUG("streams_xattr_fstat called for %s\n", fsp_str_dbg(io->fsp));
if (!streams_xattr_recheck(io)) {
return -1;
}
/* Create an smb_filename with stream_name == NULL. */
smb_fname_base = synthetic_smb_fname(talloc_tos(),
io->base,
NULL,
NULL,
fsp->fsp_name->flags);
if (smb_fname_base == NULL) {
errno = ENOMEM;
return -1;
}
if (smb_fname_base->flags & SMB_FILENAME_POSIX_PATH) {
ret = SMB_VFS_LSTAT(handle->conn, smb_fname_base);
} else {
ret = SMB_VFS_STAT(handle->conn, smb_fname_base);
}
*sbuf = smb_fname_base->st;
if (ret == -1) {
TALLOC_FREE(smb_fname_base);
return -1;
}
sbuf->st_ex_size = get_xattr_size(handle->conn,
smb_fname_base, io->xattr_name);
if (sbuf->st_ex_size == -1) {
TALLOC_FREE(smb_fname_base);
SET_STAT_INVALID(*sbuf);
return -1;
}
DEBUG(10, ("sbuf->st_ex_size = %d\n", (int)sbuf->st_ex_size));
sbuf->st_ex_ino = stream_inode(sbuf, io->xattr_name);
sbuf->st_ex_mode &= ~S_IFMT;
sbuf->st_ex_mode &= ~S_IFDIR;
sbuf->st_ex_mode |= S_IFREG;
sbuf->st_ex_blocks = sbuf->st_ex_size / STAT_ST_BLOCKSIZE + 1;
TALLOC_FREE(smb_fname_base);
return 0;
}
static int streams_xattr_stat(vfs_handle_struct *handle,
struct smb_filename *smb_fname)
{
NTSTATUS status;
int result = -1;
char *xattr_name = NULL;
if (!is_ntfs_stream_smb_fname(smb_fname)) {
return SMB_VFS_NEXT_STAT(handle, smb_fname);
}
/* Note if lp_posix_paths() is true, we can never
* get here as is_ntfs_stream_smb_fname() is
* always false. So we never need worry about
* not following links here. */
/* If the default stream is requested, just stat the base file. */
if (is_ntfs_default_stream_smb_fname(smb_fname)) {
return streams_xattr_stat_base(handle, smb_fname, true);
}
/* Populate the stat struct with info from the base file. */
if (streams_xattr_stat_base(handle, smb_fname, true) == -1) {
return -1;
}
/* Derive the xattr name to lookup. */
status = streams_xattr_get_name(handle, talloc_tos(),
smb_fname->stream_name, &xattr_name);
if (!NT_STATUS_IS_OK(status)) {
errno = map_errno_from_nt_status(status);
return -1;
}
/* Augment the base file's stat information before returning. */
smb_fname->st.st_ex_size = get_xattr_size(handle->conn,
smb_fname,
xattr_name);
if (smb_fname->st.st_ex_size == -1) {
SET_STAT_INVALID(smb_fname->st);
errno = ENOENT;
result = -1;
goto fail;
}
smb_fname->st.st_ex_ino = stream_inode(&smb_fname->st, xattr_name);
smb_fname->st.st_ex_mode &= ~S_IFMT;
smb_fname->st.st_ex_mode &= ~S_IFDIR;
smb_fname->st.st_ex_mode |= S_IFREG;
smb_fname->st.st_ex_blocks =
smb_fname->st.st_ex_size / STAT_ST_BLOCKSIZE + 1;
result = 0;
fail:
TALLOC_FREE(xattr_name);
return result;
}
static int streams_xattr_fstat(vfs_handle_struct *handle, files_struct *fsp,
SMB_STRUCT_STAT *sbuf)
{
struct smb_filename *smb_fname_base = NULL;
NTSTATUS status;
int ret = -1;
struct stream_io *io = (struct stream_io *)
VFS_FETCH_FSP_EXTENSION(handle, fsp);
DEBUG(10, ("streams_xattr_fstat called for %d\n", fsp->fh->fd));
if (io == NULL || fsp->base_fsp == NULL) {
return SMB_VFS_NEXT_FSTAT(handle, fsp, sbuf);
}
if (!streams_xattr_recheck(io)) {
return -1;
}
/* Create an smb_filename with stream_name == NULL. */
status = create_synthetic_smb_fname(talloc_tos(),
io->base,
NULL, NULL,
&smb_fname_base);
if (!NT_STATUS_IS_OK(status)) {
errno = map_errno_from_nt_status(status);
return -1;
}
if (lp_posix_pathnames()) {
ret = SMB_VFS_LSTAT(handle->conn, smb_fname_base);
} else {
ret = SMB_VFS_STAT(handle->conn, smb_fname_base);
}
*sbuf = smb_fname_base->st;
TALLOC_FREE(smb_fname_base);
if (ret == -1) {
return -1;
}
sbuf->st_ex_size = get_xattr_size(handle->conn, fsp->base_fsp,
io->base, io->xattr_name);
if (sbuf->st_ex_size == -1) {
return -1;
}
DEBUG(10, ("sbuf->st_ex_size = %d\n", (int)sbuf->st_ex_size));
sbuf->st_ex_ino = stream_inode(sbuf, io->xattr_name);
sbuf->st_ex_mode &= ~S_IFMT;
sbuf->st_ex_mode |= S_IFREG;
sbuf->st_ex_blocks = sbuf->st_ex_size / STAT_ST_BLOCKSIZE + 1;
return 0;
}
int generate_xattrs(int xattrs, struct xattr_list *xattr_list)
{
int total_size, i;
int xattr_value_max;
void *xp;
long long xattr_disk;
struct dupl_id *xattr_dupl;
/*
* check if the file xattrs are a complete duplicate of a pre-existing
* id
*/
xattr_dupl = check_id_dupl(xattr_list, xattrs);
if (xattr_dupl == NULL)
return SQUASHFS_INVALID_XATTR;
if(xattr_dupl->xattr_id != SQUASHFS_INVALID_XATTR)
return xattr_dupl->xattr_id;
/*
* Scan the xattr_list deciding which type to assign to each
* xattr. The choice is fairly straightforward, and depends on the
* size of each xattr name/value and the overall size of the
* resultant xattr list stored in the xattr metadata table.
*
* Choices are whether to store data inline or out of line.
*
* The overall goal is to optimise xattr scanning and lookup, and
* to enable the file system layout to scale from a couple of
* small xattr name/values to a large number of large xattr
* names/values without affecting performance. While hopefully
* enabling the common case of a couple of small xattr name/values
* to be stored efficiently
*
* Code repeatedly scans, doing the following
* move xattr data out of line if it exceeds
* xattr_value_max. Where xattr_value_max is
* initially XATTR_INLINE_MAX. If the final uncompressed
* xattr list is larger than XATTR_TARGET_MAX then more
* aggressively move xattr data out of line by repeatedly
* setting inline threshold to 1/2, then 1/4, 1/8 of
* XATTR_INLINE_MAX until target achieved or there's
* nothing left to move out of line
*/
xattr_value_max = XATTR_INLINE_MAX;
while(1) {
for(total_size = 0, i = 0; i < xattrs; i++) {
struct xattr_list *xattr = &xattr_list[i];
xattr->type &= XATTR_PREFIX_MASK; /* all inline */
if (xattr->vsize > xattr_value_max)
xattr->type |= XATTR_VALUE_OOL;
total_size += get_xattr_size(xattr);
}
/*
* If the total size of the uncompressed xattr list is <=
* XATTR_TARGET_MAX we're done
*/
if(total_size <= XATTR_TARGET_MAX)
break;
if(xattr_value_max == XATTR_VALUE_OOL_SIZE)
break;
/*
* Inline target not yet at minimum and so reduce it, and
* try again
*/
xattr_value_max /= 2;
if(xattr_value_max < XATTR_VALUE_OOL_SIZE)
xattr_value_max = XATTR_VALUE_OOL_SIZE;
}
/*
* Check xattr values for duplicates
*/
for(i = 0; i < xattrs; i++) {
check_value_dupl(&xattr_list[i]);
}
/*
* Add each out of line value to the file system xattr table
* if it doesn't already exist as a duplicate
*/
for(i = 0; i < xattrs; i++) {
struct xattr_list *xattr = &xattr_list[i];
if((xattr->type & XATTR_VALUE_OOL) &&
(xattr->ool_value == SQUASHFS_INVALID_BLK)) {
struct squashfs_xattr_val val;
int size = sizeof(val) + xattr->vsize;
xp = get_xattr_space(size, &xattr->ool_value);
val.vsize = xattr->vsize;
SQUASHFS_SWAP_XATTR_VAL(&val, xp);
memcpy(xp + sizeof(val), xattr->value, xattr->vsize);
}
}
/*
* Create xattr list and add to file system xattr table
*/
get_xattr_space(0, &xattr_disk);
for(i = 0; i < xattrs; i++) {
struct xattr_list *xattr = &xattr_list[i];
struct squashfs_xattr_entry entry;
struct squashfs_xattr_val val;
xp = get_xattr_space(sizeof(entry) + xattr->size, NULL);
entry.type = xattr->type;
entry.size = xattr->size;
SQUASHFS_SWAP_XATTR_ENTRY(&entry, xp);
memcpy(xp + sizeof(entry), xattr->name, xattr->size);
if(xattr->type & XATTR_VALUE_OOL) {
int size = sizeof(val) + XATTR_VALUE_OOL_SIZE;
xp = get_xattr_space(size, NULL);
val.vsize = XATTR_VALUE_OOL_SIZE;
SQUASHFS_SWAP_XATTR_VAL(&val, xp);
SQUASHFS_SWAP_LONG_LONGS(&xattr->ool_value, xp +
sizeof(val), 1);
} else {
int size = sizeof(val) + xattr->vsize;
xp = get_xattr_space(size, &xattr->ool_value);
val.vsize = xattr->vsize;
SQUASHFS_SWAP_XATTR_VAL(&val, xp);
memcpy(xp + sizeof(val), xattr->value, xattr->vsize);
}
}
/*
* Add to xattr id lookup table
*/
return get_xattr_id(xattrs, xattr_list, xattr_disk, xattr_dupl);
}
