static void initial_cache_load(struct nfs_client *client)
{
err_t r;
cache_loading_phase = true;
cache_lookups_started = 0;
cache_loaded_counter = 0;
cache_loading_probs = 0;
//my_nfs_client
r = nfs_readdir(client, nfs_root_fh, NFS_READDIR_COOKIE,
NFS_READDIR_COOKIEVERF, readdir_callback, NULL);
assert(r == ERR_OK);
}
/* NFS Callback for NFS_getdirent */
static
void
getdirent_cb(uintptr_t token, int status, int num_entries, struct nfs_filename *filenames,
int next_cookie) {
dprintf(1, "*** nfsfs_dirent_cb: %d, %d, %d, %d\n", token, status, num_entries, next_cookie);
NFS_DirRequest *rq = (NFS_DirRequest *) get_request(token);
if (rq == NULL) {
dprintf(0, "!!! nfsfs: Corrupt dirent callback, no matching token: %d\n", token);
return;
}
Process *p = process_lookup(rq->p.pid);
if (status != NFS_OK) {
syscall_reply(process_get_tid(p), status_nfs2vfs(status));
remove_request((NFS_BaseRequest *) rq);
return;
}
// got it
if (rq->cpos + num_entries >= rq->pos + 1) {
dprintf(2, "found file, getting now\n");
int status = SOS_VFS_ERROR;
struct nfs_filename *nfile = &filenames[rq->pos - rq->cpos];
if (nfile->size + 1 <= rq->nbyte) {
memcpy(rq->buf, nfile->file, nfile->size);
rq->buf[nfile->size] = '\0';
status = nfile->size;
} else {
dprintf(0, "!!! nfs_getdirent_cb: Filename too big for given buffer! (%d) (%d)\n",
nfile->size, rq->nbyte);
status = SOS_VFS_NOMEM;
}
syscall_reply(process_get_tid(p), status);
remove_request((NFS_BaseRequest *) rq);
}
// need later directory entry
else if (next_cookie > 0) {
dprintf(2, "Need more dir entries to get file\n");
rq->cpos += num_entries;
nfs_readdir(&nfs_mnt, next_cookie, IO_MAX_BUFFER, getdirent_cb, rq->p.token);
}
// error case, just return SOS_VFS_OK to say nothing read, its not an error just eof
else {
dprintf(2, "nfsfs_getdirent: didnt find file (%d)\n", rq->pos);
syscall_reply(process_get_tid(p), SOS_VFS_EOF);
remove_request((NFS_BaseRequest *) rq);
}
}
static int
DirRead(access_t *p_access, input_item_node_t *p_node)
{
access_sys_t *p_sys = p_access->p_sys;
struct nfsdirent *p_nfsdirent;
int i_ret = VLC_SUCCESS;
assert(p_sys->p_nfsdir);
struct access_fsdir fsdir;
access_fsdir_init(&fsdir, p_access, p_node);
while (i_ret == VLC_SUCCESS
&& (p_nfsdirent = nfs_readdir(p_sys->p_nfs, p_sys->p_nfsdir)) != NULL)
{
char *psz_name_encoded = vlc_uri_encode(p_nfsdirent->name);
if (psz_name_encoded == NULL)
{
i_ret = VLC_ENOMEM;
break;
}
char *psz_url = NfsGetUrl(&p_sys->encoded_url, psz_name_encoded);
free(psz_name_encoded);
if (psz_url == NULL)
{
i_ret = VLC_ENOMEM;
break;
}
int i_type;
switch (p_nfsdirent->type)
{
case NF3REG:
i_type = ITEM_TYPE_FILE;
break;
case NF3DIR:
i_type = ITEM_TYPE_DIRECTORY;
break;
default:
i_type = ITEM_TYPE_UNKNOWN;
}
i_ret = access_fsdir_additem(&fsdir, psz_url, p_nfsdirent->name,
i_type, ITEM_NET);
free(psz_url);
}
access_fsdir_finish(&fsdir, i_ret == VLC_SUCCESS);
return i_ret;
}
static int fuse_nfs_readdir(const char *path, void *buf, fuse_fill_dir_t filler,
off_t offset, struct fuse_file_info *fi)
{
struct nfsdir *nfsdir;
struct nfsdirent *nfsdirent;
int ret = 0;
ret = nfs_opendir(nfs, path, &nfsdir);
if (ret < 0) {
return ret;
}
while ((nfsdirent = nfs_readdir(nfs, nfsdir)) != NULL) {
filler(buf, nfsdirent->name, NULL, 0);
}
return ret;
}
static void readdir_callback(void *arg, struct nfs_client *client,
READDIR3res *result)
{
READDIR3resok *resok = &result->READDIR3res_u.resok;
struct http_cache_entry *ce;
entry3 *last = NULL;
err_t r;
DEBUGPRINT ("readdir_callback came in\n");
assert(result != NULL && result->status == NFS3_OK);
// FIXME: start here the measurement of file loading time
last_ts = rdtsc();
// lwip_benchmark_control(1, BMS_START_REQUEST, 0, 0);
// initiate a lookup for every entry
for (entry3 *e = resok->reply.entries; e != NULL; e = e->nextentry) {
++cache_lookups_started;
printf("Loading the file %s\n", e->name);
ce = find_cacheline(e->name);
ce->loading = 1;
async_load_cache_entry(ce);
e->name = NULL; // prevent freeing by XDR
last = e;
}
/* more in the directory: repeat call */
if (!resok->reply.eof) {
assert(last != NULL);
r = nfs_readdir(client, nfs_root_fh, last->cookie,
resok->cookieverf, readdir_callback, NULL);
assert(r == ERR_OK);
} else {
readdir_complete = true;
handle_cache_load_done();
}
// free arguments
xdr_READDIR3res(&xdr_free, result);
}
static void workspace_nfs_readdirplus_simple(fuse_req_t req, size_t size, off_t offset, struct workspace_dh_struct *dh)
{
struct resource_struct *resource=dh->object->resource;
struct net_nfs_export_struct *nfs_export=(struct net_nfs_export_struct *) resource->data;
struct nfs_context *nfs_ctx=(struct nfs_context *) nfs_export->data;
unsigned int error=0;
char *buff=NULL;
size_t pos=0;
size_t dirent_size;
struct fuse_entry_param e;
char *name=NULL;
struct directory_struct *directory=dh->directory;
struct nfsdir *dir=(struct nfsdir *) dh->handle.data;
struct entry_struct *entry, *result;
struct inode_struct *inode;
struct name_struct xname={NULL, 0, 0};
memset(&e, 0, sizeof(struct fuse_entry_param));
e.generation = 1;
e.attr_timeout = fs_options.attr_timeout;
e.entry_timeout = fs_options.entry_timeout;
e.attr.st_blksize=_DEFAULT_BLOCKSIZE;
buff=malloc(size);
if (! buff) {
error=ENOMEM;
goto error;
}
if (lock_directory(directory, _DIRECTORY_LOCK_EXCL)==-1) {
free(buff);
buff=NULL;
error=EAGAIN;
goto error;
}
while (pos<size) {
if (offset==0) {
inode=dh->parent->inode;
/* the . entry */
e.ino = inode->ino;
e.attr.st_ino = e.ino;
e.attr.st_mode = inode->mode;
e.attr.st_nlink = inode->nlink;
e.attr.st_uid = inode->uid;
e.attr.st_gid = inode->gid;
e.attr.st_rdev = inode->rdev;
e.attr.st_size = inode->size;
e.attr.st_atim.tv_sec = 0;
e.attr.st_atim.tv_nsec = 0;
e.attr.st_mtim.tv_sec = inode->mtim.tv_sec;
e.attr.st_mtim.tv_nsec = inode->mtim.tv_nsec;
e.attr.st_ctim.tv_sec = inode->ctim.tv_sec;
e.attr.st_ctim.tv_nsec = inode->ctim.tv_nsec;
name = (char *) dotname;
inode->nlookup++;
} else if (offset==1) {
/* the .. entry */
if ( ! dh->parent->parent ) {
inode=dh->parent->inode;
} else {
inode=dh->parent->parent->inode;
}
e.ino = inode->ino;
e.attr.st_ino = e.ino;
e.attr.st_mode = inode->mode;
e.attr.st_nlink = inode->nlink;
e.attr.st_uid = inode->uid;
e.attr.st_gid = inode->gid;
e.attr.st_rdev = inode->rdev;
e.attr.st_size = inode->size;
e.attr.st_atim.tv_sec = 0;
e.attr.st_atim.tv_nsec = 0;
e.attr.st_mtim.tv_sec = inode->mtim.tv_sec;
e.attr.st_mtim.tv_nsec = inode->mtim.tv_nsec;
e.attr.st_ctim.tv_sec = inode->ctim.tv_sec;
e.attr.st_ctim.tv_nsec = inode->ctim.tv_nsec;
name = (char *) dotdotname;
inode->nlookup++;
} else {
if (! dh->entry) {
struct nfsdirent *de;
readdir:
pthread_mutex_lock(&nfs_export->mutex);
de=nfs_readdir(nfs_ctx, dir);
pthread_mutex_unlock(&nfs_export->mutex);
if (de) {
if (strcmp(de->name, ".")==0 || strcmp(de->name, "..")==0) continue;
xname.name=de->name;
xname.len=strlen(xname.name);
calculate_nameindex(&xname);
} else {
dh->mode |= _WORKSPACE_READDIR_MODE_FINISH;
break;
}
error=0;
entry=create_entry(dh->parent, &xname);
inode=create_inode();
if (entry && inode) {
result=insert_entry_batch(directory, entry, &error, 0);
if (result==entry) {
struct workspace_object_struct *export_object=NULL;
inode->mode = translate_libnfs_type(de->type);
inode->mode |= de->mode;
add_inode_hashtable(inode, increase_inodes_workspace, (void *) dh->object->workspace_mount);
inode->alias=entry;
entry->inode=inode;
memcpy(&entry->synctime, &dh->synctime, sizeof(struct timespec));
inode->nlookup++;
inode->nlink=2;
inode->uid=0; /* ?? */
inode->gid=0; /* ?? */
inode->size=de->size;
/* struct timeval convert to timespec */
inode->mtim.tv_sec=de->mtime.tv_sec;
inode->mtim.tv_nsec=1000 * de->mtime.tv_usec;
inode->ctim.tv_sec=de->ctime.tv_sec;
inode->ctim.tv_nsec=1000 * de->ctime.tv_usec;
adjust_pathmax(dh->pathinfo.len + 1 + xname.len);
} else {
if (error==EEXIST) {
destroy_entry(entry);
entry=result;
memcpy(&entry->synctime, &dh->synctime, sizeof(struct timespec));
free(inode);
inode=entry->inode;
} else {
free(buff);
destroy_entry(entry);
free(inode);
goto error;
}
}
} else {
if (entry) {
destroy_entry(entry);
entry=NULL;
}
if (inode) {
free(inode);
inode=NULL;
}
error=ENOMEM;
free(buff);
goto error;
}
name=entry->name.name;
dh->entry=entry;
} else {
entry=dh->entry;
inode=entry->inode;
name=entry->name.name;
}
e.ino = inode->ino;
e.attr.st_ino = e.ino;
e.attr.st_mode = inode->mode;
e.attr.st_nlink = inode->nlink;
e.attr.st_uid = inode->uid;
e.attr.st_gid = inode->gid;
e.attr.st_rdev = inode->rdev;
e.attr.st_size = inode->size;
e.attr.st_atim.tv_sec = 0;
e.attr.st_atim.tv_nsec = 0;
e.attr.st_mtim.tv_sec = inode->mtim.tv_sec;
e.attr.st_mtim.tv_nsec = inode->mtim.tv_nsec;
e.attr.st_ctim.tv_sec = inode->ctim.tv_sec;
e.attr.st_ctim.tv_nsec = inode->ctim.tv_nsec;
if (inode->size % e.attr.st_blksize == 0) {
e.attr.st_blocks=inode->size / e.attr.st_blksize;
} else {
e.attr.st_blocks=1 + inode->size / e.attr.st_blksize;
}
}
dirent_size=fuse_add_direntry_plus(req, buff+pos, size-pos, name, &e, offset+1);
if (pos + dirent_size > size) {
dh->offset=offset;
break;
}
/* increase counter and clear the various fields */
dh->entry=NULL; /* forget current entry to force readdir */
offset++;
pos += dirent_size;
}
unlock_directory(directory, _DIRECTORY_LOCK_EXCL);
fuse_reply_buf(req, buff, pos);
free(buff);
buff=NULL;
return;
error:
fuse_reply_err(req, error);
}
static void workspace_nfs_readdir_simple(fuse_req_t req, size_t size, off_t offset, struct workspace_dh_struct *dh)
{
struct resource_struct *resource=dh->object->resource;
struct net_nfs_export_struct *nfs_export=(struct net_nfs_export_struct *) resource->data;
struct nfs_context *nfs_ctx=(struct nfs_context *) nfs_export->data;
unsigned int error=0;
char *buff=NULL;
size_t pos=0;
size_t dirent_size;
char *name=NULL;
struct directory_struct *directory=dh->directory;
struct nfsdir *dir=(struct nfsdir *) dh->handle.data;
struct entry_struct *entry, *result;
struct inode_struct *inode;
struct name_struct xname={NULL, 0, 0};
struct stat st;
memset(&st, 0, sizeof(struct stat));
buff=malloc(size);
if (! buff) {
error=ENOMEM;
goto error;
}
if (lock_directory(directory, _DIRECTORY_LOCK_EXCL)==-1) {
free(buff);
buff=NULL;
error=EAGAIN;
goto error;
}
while (pos<size) {
if (offset==0) {
inode=dh->parent->inode;
/* the . entry */
st.st_ino = inode->ino;
st.st_mode = S_IFDIR;
name = (char *) dotname;
} else if (offset==1) {
/* the .. entry */
if (! dh->parent->parent ) {
inode=dh->parent->inode;
st.st_ino = inode->ino;
} else {
struct entry_struct *parent=dh->parent->parent;
inode=parent->inode;
st.st_ino=inode->ino;
}
st.st_mode = S_IFDIR;
name = (char *) dotdotname;
} else {
if (! dh->entry) {
struct nfsdirent *de;
readdir:
pthread_mutex_lock(&nfs_export->mutex);
de=nfs_readdir(nfs_ctx, dir);
pthread_mutex_unlock(&nfs_export->mutex);
if (de) {
if (strcmp(de->name, ".")==0 || strcmp(de->name, "..")==0) continue;
xname.name=de->name;
xname.len=strlen(xname.name);
calculate_nameindex(&xname);
} else {
dh->mode |= _WORKSPACE_READDIR_MODE_FINISH;
break;
}
error=0;
entry=create_entry(dh->parent, &xname);
inode=create_inode();
if (entry && inode) {
result=insert_entry_batch(directory, entry, &error, 0);
if (result==entry) {
struct workspace_object_struct *export_object=NULL;
inode->mode = translate_libnfs_type(de->type);
inode->mode |= de->mode;
add_inode_hashtable(inode, increase_inodes_workspace, (void *) dh->object->workspace_mount);
inode->alias=entry;
entry->inode=inode;
adjust_pathmax(dh->pathinfo.len + 1 + xname.len);
} else {
if (error==EEXIST) {
destroy_entry(entry);
entry=result;
free(inode);
inode=entry->inode;
} else {
free(buff);
destroy_entry(entry);
free(inode);
goto error;
}
}
st.st_mode=entry->inode->mode;
st.st_ino=entry->inode->ino;
name=entry->name.name;
} else {
if (entry) {
destroy_entry(entry);
entry=NULL;
}
if (inode) {
free(inode);
inode=NULL;
}
error=ENOMEM;
free(buff);
goto error;
}
dh->entry=entry;
} else {
st.st_ino=dh->entry->inode->ino;
st.st_mode=dh->entry->inode->mode;
name=dh->entry->name.name;
}
}
dirent_size=fuse_add_direntry(req, buff+pos, size-pos, name, &st, offset+1);
if (pos + dirent_size > size) {
dh->offset = offset + 1;
break;
}
/* increase counter and clear the various fields */
dh->entry=NULL; /* forget current entry to force readdir */
offset++;
pos += dirent_size;
}
unlock_directory(directory, _DIRECTORY_LOCK_EXCL);
fuse_reply_buf(req, buff, pos);
free(buff);
buff=NULL;
return;
error:
fuse_reply_err(req, error);
}
/* Run a getdirent request */
static
void
rq_dir_run(NFS_DirRequest *rq) {
dprintf(2, "run NFS getdirent request\n");
nfs_readdir(&nfs_mnt, 0, IO_MAX_BUFFER, getdirent_cb, rq->p.token);
}
