Hi Murali,
I found these functions from a previous post in this mail list [pvfs2
native api]. I will attach the code too. As you guess they use the
system interface to handle file operations.
I used the unix calls (fopen etc.) instead of the pvfs_* calls. It works
correctly.
Another thing I tried is to use fork() instead of pthreads. The pseudo
code is as follows:
main:
for 1 to n
{
fork ();
child {
PVFS_util_init_defaults ();
thread_func ();
PVFS_sys_finalize ();
}
}
parent {
waitforchilds;
}
thread_func:
filesize=1GB
offset= rand (0 - 1GB)
for i to m
{
PVFS_sys_read (100KB, offset);
}
this code works correctly.
When I used fork and unix calls I got approximately 3 thread_func calls
per second. However with fork and system interface I got approx. 400
thread_func calls per second. What may cause this difference? In the
first case I observed that the client machine and the server machine
contacts with the same port number. In other words client use the same
port number to connect the servers 3334th port. In the second case this
port number changed. I observed many different port numbers connecting
to pvfs2 servers port. [Raw sockets used to listen the network] May be
the reason is this.
On 11/29/05, *Murali Vilayannur* <[EMAIL PROTECTED]
<mailto:[EMAIL PROTECTED]>> wrote:
Hi Hamza,
> thread_func:
> filesize=1GB
> offset= rand (0 - 1GB)
> pvfs_open ("/pvfs2/1GBfile");
> for i to m
> {
> pvfs_lseek (offset);
> pvfs_read (100K);
> }
What do the functions pvfs_open, pvfs_lseek and pvfs_read do? It
would be
good to see the code or pseudo-code for those as well (just in case
there is something wrong there).
I presume that they somehow make use of the pvfs2 system interface to
offer the above functionality.
> When I executed the programme with n=1 it works correctly. However
> when n>1 I got the error:
> ===================================
> [14:50:19.904834] critical BMI failure (null callback)
> th: src/io/flow/flowproto-bmi-trove/flowproto-multiqueue.c:1701:
> bmi_to_mem_callback_fn: Assertion `q_item->parent->state !=
> FLOW_COMPLETE' failed.
> Aborted
> ===================================
> What may be the problem?
Could you trigger this thru the VFS as well?
Or only thru the system interface?
Thanks for the reports
Murali
>
> Thanks very much.
>
> --
> hamza
>
> _______________________________________________
> PVFS2-users mailing list
> [email protected]
<mailto:[email protected]>
> http://www.beowulf-underground.org/mailman/listinfo/pvfs2-users
>
>
------------------------------------------------------------------------
/*
* (C) 2004 Clemson University
*
* See COPYING in top-level directory.
*/
#include <errno.h>
#include <fcntl.h>
#include <limits.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/resource.h>
#include <sys/stat.h>
#include <time.h>
#include <unistd.h>
#include "pvfs2.h"
#include "pvfs2-request.h"
#include "pvfs2-native.h"
/* Define success and error return values */
#define PVFS_FD_SUCCESS 0
#define PVFS_FD_FAILURE -1
/* Define GNU's O_NOFOLLOW flag to be false if its not set */
#ifndef O_NOFOLLOW
#define O_NOFOLLOW 0
#endif
/* Define a max macro */
#define max(x, y) (((x) > (y)) ? (x) : (y))
/* PVFS Descriptor table entry */
typedef struct pvfs_descriptor_s
{
int id;
PVFS_fs_id fs_id;
PVFS_handle pvfs_handle;
int flags;
off64_t offset;
int is_in_use;
} pvfs_descriptor;
/* PVFS File Descriptor Offset */
static rlim_t pvfs_fd_offset = 0;
/* PVFS System initialization indicator */
static int pvfs_is_sys_initialized = 0;
/* PVFS Descriptor table */
static pvfs_descriptor *descriptor_table = 0;
/* PVFS Descriptor table size */
static size_t descriptor_table_size = 0;
/**
* Return a pointer to the pvfs_descriptor for the file descriptor or null
* if there is no entry for the given file descriptor
*/
static pvfs_descriptor* pvfs_find_descriptor( int fd )
{
pvfs_descriptor* pd = 0;
int i;
for (i = 0; i < descriptor_table_size; ++i)
{
if (fd == descriptor_table[i].id &&
descriptor_table[i].is_in_use) {
pd = &(descriptor_table[i]);
break;
}
}
return pd;
}
/**
* Allocate a new pvfs_descriptor, with a fd number greater than lower_bound
* If the table is not large enough to handle the lower_bound, return 0
*/
static pvfs_descriptor* pvfs_alloc_descriptor( int lower_bound )
{
const int TABLE_SIZE_INCREMENT = 10;
pvfs_descriptor* fd = 0;
int descriptor_idx = -1;
int i;
int index_lb;
/* Compute a lower bound for the pvfs table index from the file
descriptor lower bound */
index_lb = max(0, (long)lower_bound - (long)pvfs_fd_offset);
/* Find the first available descriptor greater than lower_bound */
for (i = index_lb; i < descriptor_table_size; ++i)
{
if (!descriptor_table[i].is_in_use)
{
descriptor_idx = i;
break;
}
}
/* If no available descriptor was found and the descriptor_table_size
is larger than the lower_bound, increase the number of available
descriptors */
if (0 <= descriptor_idx)
{
fd = &descriptor_table[descriptor_idx];
/* Set the file descriptor number */
fd->id = pvfs_fd_offset + descriptor_idx;
fd->is_in_use = 1;
}
else if (-1 == descriptor_idx &&
index_lb <= descriptor_table_size)
{
pvfs_descriptor *buf;
int new_table_size = descriptor_table_size + TABLE_SIZE_INCREMENT;
buf = malloc(new_table_size * sizeof(pvfs_descriptor));
if (0 != buf)
{
memcpy(buf, descriptor_table,
descriptor_table_size * sizeof(pvfs_descriptor));
memset(buf + descriptor_table_size, 0,
TABLE_SIZE_INCREMENT * sizeof(pvfs_descriptor));
free(descriptor_table);
descriptor_idx = descriptor_table_size;
descriptor_table = buf;
descriptor_table_size = new_table_size;
/* Set the file descriptor number */
fd = &descriptor_table[descriptor_idx];
fd->id = pvfs_fd_offset + descriptor_idx;
fd->is_in_use = 1;
}
}
return fd;
}
/**
* Split a pathname into a directory and a filename. If non-null
* is passed as the directory or filename, the field will be allocated and
* filled with the correct value
*/
static int pvfs_split_pathname( const char *path,
char **directory,
char **filename)
{
/* Split path into a directory and filename */
int path_length = strlen(path);
if ('/' == path[0])
{
int i;
for (i = path_length - 1; i >= 0; --i)
{
if ( '/' == path[i] )
{
/* parse the directory */
if (0 != directory)
{
*directory = malloc(i + 1);
if (0 != directory)
{
strncpy(*directory, path, i);
(*directory)[i] = '\0';
}
}
/* parse the filename */
if (0 != filename)
{
*filename = malloc(path_length - i + 1);
if (0 != filename)
{
strncpy(*filename, path + i + 1, path_length - i);
(*filename)[path_length - i] = '\0';
}
}
break;
}
}
}
else
{
fprintf(stderr, "Error: Not an absolute path: %s\n", path);
return PVFS_FD_FAILURE;
}
return PVFS_FD_SUCCESS;
}
/**
* Perform PVFS initialization tasks
*/
static int pvfs_sys_init()
{
const PVFS_util_tab* mnt;
struct rlimit rl;
int rc;
/* Initialize the file system with mount points */
PVFS_util_init_defaults();
/* Use the maximum allowed file descriptor to make sure PVFS file
descriptors are distinguishable by being greater than that max */
rc = getrlimit(RLIMIT_NOFILE, &rl);
pvfs_fd_offset = rl.rlim_max;
if (RLIM_INFINITY == pvfs_fd_offset)
{
pvfs_fd_offset = 0;
}
/* Mark the initialization complete */
pvfs_is_sys_initialized = 1;
return PVFS_FD_SUCCESS;
}
/**
* Find the PVFS handle to a file via the PVFS system interface
*/
static int pvfs_lookup_dir( const char *directory,
PVFS_object_ref *ref,
int *fs_id)
{
int rc;
char pvfs_path[256];
PVFS_fs_id lookup_fs_id;
/* Determine the fs_id and pvfs_path */
rc = PVFS_util_resolve(directory, &lookup_fs_id, pvfs_path, 256);
if (0 == rc)
{
PVFS_credentials credentials;
PVFS_sysresp_lookup resp_lookup;
credentials.uid = getuid();
credentials.gid = getgid();
rc = PVFS_sys_lookup(lookup_fs_id, pvfs_path,
&credentials, &resp_lookup,
PVFS2_LOOKUP_LINK_FOLLOW);
*ref = resp_lookup.ref;
}
else
{
fprintf(stderr, "Error: No matching fstab entry for %s\n", directory);
}
*fs_id = lookup_fs_id;
return rc;
}
/**
* Create a file via the PVFS system interface
*/
static int pvfs_lookup_file( const char *filename,
int fs_id,
PVFS_object_ref parent_ref,
int follow_links,
PVFS_object_ref *ref )
{
int rc;
PVFS_credentials credentials;
PVFS_sysresp_lookup resp_lookup;
/* Set credentials */
memset(&credentials, 0, sizeof(credentials));
credentials.uid = getuid();
credentials.gid = getgid();
/* Contact server */
rc = PVFS_sys_ref_lookup(fs_id,
(char*)filename,
parent_ref,
&credentials,
&resp_lookup,
follow_links);
*ref = resp_lookup.ref;
return rc;
}
/**
* Create a file via the PVFS system interface
*/
static int pvfs_create_file( const char *filename,
mode_t mode,
PVFS_object_ref parent_ref,
PVFS_object_ref *ref,
char *dist )
{
int rc;
mode_t mode_mask;
mode_t user_mode;
PVFS_sys_attr attributes;
PVFS_credentials credentials;
PVFS_sysresp_create resp_create;
PVFS_sys_dist *new_dist = 0;
/* Set attributes */
memset(&attributes, 0, sizeof(attributes));
attributes.owner = getuid();
attributes.group = getgid();
attributes.atime = time(NULL);
attributes.mtime = attributes.atime;
attributes.ctime = attributes.atime;
attributes.mask = PVFS_ATTR_SYS_ALL_SETABLE;
//attributes.dfile_count = 0;
//attributes.perms = 0;
/* Extract the users umask (and restore it to the original value) */
mode_mask = umask(0);
umask(mode_mask);
user_mode = mode & ~mode_mask;
/* Set file permissions */
if (user_mode & S_IXOTH)
{
attributes.perms |= PVFS_O_EXECUTE;
}
if (user_mode & S_IWOTH)
{
attributes.perms |= PVFS_O_WRITE;
}
if (user_mode & S_IROTH)
{
attributes.perms |= PVFS_O_READ;
}
if (user_mode & S_IXGRP)
{
attributes.perms |= PVFS_G_EXECUTE;
}
if (user_mode & S_IWGRP)
{
attributes.perms |= PVFS_G_WRITE;
}
if (user_mode & S_IRGRP)
{
attributes.perms |= PVFS_G_READ;
}
if (user_mode & S_IXUSR)
{
attributes.perms |= PVFS_U_EXECUTE;
}
if (user_mode & S_IWUSR)
{
attributes.perms |= PVFS_U_WRITE;
}
if (user_mode & S_IRUSR)
{
attributes.perms |= PVFS_U_READ;
}
/* Set credentials */
memset(&credentials, 0, sizeof(credentials));
credentials.uid = attributes.owner;
credentials.gid = attributes.group;
if (dist != NULL)
{
char *strips = (char *) malloc (sizeof (char) * 256);
strcpy (strips, dist);
new_dist = PVFS_sys_dist_lookup ("varstrip_dist");
rc = PVFS_sys_dist_setparam (new_dist, "strips", strips);
if (rc < 0)
{
PVFS_perror ("PVFS_sys_dist_setparam", rc);
exit (0);
}
}
/* Contact server */
rc = PVFS_sys_create((char*)filename,
parent_ref,
attributes,
&credentials,
new_dist,
&resp_create);
*ref = resp_create.ref;
return rc;
}
/* pvfs_close implementation*/
int pvfs_close( int fd )
{
pvfs_descriptor* pd;
pd = pvfs_find_descriptor(fd);
if (0 == pd)
{
errno = EBADF;
return PVFS_FD_FAILURE;
}
/* Reset the descriptor for reuse */
memset(pd, 0, sizeof(pd));
return PVFS_FD_SUCCESS;
}
/* pvfs_creat implementation*/
int pvfs_creat( const char *pathname, mode_t mode )
{
int flags;
/* call pvfs_open with correct flags */
flags = O_CREAT|O_WRONLY|O_TRUNC;
return pvfs_open(pathname, flags, NULL, mode);
}
/* pvfs_creat64 implementation*/
int pvfs_creat64( const char *pathname, mode_t mode )
{
int flags;
/* call pvfs_open64 with correct flags */
flags = O_CREAT|O_WRONLY|O_TRUNC|O_LARGEFILE;
return pvfs_open(pathname, flags, NULL, mode);
}
/* pvfs_fcntl implementation */
int pvfs_fcntl( int fd, int cmd, ... )
{
switch (cmd)
{
/* Copy the given file descriptor */
case F_DUPFD:
{
va_list ap;
int fd_lower_bound;
pvfs_descriptor* pd;
pvfs_descriptor* new_pd;
/* Retrieve the descriptor */
pd = pvfs_find_descriptor(fd);
if (0 == pd)
{
errno = EBADF;
return PVFS_FD_FAILURE;
}
/* Allocate a new descriptor */
va_start(ap, cmd);
fd_lower_bound = va_arg(ap, int);
va_end(ap);
new_pd = pvfs_alloc_descriptor(fd_lower_bound);
/* Copy the file descriptor attributes */
new_pd->fs_id = pd->fs_id;
new_pd->pvfs_handle = pd->pvfs_handle;
new_pd->flags = pd->flags;
new_pd->offset = pd->offset;
return new_pd->id;
}
/* Get the exec on close bit */
case F_GETFD:
{
/* PVFS close-on-exec must be 0 */
return 0;
}
/* Get the flags for this file */
case F_GETFL:
{
pvfs_descriptor* pd;
pd = pvfs_find_descriptor(fd);
if (0 == pd)
{
errno = EBADF;
return PVFS_FD_FAILURE;
}
return pd->flags;
}
/* Set the flags for this file */
case F_SETFL:
{
va_list ap;
int new_flags;
pvfs_descriptor* pd;
/* Retrieve the descriptor */
pd = pvfs_find_descriptor(fd);
if (0 == pd)
{
errno = EBADF;
return PVFS_FD_FAILURE;
}
/* Allocate a new descriptor */
va_start(ap, cmd);
new_flags = va_arg(ap, int);
va_end(ap);
pd->flags |= (new_flags & O_APPEND);
/* Only flag we allow is the append flag */
if (pd->flags & O_APPEND)
{
pvfs_lseek64(pd->id, 0, SEEK_END);
}
return PVFS_FD_SUCCESS;
}
/* Return an error for locking commands */
case F_GETLK:
case F_SETLK:
case F_SETLKW:
{
errno = ENOLCK;
return PVFS_FD_FAILURE;
}
/* Return an error for notification signal commands */
case F_GETOWN:
case F_SETOWN:
{
errno = EINVAL;
return PVFS_FD_FAILURE;
}
default:
{
errno = EBADF;
return PVFS_FD_FAILURE;
}
}
return PVFS_FD_SUCCESS;
}
/* pvfs_lseek implementation */
off_t pvfs_lseek(int fd, off_t offset, int whence)
{
return pvfs_lseek64(fd, offset, whence);
}
/* pvfs_lseek implementation */
off64_t pvfs_lseek64(int fd, off64_t offset, int whence)
{
pvfs_descriptor* pd;
/* Find the descriptor */
pd = pvfs_find_descriptor(fd);
if (0 == pd)
{
errno = EBADF;
return PVFS_FD_FAILURE;
}
switch(whence)
{
case SEEK_SET:
{
pd->offset = offset;
break;
}
case SEEK_CUR:
{
pd->offset += offset;
break;
}
case SEEK_END:
{
PVFS_object_ref file_ref;
PVFS_credentials creds;
PVFS_sysresp_getattr attributes_resp;
/* Construct pinode_reference and from descriptor*/
memset(&file_ref, 0, sizeof(file_ref));
file_ref.handle = pd->pvfs_handle;
file_ref.fs_id = pd->fs_id;
/* Construct credentials*/
memset(&creds, 0, sizeof(creds));
creds.uid = getuid();
creds.gid = getgid();
/* Get the file's size in bytes as the ending offset */
PVFS_sys_getattr(file_ref, PVFS_ATTR_SYS_SIZE,
&creds, &attributes_resp);
pd->offset = attributes_resp.attr.size + offset;
break;
}
default:
{
errno = EINVAL;
return PVFS_FD_FAILURE;
}
}
return pd->offset;
}
/* pvfs_open implementation*/
int pvfs_open( const char *pathname, int flag, char *dist, ... )
{
int rc;
int follow_link;
int descriptor;
char *directory;
char *filename;
PVFS_object_ref file_ref;
/* Initialize the system interface for this process */
if (!pvfs_is_sys_initialized)
{
rc = pvfs_sys_init();
}
/* Split the path into a directory and file */
rc = pvfs_split_pathname(pathname, &directory, &filename);
if (0 != rc && (0 == directory || 0 == filename))
{
errno = ENOMEM;
return PVFS_FD_FAILURE;
}
else if (0 != rc)
{
fprintf(stderr, "Error: %s is not a legal PVFS path.\n", pathname);
errno = EACCES;
return PVFS_FD_FAILURE;
}
/* Check the flag to determine if links are followed */
if (flag & O_NOFOLLOW)
{
follow_link = PVFS2_LOOKUP_LINK_NO_FOLLOW;
}
else
{
follow_link = PVFS2_LOOKUP_LINK_FOLLOW;
}
/* Check flag to determine creation behavior */
if ( (flag & O_CREAT) && (flag & O_EXCL))
{
PVFS_object_ref parent_ref;
int fs_id = 0;
rc = pvfs_lookup_dir(pathname, &parent_ref, &fs_id);
if (0 == rc)
{
mode_t mode = 0;
//va_list ap;
//va_start(ap, flag);
//mode = va_arg(ap, mode_t);
//va_end(ap);
rc = pvfs_create_file(filename, mode, parent_ref, &file_ref, dist);
}
else
{
errno = ENOTDIR;
return PVFS_FD_FAILURE;
}
}
else if (flag & O_CREAT)
{
PVFS_object_ref parent_ref;
int fs_id = 0;
rc = pvfs_lookup_dir(directory, &parent_ref, &fs_id);
if (0 == rc)
{
rc = pvfs_lookup_file(filename, fs_id, parent_ref,
follow_link, &file_ref);
}
if (0 != rc)
{
mode_t mode = 0;
va_list ap;
va_start(ap, dist);
mode = va_arg(ap, mode_t);
va_end(ap);
rc = pvfs_create_file(filename, mode, parent_ref, &file_ref, dist);
}
}
else
{
PVFS_object_ref parent_ref;
int fs_id = 0;
rc = pvfs_lookup_dir(directory, &parent_ref, &fs_id);
if (0 == rc)
{
rc = pvfs_lookup_file(filename, fs_id, parent_ref,
follow_link, &file_ref);
}
else
{
errno = ENOTDIR;
return PVFS_FD_FAILURE;
}
}
/* Free directory and filename memory */
free(directory);
free(filename);
/* Translate the pvfs reference into a file descriptor */
if (0 == rc)
{
pvfs_descriptor* pd;
pd = pvfs_alloc_descriptor(0);
if (0 != pd)
{
/* Set the file information */
pd->fs_id = file_ref.fs_id;
pd->pvfs_handle = file_ref.handle;
pd->flags = flag;
pd->is_in_use = 1;
/* Retrieve the descriptor number */
descriptor = pd->id;
}
else
{
errno = ENOMEM;
return PVFS_FD_FAILURE;
}
}
else
{
/* Inidicate that an error occurred */
errno = EACCES;
return PVFS_FD_FAILURE;
}
/* Truncate the file if neccesary */
if (flag & O_TRUNC)
{
PVFS_credentials creds;
memset(&creds, 0, sizeof(PVFS_credentials));
creds.uid = getuid();
creds.gid = getgid();
PVFS_sys_truncate(file_ref, 0, &creds);
}
/* Move to the end of file if necessary */
if (flag & O_APPEND)
{
pvfs_lseek64(descriptor, 0, SEEK_END);
}
return descriptor;
}
/* pvfs_open64 implementation*/
int pvfs_open64( const char *pathname, int flag, ... )
{
int rc;
flag |= O_LARGEFILE;
if (O_CREAT & flag)
{
va_list ap;
mode_t mode = 0;
va_start(ap, flag);
mode = va_arg(ap, mode_t);
va_end(ap);
rc = pvfs_open(pathname, flag, NULL, mode);
}
else
{
rc = pvfs_open(pathname, flag, NULL);
}
if (0 != rc)
{
return PVFS_FD_FAILURE;
}
return PVFS_FD_SUCCESS;
}
/* pvfs_read implementation */
ssize_t pvfs_read( int fd, void *buf, PVFS_Request data_type, size_t count )
{
int rc;
pvfs_descriptor* pd;
PVFS_object_ref file_ref;
PVFS_Request file_req;
PVFS_Request memory_req;
PVFS_credentials creds;
PVFS_offset offset;
PVFS_sysresp_io read_resp;
memset(&file_ref, 0, sizeof(file_ref));
memset(&file_req, 0, sizeof(file_req));
memset(&memory_req, 0, sizeof(memory_req));
memset(&creds, 0, sizeof(creds));
/* Find the descriptor */
pd = pvfs_find_descriptor(fd);
if (0 == pd)
{
errno = EBADF;
return PVFS_FD_FAILURE;
}
/* Ensure descriptor is available for read access */
if (O_WRONLY & pd->flags)
{
errno = EBADF;
return PVFS_FD_FAILURE;
}
/* Construct pinode_reference and offset from descriptor*/
file_ref.handle = pd->pvfs_handle;
file_ref.fs_id = pd->fs_id;
offset = pd->offset;
file_req = PVFS_BYTE;
rc = PVFS_Request_contiguous(count, data_type, &memory_req);
creds.uid = getuid();
creds.gid = getgid();
if (0 == rc)
{
rc = PVFS_sys_read(file_ref, data_type, offset,
buf, memory_req, &creds, &read_resp);
}
else
{
errno = EINVAL;
return PVFS_FD_FAILURE;
}
if (0 != rc)
{
errno = EIO;
return PVFS_FD_FAILURE;
}
pd->offset += count;
return count;
}
/* pvfs_unlink implementation */
int pvfs_unlink( const char *pathname )
{
int rc = 0;
char *directory = 0;
char *filename = 0;
PVFS_object_ref file_ref;
/* Initialize the system interface for this process */
if (!pvfs_is_sys_initialized)
{
rc = pvfs_sys_init();
}
if (0 == rc)
{
rc = pvfs_split_pathname(pathname, &directory, &filename);
}
if (0 == rc)
{
int fs_id;
rc = pvfs_lookup_dir(directory, &file_ref, &fs_id);
}
if (0 == rc)
{
PVFS_credentials credentials;
credentials.uid = getuid();
credentials.gid = getgid();
rc = PVFS_sys_remove(filename, file_ref, &credentials);
}
free(directory);
free(filename);
if (0 != rc)
{
return PVFS_FD_FAILURE;
}
return PVFS_FD_SUCCESS;
}
/*pvfs_write implementation */
ssize_t pvfs_write( int fd, const void *buf, PVFS_Request data_type, size_t
count )
{
int rc;
pvfs_descriptor* pd;
PVFS_object_ref file_ref;
PVFS_Request file_req;
PVFS_Request memory_req;
PVFS_credentials creds;
PVFS_offset offset;
PVFS_sysresp_io write_resp;
memset(&file_ref, 0, sizeof(file_ref));
memset(&file_req, 0, sizeof(file_req));
memset(&memory_req, 0, sizeof(memory_req));
memset(&creds, 0, sizeof(creds));
/* Find the descriptor */
pd = pvfs_find_descriptor(fd);
if (0 == pd)
{
errno = EBADF;
return PVFS_FD_FAILURE;
}
/* Ensure descriptor is available for read access */
if (O_RDONLY == (pd->flags & O_ACCMODE))
{
errno = EBADF;
return PVFS_FD_FAILURE;
}
/* Construct pinode_reference and offset from descriptor*/
file_ref.handle = pd->pvfs_handle;
file_ref.fs_id = pd->fs_id;
file_req = PVFS_BYTE;
rc = PVFS_Request_contiguous(count, data_type, &memory_req);
offset = 0;
creds.uid = getuid();
creds.gid = getgid();
if (0 == rc)
{
rc = PVFS_sys_write(file_ref, data_type, pd->offset,
(void*)buf, memory_req, &creds, &write_resp);
}
else
{
errno = EINVAL;
return PVFS_FD_FAILURE;
}
if (0 != rc)
{
errno = EIO;
return PVFS_FD_FAILURE;
}
pd->offset += count;
return count;
}
int pvfs_eof (int fd)
{
int rc;
PVFS_sysresp_getattr attr_resp;
pvfs_descriptor* pd;
PVFS_object_ref file_ref;
PVFS_credentials creds;
PVFS_offset offset;
memset (&file_ref, 0, sizeof(file_ref));
memset (&creds, 0, sizeof(creds));
pd = pvfs_find_descriptor (fd);
if (pd == 0)
{
//puts ("olmadiii");
errno = EBADF;
return PVFS_FD_FAILURE;
}
file_ref.handle = pd->pvfs_handle;
file_ref.fs_id = pd->fs_id;
creds.uid = getuid ();
creds.gid = getgid ();
offset = pd->offset;
rc = PVFS_sys_getattr (file_ref, PVFS_ATTR_SYS_SIZE, &creds, &attr_resp);
//if (rc <= 0) perror ("asad");
printf ("%lu %lu\n", offset, (int64_t)attr_resp.attr.size);
if (offset > attr_resp.attr.size) {
//perror ("oro");
return 1;
}
return 0;
}
void pvfs_get (int fd, PVFS_offset *offset, PVFS_size *size)
{
int rc;
PVFS_sysresp_getattr attr_resp;
pvfs_descriptor* pd;
PVFS_object_ref file_ref;
PVFS_credentials creds;
memset (&file_ref, 0, sizeof(file_ref));
memset (&creds, 0, sizeof(creds));
pd = pvfs_find_descriptor (fd);
if (pd == 0)
{
//puts ("olmadiii");
errno = EBADF;
}
file_ref.handle = pd->pvfs_handle;
file_ref.fs_id = pd->fs_id;
creds.uid = getuid ();
creds.gid = getgid ();
*offset = pd->offset;
rc = PVFS_sys_getattr (file_ref, PVFS_ATTR_SYS_SIZE, &creds, &attr_resp);
*size = attr_resp.attr.size;
}
/*
* Local variables:
* c-indent-level: 4g
* c-basic-offset: 4
* End:
*
* vim: ts=8 sts=4 sw=4 noexpandtab
*/
------------------------------------------------------------------------
_______________________________________________
PVFS2-users mailing list
[email protected]
http://www.beowulf-underground.org/mailman/listinfo/pvfs2-users
