/* * create a symbolic link */ int afs_vnode_symlink(struct afs_vnode *vnode, struct key *key, const char *name, const char *content, struct afs_fid *newfid, struct afs_file_status *newstatus, struct afs_server **_server) { struct afs_server *server; int ret; _enter("%s{%x:%u.%u},%x,%s,%s,,,", vnode->volume->vlocation->vldb.name, vnode->fid.vid, vnode->fid.vnode, vnode->fid.unique, key_serial(key), name, content); /* this op will fetch the status on the directory we're creating in */ spin_lock(&vnode->lock); vnode->update_cnt++; spin_unlock(&vnode->lock); do { /* pick a server to query */ server = afs_volume_pick_fileserver(vnode); if (IS_ERR(server)) goto no_server; _debug("USING SERVER: %08x\n", ntohl(server->addr.s_addr)); ret = afs_fs_symlink(server, key, vnode, name, content, newfid, newstatus, &afs_sync_call); } while (!afs_volume_release_fileserver(vnode, server, ret)); /* adjust the flags */ if (ret == 0) { afs_vnode_finalise_status_update(vnode, server); *_server = server; } else { afs_vnode_status_update_failed(vnode, ret); *_server = NULL; } _leave(" = %d [cnt %d]", ret, vnode->update_cnt); return ret; no_server: spin_lock(&vnode->lock); vnode->update_cnt--; ASSERTCMP(vnode->update_cnt, >=, 0); spin_unlock(&vnode->lock); _leave(" = %ld [cnt %d]", PTR_ERR(server), vnode->update_cnt); return PTR_ERR(server); }
/* * fetch file data from the volume * - TODO implement caching */ int afs_vnode_fetch_data(struct afs_vnode *vnode, struct key *key, off_t offset, size_t length, struct page *page) { struct afs_server *server; int ret; _enter("%s{%x:%u.%u},%x,,,", vnode->volume->vlocation->vldb.name, vnode->fid.vid, vnode->fid.vnode, vnode->fid.unique, key_serial(key)); /* this op will fetch the status */ spin_lock(&vnode->lock); vnode->update_cnt++; spin_unlock(&vnode->lock); /* merge in AFS status fetches and clear outstanding callback on this * vnode */ do { /* pick a server to query */ server = afs_volume_pick_fileserver(vnode); if (IS_ERR(server)) goto no_server; _debug("USING SERVER: %08x\n", ntohl(server->addr.s_addr)); ret = afs_fs_fetch_data(server, key, vnode, offset, length, page, &afs_sync_call); } while (!afs_volume_release_fileserver(vnode, server, ret)); /* adjust the flags */ if (ret == 0) { afs_vnode_finalise_status_update(vnode, server); afs_put_server(server); } else { afs_vnode_status_update_failed(vnode, ret); } _leave(" = %d", ret); return ret; no_server: spin_lock(&vnode->lock); vnode->update_cnt--; ASSERTCMP(vnode->update_cnt, >=, 0); spin_unlock(&vnode->lock); return PTR_ERR(server); }
/* * fetch file data from the volume * - TODO implement caching and server failover */ int afs_vnode_fetch_data(struct afs_vnode *vnode, struct afs_rxfs_fetch_descriptor *desc) { struct afs_server *server; int ret; _enter("%s,{%u,%u,%u}", vnode->volume->vlocation->vldb.name, vnode->fid.vid, vnode->fid.vnode, vnode->fid.unique); /* this op will fetch the status */ spin_lock(&vnode->lock); vnode->update_cnt++; spin_unlock(&vnode->lock); /* merge in AFS status fetches and clear outstanding callback on this * vnode */ do { /* pick a server to query */ ret = afs_volume_pick_fileserver(vnode->volume, &server); if (ret < 0) return ret; _debug("USING SERVER: %08x\n", ntohl(server->addr.s_addr)); ret = afs_rxfs_fetch_file_data(server, vnode, desc, NULL); } while (!afs_volume_release_fileserver(vnode->volume, server, ret)); /* adjust the flags */ afs_vnode_finalise_status_update(vnode, server, ret); _leave(" = %d", ret); return ret; } /* end afs_vnode_fetch_data() */
/* * fetch file status from the volume * - don't issue a fetch if: * - the changed bit is not set and there's a valid callback * - there are any outstanding ops that will fetch the status * - TODO implement local caching */ int afs_vnode_fetch_status(struct afs_vnode *vnode) { struct afs_server *server; int ret; DECLARE_WAITQUEUE(myself, current); _enter("%s,{%u,%u,%u}", vnode->volume->vlocation->vldb.name, vnode->fid.vid, vnode->fid.vnode, vnode->fid.unique); if (!(vnode->flags & AFS_VNODE_CHANGED) && vnode->cb_server) { _leave(" [unchanged]"); return 0; } if (vnode->flags & AFS_VNODE_DELETED) { _leave(" [deleted]"); return -ENOENT; } spin_lock(&vnode->lock); if (!(vnode->flags & AFS_VNODE_CHANGED)) { spin_unlock(&vnode->lock); _leave(" [unchanged]"); return 0; } if (vnode->update_cnt > 0) { /* someone else started a fetch */ set_current_state(TASK_UNINTERRUPTIBLE); add_wait_queue(&vnode->update_waitq, &myself); /* wait for the status to be updated */ for (;;) { if (!(vnode->flags & AFS_VNODE_CHANGED)) break; if (vnode->flags & AFS_VNODE_DELETED) break; /* it got updated and invalidated all before we saw * it */ if (vnode->update_cnt == 0) { remove_wait_queue(&vnode->update_waitq, &myself); set_current_state(TASK_RUNNING); goto get_anyway; } spin_unlock(&vnode->lock); schedule(); set_current_state(TASK_UNINTERRUPTIBLE); spin_lock(&vnode->lock); } remove_wait_queue(&vnode->update_waitq, &myself); spin_unlock(&vnode->lock); set_current_state(TASK_RUNNING); return vnode->flags & AFS_VNODE_DELETED ? -ENOENT : 0; } get_anyway: /* okay... we're going to have to initiate the op */ vnode->update_cnt++; spin_unlock(&vnode->lock); /* merge AFS status fetches and clear outstanding callback on this * vnode */ do { /* pick a server to query */ ret = afs_volume_pick_fileserver(vnode->volume, &server); if (ret<0) return ret; _debug("USING SERVER: %08x\n", ntohl(server->addr.s_addr)); ret = afs_rxfs_fetch_file_status(server, vnode, NULL); } while (!afs_volume_release_fileserver(vnode->volume, server, ret)); /* adjust the flags */ afs_vnode_finalise_status_update(vnode, server, ret); _leave(" = %d", ret); return ret; } /* end afs_vnode_fetch_status() */
/* * rename a file */ int afs_vnode_rename(struct afs_vnode *orig_dvnode, struct afs_vnode *new_dvnode, struct key *key, const char *orig_name, const char *new_name) { struct afs_server *server; int ret; _enter("%s{%x:%u.%u},%s{%u,%u,%u},%x,%s,%s", orig_dvnode->volume->vlocation->vldb.name, orig_dvnode->fid.vid, orig_dvnode->fid.vnode, orig_dvnode->fid.unique, new_dvnode->volume->vlocation->vldb.name, new_dvnode->fid.vid, new_dvnode->fid.vnode, new_dvnode->fid.unique, key_serial(key), orig_name, new_name); /* this op will fetch the status on both the directories we're dealing * with */ spin_lock(&orig_dvnode->lock); orig_dvnode->update_cnt++; spin_unlock(&orig_dvnode->lock); if (new_dvnode != orig_dvnode) { spin_lock(&new_dvnode->lock); new_dvnode->update_cnt++; spin_unlock(&new_dvnode->lock); } do { /* pick a server to query */ server = afs_volume_pick_fileserver(orig_dvnode); if (IS_ERR(server)) goto no_server; _debug("USING SERVER: %08x\n", ntohl(server->addr.s_addr)); ret = afs_fs_rename(server, key, orig_dvnode, orig_name, new_dvnode, new_name, &afs_sync_call); } while (!afs_volume_release_fileserver(orig_dvnode, server, ret)); /* adjust the flags */ if (ret == 0) { afs_vnode_finalise_status_update(orig_dvnode, server); if (new_dvnode != orig_dvnode) afs_vnode_finalise_status_update(new_dvnode, server); afs_put_server(server); } else { afs_vnode_status_update_failed(orig_dvnode, ret); if (new_dvnode != orig_dvnode) afs_vnode_status_update_failed(new_dvnode, ret); } _leave(" = %d [cnt %d]", ret, orig_dvnode->update_cnt); return ret; no_server: spin_lock(&orig_dvnode->lock); orig_dvnode->update_cnt--; ASSERTCMP(orig_dvnode->update_cnt, >=, 0); spin_unlock(&orig_dvnode->lock); if (new_dvnode != orig_dvnode) { spin_lock(&new_dvnode->lock); new_dvnode->update_cnt--; ASSERTCMP(new_dvnode->update_cnt, >=, 0); spin_unlock(&new_dvnode->lock); }
/* * fetch file status from the volume * - don't issue a fetch if: * - the changed bit is not set and there's a valid callback * - there are any outstanding ops that will fetch the status * - TODO implement local caching */ int afs_vnode_fetch_status(struct afs_vnode *vnode, struct afs_vnode *auth_vnode, struct key *key) { struct afs_server *server; unsigned long acl_order; int ret; DECLARE_WAITQUEUE(myself, current); _enter("%s,{%x:%u.%u}", vnode->volume->vlocation->vldb.name, vnode->fid.vid, vnode->fid.vnode, vnode->fid.unique); if (!test_bit(AFS_VNODE_CB_BROKEN, &vnode->flags) && vnode->cb_promised) { _leave(" [unchanged]"); return 0; } if (test_bit(AFS_VNODE_DELETED, &vnode->flags)) { _leave(" [deleted]"); return -ENOENT; } acl_order = 0; if (auth_vnode) acl_order = auth_vnode->acl_order; spin_lock(&vnode->lock); if (!test_bit(AFS_VNODE_CB_BROKEN, &vnode->flags) && vnode->cb_promised) { spin_unlock(&vnode->lock); _leave(" [unchanged]"); return 0; } ASSERTCMP(vnode->update_cnt, >=, 0); if (vnode->update_cnt > 0) { /* someone else started a fetch */ _debug("wait on fetch %d", vnode->update_cnt); set_current_state(TASK_UNINTERRUPTIBLE); ASSERT(myself.func != NULL); add_wait_queue(&vnode->update_waitq, &myself); /* wait for the status to be updated */ for (;;) { if (!test_bit(AFS_VNODE_CB_BROKEN, &vnode->flags)) break; if (test_bit(AFS_VNODE_DELETED, &vnode->flags)) break; /* check to see if it got updated and invalidated all * before we saw it */ if (vnode->update_cnt == 0) { remove_wait_queue(&vnode->update_waitq, &myself); set_current_state(TASK_RUNNING); goto get_anyway; } spin_unlock(&vnode->lock); schedule(); set_current_state(TASK_UNINTERRUPTIBLE); spin_lock(&vnode->lock); } remove_wait_queue(&vnode->update_waitq, &myself); spin_unlock(&vnode->lock); set_current_state(TASK_RUNNING); return test_bit(AFS_VNODE_DELETED, &vnode->flags) ? -ENOENT : 0; } get_anyway: /* okay... we're going to have to initiate the op */ vnode->update_cnt++; spin_unlock(&vnode->lock); /* merge AFS status fetches and clear outstanding callback on this * vnode */ do { /* pick a server to query */ server = afs_volume_pick_fileserver(vnode); if (IS_ERR(server)) goto no_server; _debug("USING SERVER: %p{%08x}", server, ntohl(server->addr.s_addr)); ret = afs_fs_fetch_file_status(server, key, vnode, NULL, &afs_sync_call); } while (!afs_volume_release_fileserver(vnode, server, ret)); /* adjust the flags */ if (ret == 0) { _debug("adjust"); if (auth_vnode) afs_cache_permit(vnode, key, acl_order); afs_vnode_finalise_status_update(vnode, server); afs_put_server(server); } else { _debug("failed [%d]", ret); afs_vnode_status_update_failed(vnode, ret); } ASSERTCMP(vnode->update_cnt, >=, 0); _leave(" = %d [cnt %d]", ret, vnode->update_cnt); return ret; no_server: spin_lock(&vnode->lock); vnode->update_cnt--; ASSERTCMP(vnode->update_cnt, >=, 0); spin_unlock(&vnode->lock); _leave(" = %ld [cnt %d]", PTR_ERR(server), vnode->update_cnt); return PTR_ERR(server); }