lib/vfs/vfs_nfs.c

75 typedef void resolve_cont_fn(void *st, errval_t err, struct nfs_fh3 fh,
205     struct nfs_file_io_handle    *fh;
217         pfh->fh->status = result->status;
228     memcpy((char *)pfh->fh->data + pfh->chunk_start, res->data.data_val,
230     pfh->fh->size_complete += res->data.data_len;
236         if (pfh->fh->size > newsize) {
237             pfh->fh->size = newsize;
246         errval_t e = nfs_read(client, pfh->fh->handle,
247                            pfh->fh->offset + pfh->chunk_start,
254     assert(pfh->fh->size >= pfh->fh->size_complete);
257     if (pfh->fh->size == pfh->fh->size_complete) {
261     else if (pfh->fh->chunk_pos < pfh->fh->size) {
262         pfh->chunk_start =  pfh->fh->chunk_pos;
263         pfh->chunk_size = MIN(MAX_NFS_READ_BYTES, pfh->fh->size - pfh->chunk_start);
264         pfh->fh->chunk_pos += pfh->chunk_size;
265         pfh->fh->chunks_in_progress++;
266         errval_t r = nfs_read(client, pfh->fh->handle,
267                            pfh->fh->offset + pfh->chunk_start,
275     pfh->fh->chunks_in_progress--;
278     if (pfh->fh->chunks_in_progress == 0) {
293         pfh->fh->status = result->status;
298         pfh->fh->back_fh->inflight--;
299         assert(pfh->fh->back_fh->inflight >= 0);
300         free(pfh->fh);
310     pfh->fh->size_complete += res->count;
312     assert(pfh->fh->size >= pfh->fh->size_complete);
315     if (pfh->fh->size == pfh->fh->size_complete) {
317         pfh->fh->back_fh->inflight--;
318         assert(pfh->fh->back_fh->inflight >= 0);
319         free(pfh->fh);
326     else if (pfh->fh->chunk_pos < pfh->fh->size) {
327         pfh->chunk_start = pfh->fh->chunk_pos;
328         pfh->chunk_size = MIN(MAX_NFS_WRITE_BYTES, pfh->fh->size - pfh->chunk_start);
329         pfh->fh->chunk_pos += pfh->chunk_size;
330         errval_t r = nfs_write(client, pfh->fh->handle,
331                             pfh->fh->offset + pfh->chunk_start,
332                             (char *)pfh->fh->data + pfh->chunk_start, pfh->chunk_size,
344 static void open_resolve_cont(void *st, errval_t err, struct nfs_fh3 fh,
351         nfs_copyfh(&h->fh, fh);
369     h->fh = NULL_NFS_FH;
383     if (h->fh.data_len > 0 && h->type != NF3DIR) {
386     } else if (h->fh.data_len > 0 && h->type == NF3DIR) {
407         nfs_copyfh(&h->fh, res->obj.post_op_fh3_u.handle);
418 static void create_resolve_cont(void *st, errval_t err, struct nfs_fh3 fh,
433     errval_t r = nfs_create(h->nfs->client, fh, h->st, false, nulattr,
463     h->fh = NULL_NFS_FH;
465     h->fh.data_len = 0;
481     if (h->fh.data_len > 0) {
501     h->fh = NULL_NFS_FH;
513         nfs_copyfh(&h->fh, nfs->rootfh);
524     if (h->fh.data_len > 0 && h->type == NF3DIR) {
544     struct nfs_file_io_handle fh;
545     memset(&fh, 0, sizeof(struct nfs_file_io_handle));
547     fh.data = buffer;
548     fh.size = bytes;
549     fh.offset = h->u.file.pos;
550     fh.status = NFS3_OK;
551     fh.handle = h->fh;
552     fh.chunks_in_progress = 0;
558     while (fh.chunk_pos < fh.size && chunks < MAX_NFS_READ_CHUNKS) {
559 //    while (fh.chunk_pos < fh.size) {
563         pfh->fh = &fh;
564         pfh->chunk_start = fh.chunk_pos;
565         pfh->chunk_size = MIN(MAX_NFS_READ_BYTES, fh.size - pfh->chunk_start);
566         fh.chunk_pos += pfh->chunk_size;
568         fh.chunks_in_progress++;
569         e = nfs_read(nfs->client, fh.handle, fh.offset + pfh->chunk_start,
575                     chunks, (int)fh.chunks_in_progress);
576             fh.chunk_pos -= pfh->chunk_size;
591     if (fh.status != NFS3_OK) {
592   //      printf("read:vfs_nfs: fh.status issue %u\n", fh.status);
593         return nfsstat_to_errval(fh.status);
596     assert(fh.size <= bytes);
597     h->u.file.pos += fh.size;
598     *bytes_read = fh.size;
600     if (fh.size == 0) {
604                 fh.size, bytes, MAX_NFS_READ_CHUNKS);
640     struct nfs_file_io_handle *fh = &the_fh;
642     struct nfs_file_io_handle *fh = malloc(sizeof(struct nfs_file_io_handle));
643     assert(fh != NULL);
645     memset(fh, 0, sizeof(struct nfs_file_io_handle));
648     fh->data = malloc(bytes);
649     assert(fh->data != NULL);
650     memcpy(fh->data, buffer, bytes);
653     fh->data = (void *)buffer;
655     fh->size = bytes;
656     fh->offset = h->u.file.pos;
657     fh->status = NFS3_OK;
658     fh->handle = h->fh;
659     fh->back_fh = h;
668         pfh->fh = fh;
669         pfh->fh->chunks_in_progress = 0;
670         pfh->chunk_start = fh->chunk_pos;
671         pfh->chunk_size = MIN(MAX_NFS_WRITE_BYTES, fh->size - pfh->chunk_start);
672         fh->chunk_pos += pfh->chunk_size;
673         e = nfs_write(nfs->client, fh->handle, fh->offset + pfh->chunk_start,
674                       (char *)fh->data + pfh->chunk_start, pfh->chunk_size,
678     } while (fh->chunk_pos < fh->size && chunks < MAX_NFS_WRITE_CHUNKS);
687     if (fh->status != NFS3_OK && fh->status != NFS3ERR_STALE) {
688         printf("NFS Error: %d\n", fh->status);
689         return nfsstat_to_errval(fh->status);
692     assert(fh->size <= bytes);
693     h->u.file.pos += fh->size;
694     *bytes_written = fh->size;
740     e = nfs_setattr(nfs->client, h->fh,
801     e = nfs_getattr(nfs->client, h->fh, getattr_callback, info);
909             e = nfs_readdir(nfs->client, h->fh, oldentry->cookie,
917             e = nfs_readdir(nfs->client, h->fh, NFS_READDIR_COOKIE,
944             e = nfs_lookup(nfs->client, h->fh, entry->name, get_info_lookup_cb,
967     nfs_freefh(h->fh);
980     nfs_freefh(h->fh);
992     h->fh.data_len = result->status;
997 static void remove_resolve_cont(void *st, errval_t err, struct nfs_fh3 fh,
1009     errval_t r = nfs_remove(h->nfs->client, fh, h->st, remove_callback, h);
1038     h->fh = NULL_NFS_FH;
1040     h->fh.data_len = 0;
1050     size_t err = h->fh.data_len;
1085 static void mkdir_resolve_cont(void *st, errval_t err, struct nfs_fh3 fh,
1102     errval_t r = nfs_mkdir(s->client, fh, s->dirname, nulattr, mkdir_callback, s);
1163     for(int i = 0; i < h->fh.data_len; i++) {
1164         snprintf(str, 20, "%02x", h->fh.data_val[i]);
1171     *keylen = h->fh.data_len + sizeof(blockid);
1174     memcpy(*retkey, h->fh.data_val, h->fh.data_len);
1175     memcpy(&(*retkey)[h->fh.data_len], &blockid, sizeof(blockid));
1192     struct nfs_file_io_handle fh;
1193     memset(&fh, 0, sizeof(struct nfs_file_io_handle));
1195     fh.data = buffer;
1196     fh.size = BUFFER_CACHE_BLOCK_SIZE;
1197     fh.offset = (h->u.file.pos / BUFFER_CACHE_BLOCK_SIZE) * BUFFER_CACHE_BLOCK_SIZE;
1198     fh.status = NFS3_OK;
1199     fh.handle = h->fh;
1200     fh.chunks_in_progress = 0;
1206     while (fh.chunk_pos < fh.size && chunks < MAX_NFS_READ_CHUNKS) {
1207 //    while (fh.chunk_pos < fh.size) {
1211         pfh->fh = &fh;
1212         pfh->chunk_start = fh.chunk_pos;
1213         pfh->chunk_size = MIN(MAX_NFS_READ_BYTES, fh.size - pfh->chunk_start);
1214         fh.chunk_pos += pfh->chunk_size;
1215         fh.chunks_in_progress++;
1216         e = nfs_read(nfs->client, fh.handle, fh.offset + pfh->chunk_start,
1219             fh.chunk_pos -= pfh->chunk_size;
1231     if (fh.status != NFS3_OK && fh.status != NFS3ERR_STALE) {
1232         return nfsstat_to_errval(fh.status);
1235     assert(fh.size <= BUFFER_CACHE_BLOCK_SIZE);
1236     *bytes_read = fh.size;
1238     if (fh.size < BUFFER_CACHE_BLOCK_SIZE) {
1258     struct nfs_file_io_handle fh;
1259     memset(&fh, 0, sizeof(struct nfs_file_io_handle));
1263     fh.data = (void *)buffer;
1264     fh.size = bytes;
1265     fh.offset = (h->u.file.pos / BUFFER_CACHE_BLOCK_SIZE) * BUFFER_CACHE_BLOCK_SIZE;
1266     fh.status = NFS3_OK;
1267     fh.handle = h->fh;
1276         pfh->fh = &fh;
1277         pfh->chunk_start = fh.chunk_pos;
1278         pfh->chunk_size = MIN(MAX_NFS_WRITE_BYTES, fh.size - pfh->chunk_start);
1279         fh.chunk_pos += pfh->chunk_size;
1280         e = nfs_write(nfs->client, fh.handle, fh.offset + pfh->chunk_start,
1281                       (char *)fh.data + pfh->chunk_start, pfh->chunk_size,
1285     } while (fh.chunk_pos < fh.size && chunks < MAX_NFS_WRITE_CHUNKS);
1291     if (fh.status != NFS3_OK) {
1292         return nfsstat_to_errval(fh.status);
1295     assert(fh.size <= bytes);
1296     h->u.file.pos += fh.size;
1297     *bytes_written = fh.size;