/* * handle remote file deletion by discarding the callback promise */ static void afs_vnode_deleted_remotely(struct afs_vnode *vnode) { struct afs_server *server; _enter("{%p}", vnode->server); set_bit(AFS_VNODE_DELETED, &vnode->flags); server = vnode->server; if (server) { if (vnode->cb_promised) { spin_lock(&server->cb_lock); if (vnode->cb_promised) { rb_erase(&vnode->cb_promise, &server->cb_promises); vnode->cb_promised = false; } spin_unlock(&server->cb_lock); } spin_lock(&server->fs_lock); rb_erase(&vnode->server_rb, &server->fs_vnodes); spin_unlock(&server->fs_lock); vnode->server = NULL; afs_put_server(server); } else { ASSERT(!vnode->cb_promised); } _leave(""); }
/* * handle a callback timing out * TODO: retain a ref to vnode struct for an outstanding callback timeout */ static void afs_vnode_cb_timed_out(struct afs_timer *timer) { struct afs_server *oldserver; struct afs_vnode *vnode; vnode = list_entry(timer, struct afs_vnode, cb_timeout); _enter("%p", vnode); /* set the changed flag in the vnode and release the server */ spin_lock(&vnode->lock); oldserver = xchg(&vnode->cb_server, NULL); if (oldserver) { vnode->flags |= AFS_VNODE_CHANGED; spin_lock(&afs_cb_hash_lock); list_del_init(&vnode->cb_hash_link); spin_unlock(&afs_cb_hash_lock); spin_lock(&oldserver->cb_lock); list_del_init(&vnode->cb_link); spin_unlock(&oldserver->cb_lock); } spin_unlock(&vnode->lock); afs_put_server(oldserver); _leave(""); } /* end afs_vnode_cb_timed_out() */
/* * Dispose of a reference on a call. */ void afs_put_call(struct afs_call *call) { struct afs_net *net = call->net; int n = atomic_dec_return(&call->usage); int o = atomic_read(&net->nr_outstanding_calls); trace_afs_call(call, afs_call_trace_put, n + 1, o, __builtin_return_address(0)); ASSERTCMP(n, >=, 0); if (n == 0) { ASSERT(!work_pending(&call->async_work)); ASSERT(call->type->name != NULL); if (call->rxcall) { rxrpc_kernel_end_call(net->socket, call->rxcall); call->rxcall = NULL; } if (call->type->destructor) call->type->destructor(call); afs_put_server(call->net, call->cm_server); afs_put_cb_interest(call->net, call->cbi); kfree(call->request); trace_afs_call(call, afs_call_trace_free, 0, o, __builtin_return_address(0)); kfree(call); o = atomic_dec_return(&net->nr_outstanding_calls); if (o == 0) wake_up_var(&net->nr_outstanding_calls); } }
/* * finish off updating the recorded status of a file * - starts callback expiry timer * - adds to server's callback list */ void afs_vnode_finalise_status_update(afs_vnode_t *vnode, afs_server_t *server, int ret) { afs_server_t *oldserver = NULL; _enter("%p,%p,%d",vnode,server,ret); spin_lock(&vnode->lock); vnode->flags &= ~AFS_VNODE_CHANGED; if (ret==0) { /* adjust the callback timeout appropriately */ afs_kafstimod_add_timer(&vnode->cb_timeout,vnode->cb_expiry*HZ); spin_lock(&afs_cb_hash_lock); list_del(&vnode->cb_hash_link); list_add_tail(&vnode->cb_hash_link,&afs_cb_hash(server,&vnode->fid)); spin_unlock(&afs_cb_hash_lock); /* swap ref to old callback server with that for new callback server */ oldserver = xchg(&vnode->cb_server,server); if (oldserver!=server) { if (oldserver) { spin_lock(&oldserver->cb_lock); list_del_init(&vnode->cb_link); spin_unlock(&oldserver->cb_lock); } afs_get_server(server); spin_lock(&server->cb_lock); list_add_tail(&vnode->cb_link,&server->cb_promises); spin_unlock(&server->cb_lock); } else { /* same server */ oldserver = NULL; } } else if (ret==-ENOENT) { /* the file was deleted - clear the callback timeout */ oldserver = xchg(&vnode->cb_server,NULL); afs_kafstimod_del_timer(&vnode->cb_timeout); _debug("got NOENT from server - marking file deleted"); vnode->flags |= AFS_VNODE_DELETED; } vnode->update_cnt--; spin_unlock(&vnode->lock); wake_up_all(&vnode->update_waitq); afs_put_server(oldserver); _leave(""); } /* end afs_vnode_finalise_status_update() */
/* * clean up a cache manager call */ static void afs_cm_destructor(struct afs_call *call) { _enter(""); afs_put_server(call->server); call->server = NULL; kfree(call->buffer); call->buffer = NULL; }
void afs_put_serverlist(struct afs_net *net, struct afs_server_list *slist) { int i; if (slist && refcount_dec_and_test(&slist->usage)) { for (i = 0; i < slist->nr_servers; i++) { afs_put_cb_interest(net, slist->servers[i].cb_interest); afs_put_server(net, slist->servers[i].server); } kfree(slist); } }
/* * 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); }
/* * remove a file or directory */ int afs_vnode_remove(struct afs_vnode *vnode, struct key *key, const char *name, bool isdir) { struct afs_server *server; int ret; _enter("%s{%x:%u.%u},%x,%s", vnode->volume->vlocation->vldb.name, vnode->fid.vid, vnode->fid.vnode, vnode->fid.unique, key_serial(key), name); /* this op will fetch the status on the directory we're removing from */ 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_remove(server, key, vnode, name, isdir, &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 [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); }
/* * clear an AFS inode */ void afs_evict_inode(struct inode *inode) { struct afs_permits *permits; struct afs_vnode *vnode; vnode = AFS_FS_I(inode); _enter("{%x:%u.%d} v=%u x=%u t=%u }", vnode->fid.vid, vnode->fid.vnode, vnode->fid.unique, vnode->cb_version, vnode->cb_expiry, vnode->cb_type); _debug("CLEAR INODE %p", inode); ASSERTCMP(inode->i_ino, ==, vnode->fid.vnode); truncate_inode_pages_final(&inode->i_data); clear_inode(inode); afs_give_up_callback(vnode); if (vnode->server) { spin_lock(&vnode->server->fs_lock); rb_erase(&vnode->server_rb, &vnode->server->fs_vnodes); spin_unlock(&vnode->server->fs_lock); afs_put_server(vnode->server); vnode->server = NULL; } ASSERT(list_empty(&vnode->writebacks)); ASSERT(!vnode->cb_promised); #ifdef CONFIG_AFS_FSCACHE fscache_relinquish_cookie(vnode->cache, 0); vnode->cache = NULL; #endif mutex_lock(&vnode->permits_lock); permits = vnode->permits; rcu_assign_pointer(vnode->permits, NULL); mutex_unlock(&vnode->permits_lock); if (permits) call_rcu(&permits->rcu, afs_zap_permits); _leave(""); }
/* * insert a vnode into the backing server's vnode tree */ static void afs_install_vnode(struct afs_vnode *vnode, struct afs_server *server) { struct afs_server *old_server = vnode->server; struct afs_vnode *xvnode; struct rb_node *parent, **p; _enter("%p,%p", vnode, server); if (old_server) { spin_lock(&old_server->fs_lock); rb_erase(&vnode->server_rb, &old_server->fs_vnodes); spin_unlock(&old_server->fs_lock); } afs_get_server(server); vnode->server = server; afs_put_server(old_server); /* insert into the server's vnode tree in FID order */ spin_lock(&server->fs_lock); parent = NULL; p = &server->fs_vnodes.rb_node; while (*p) { parent = *p; xvnode = rb_entry(parent, struct afs_vnode, server_rb); if (vnode->fid.vid < xvnode->fid.vid) p = &(*p)->rb_left; else if (vnode->fid.vid > xvnode->fid.vid) p = &(*p)->rb_right; else if (vnode->fid.vnode < xvnode->fid.vnode) p = &(*p)->rb_left; else if (vnode->fid.vnode > xvnode->fid.vnode) p = &(*p)->rb_right; else if (vnode->fid.unique < xvnode->fid.unique) p = &(*p)->rb_left; else if (vnode->fid.unique > xvnode->fid.unique) p = &(*p)->rb_right; else BUG(); /* can't happen unless afs_iget() malfunctions */ } rb_link_node(&vnode->server_rb, parent, p); rb_insert_color(&vnode->server_rb, &server->fs_vnodes); spin_unlock(&server->fs_lock); _leave(""); }
/* * clean up a cache manager call */ static void afs_cm_destructor(struct afs_call *call) { _enter(""); /* Break the callbacks here so that we do it after the final ACK is * received. The step number here must match the final number in * afs_deliver_cb_callback(). */ if (call->unmarshall == 5) { ASSERT(call->server && call->count && call->request); afs_break_callbacks(call->server, call->count, call->request); } afs_put_server(call->server); call->server = NULL; kfree(call->buffer); call->buffer = NULL; }
/* * finish off updating the recorded status of a file after a successful * operation completion * - starts callback expiry timer * - adds to server's callback list */ void afs_vnode_finalise_status_update(struct afs_vnode *vnode, struct afs_server *server) { struct afs_server *oldserver = NULL; _enter("%p,%p", vnode, server); spin_lock(&vnode->lock); clear_bit(AFS_VNODE_CB_BROKEN, &vnode->flags); afs_vnode_note_promise(vnode, server); vnode->update_cnt--; ASSERTCMP(vnode->update_cnt, >=, 0); spin_unlock(&vnode->lock); wake_up_all(&vnode->update_waitq); afs_put_server(oldserver); _leave(""); }
/* * destroy a volume record */ void afs_put_volume(struct afs_volume *volume) { struct afs_vlocation *vlocation; int loop; if (!volume) return; _enter("%p", volume); ASSERTCMP(atomic_read(&volume->usage), >, 0); vlocation = volume->vlocation; /* to prevent a race, the decrement and the dequeue must be effectively * atomic */ down_write(&vlocation->cell->vl_sem); if (likely(!atomic_dec_and_test(&volume->usage))) { up_write(&vlocation->cell->vl_sem); _leave(""); return; } vlocation->vols[volume->type] = NULL; up_write(&vlocation->cell->vl_sem); /* finish cleaning up the volume */ #ifdef CONFIG_AFS_FSCACHE fscache_relinquish_cookie(volume->cache, 0); #endif afs_put_vlocation(vlocation); for (loop = volume->nservers - 1; loop >= 0; loop--) afs_put_server(volume->servers[loop]); bdi_destroy(&volume->bdi); kfree(volume); _leave(" [destroyed]"); }
/* * break any outstanding callback on a vnode * - only relevent to server that issued it */ int afs_vnode_give_up_callback(struct afs_vnode *vnode) { 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); spin_lock(&afs_cb_hash_lock); list_del_init(&vnode->cb_hash_link); spin_unlock(&afs_cb_hash_lock); /* set the changed flag in the vnode and release the server */ spin_lock(&vnode->lock); afs_kafstimod_del_timer(&vnode->cb_timeout); server = xchg(&vnode->cb_server, NULL); if (server) { vnode->flags |= AFS_VNODE_CHANGED; spin_lock(&server->cb_lock); list_del_init(&vnode->cb_link); spin_unlock(&server->cb_lock); } spin_unlock(&vnode->lock); ret = 0; if (server) { ret = afs_rxfs_give_up_callback(server, vnode); afs_put_server(server); } _leave(" = %d", ret); return ret; } /* end afs_vnode_give_up_callback() */
/* * release a server after use * - releases the ref on the server struct that was acquired by picking * - records result of using a particular server to access a volume * - return 0 to try again, 1 if okay or to issue error * - the caller must release the server struct if result was 0 */ int afs_volume_release_fileserver(struct afs_vnode *vnode, struct afs_server *server, int result) { struct afs_volume *volume = vnode->volume; unsigned loop; _enter("%s,%08x,%d", volume->vlocation->vldb.name, ntohl(server->addr.s_addr), result); switch (result) { /* success */ case 0: server->fs_act_jif = jiffies; server->fs_state = 0; _leave(""); return 1; /* the fileserver denied all knowledge of the volume */ case -ENOMEDIUM: server->fs_act_jif = jiffies; down_write(&volume->server_sem); /* firstly, find where the server is in the active list (if it * is) */ for (loop = 0; loop < volume->nservers; loop++) if (volume->servers[loop] == server) goto present; /* no longer there - may have been discarded by another op */ goto try_next_server_upw; present: volume->nservers--; memmove(&volume->servers[loop], &volume->servers[loop + 1], sizeof(volume->servers[loop]) * (volume->nservers - loop)); volume->servers[volume->nservers] = NULL; afs_put_server(server); volume->rjservers++; if (volume->nservers > 0) /* another server might acknowledge its existence */ goto try_next_server_upw; /* handle the case where all the fileservers have rejected the * volume * - TODO: try asking the fileservers for volume information * - TODO: contact the VL server again to see if the volume is * no longer registered */ up_write(&volume->server_sem); afs_put_server(server); _leave(" [completely rejected]"); return 1; /* problem reaching the server */ case -ENETUNREACH: case -EHOSTUNREACH: case -ECONNREFUSED: case -ETIME: case -ETIMEDOUT: case -EREMOTEIO: /* mark the server as dead * TODO: vary dead timeout depending on error */ spin_lock(&server->fs_lock); if (!server->fs_state) { server->fs_dead_jif = jiffies + HZ * 10; server->fs_state = result; printk("kAFS: SERVER DEAD state=%d\n", result); } spin_unlock(&server->fs_lock); goto try_next_server; /* miscellaneous error */ default: server->fs_act_jif = jiffies; case -ENOMEM: case -ENONET: /* tell the caller to accept the result */ afs_put_server(server); _leave(" [local failure]"); return 1; } /* tell the caller to loop around and try the next server */ try_next_server_upw: up_write(&volume->server_sem); try_next_server: afs_put_server(server); _leave(" [try next server]"); return 0; }
/* * create a regular file on an AFS filesystem */ static int afs_create(struct inode *dir, struct dentry *dentry, umode_t mode, bool excl) { struct afs_file_status status; struct afs_callback cb; struct afs_server *server; struct afs_vnode *dvnode, *vnode; struct afs_fid fid; struct inode *inode; struct key *key; int ret; dvnode = AFS_FS_I(dir); _enter("{%x:%u},{%pd},%ho,", dvnode->fid.vid, dvnode->fid.vnode, dentry, mode); key = afs_request_key(dvnode->volume->cell); if (IS_ERR(key)) { ret = PTR_ERR(key); goto error; } mode |= S_IFREG; ret = afs_vnode_create(dvnode, key, dentry->d_name.name, mode, &fid, &status, &cb, &server); if (ret < 0) goto create_error; inode = afs_iget(dir->i_sb, key, &fid, &status, &cb); if (IS_ERR(inode)) { /* ENOMEM at a really inconvenient time - just abandon the new * directory on the server */ ret = PTR_ERR(inode); goto iget_error; } /* apply the status report we've got for the new vnode */ vnode = AFS_FS_I(inode); spin_lock(&vnode->lock); vnode->update_cnt++; spin_unlock(&vnode->lock); afs_vnode_finalise_status_update(vnode, server); afs_put_server(server); d_instantiate(dentry, inode); if (d_unhashed(dentry)) { _debug("not hashed"); d_rehash(dentry); } key_put(key); _leave(" = 0"); return 0; iget_error: afs_put_server(server); create_error: key_put(key); error: d_drop(dentry); _leave(" = %d", ret); return ret; }
/* * Build a server list from a VLDB record. */ struct afs_server_list *afs_alloc_server_list(struct afs_cell *cell, struct key *key, struct afs_vldb_entry *vldb, u8 type_mask) { struct afs_server_list *slist; struct afs_server *server; int ret = -ENOMEM, nr_servers = 0, i, j; for (i = 0; i < vldb->nr_servers; i++) if (vldb->fs_mask[i] & type_mask) nr_servers++; slist = kzalloc(struct_size(slist, servers, nr_servers), GFP_KERNEL); if (!slist) goto error; refcount_set(&slist->usage, 1); rwlock_init(&slist->lock); /* Make sure a records exists for each server in the list. */ for (i = 0; i < vldb->nr_servers; i++) { if (!(vldb->fs_mask[i] & type_mask)) continue; server = afs_lookup_server(cell, key, &vldb->fs_server[i]); if (IS_ERR(server)) { ret = PTR_ERR(server); if (ret == -ENOENT || ret == -ENOMEDIUM) continue; goto error_2; } /* Insertion-sort by UUID */ for (j = 0; j < slist->nr_servers; j++) if (memcmp(&slist->servers[j].server->uuid, &server->uuid, sizeof(server->uuid)) >= 0) break; if (j < slist->nr_servers) { if (slist->servers[j].server == server) { afs_put_server(cell->net, server); continue; } memmove(slist->servers + j + 1, slist->servers + j, (slist->nr_servers - j) * sizeof(struct afs_server_entry)); } slist->servers[j].server = server; slist->nr_servers++; } if (slist->nr_servers == 0) { ret = -EDESTADDRREQ; goto error_2; } return slist; error_2: afs_put_serverlist(cell->net, slist); error: return ERR_PTR(ret); }
/* * create a symlink in an AFS filesystem */ static int afs_symlink(struct inode *dir, struct dentry *dentry, const char *content) { struct afs_file_status status; struct afs_server *server; struct afs_vnode *dvnode, *vnode; struct afs_fid fid; struct inode *inode; struct key *key; int ret; dvnode = AFS_FS_I(dir); _enter("{%x:%u},{%s},%s", dvnode->fid.vid, dvnode->fid.vnode, dentry->d_name.name, content); ret = -ENAMETOOLONG; if (dentry->d_name.len >= AFSNAMEMAX) goto error; ret = -EINVAL; if (strlen(content) >= AFSPATHMAX) goto error; key = afs_request_key(dvnode->volume->cell); if (IS_ERR(key)) { ret = PTR_ERR(key); goto error; } ret = afs_vnode_symlink(dvnode, key, dentry->d_name.name, content, &fid, &status, &server); if (ret < 0) goto create_error; inode = afs_iget(dir->i_sb, key, &fid, &status, NULL); if (IS_ERR(inode)) { /* ENOMEM at a really inconvenient time - just abandon the new * directory on the server */ ret = PTR_ERR(inode); goto iget_error; } /* apply the status report we've got for the new vnode */ vnode = AFS_FS_I(inode); spin_lock(&vnode->lock); vnode->update_cnt++; spin_unlock(&vnode->lock); afs_vnode_finalise_status_update(vnode, server); afs_put_server(server); d_instantiate(dentry, inode); if (d_unhashed(dentry)) { _debug("not hashed"); d_rehash(dentry); } key_put(key); _leave(" = 0"); return 0; iget_error: afs_put_server(server); create_error: key_put(key); error: d_drop(dentry); _leave(" = %d", ret); return ret; }
/* * lookup a volume by name * - this can be one of the following: * "%[cell:]volume[.]" R/W volume * "#[cell:]volume[.]" R/O or R/W volume (rwparent=0), * or R/W (rwparent=1) volume * "%[cell:]volume.readonly" R/O volume * "#[cell:]volume.readonly" R/O volume * "%[cell:]volume.backup" Backup volume * "#[cell:]volume.backup" Backup volume * * The cell name is optional, and defaults to the current cell. * * See "The Rules of Mount Point Traversal" in Chapter 5 of the AFS SysAdmin * Guide * - Rule 1: Explicit type suffix forces access of that type or nothing * (no suffix, then use Rule 2 & 3) * - Rule 2: If parent volume is R/O, then mount R/O volume by preference, R/W * if not available * - Rule 3: If parent volume is R/W, then only mount R/W volume unless * explicitly told otherwise */ struct afs_volume *afs_volume_lookup(struct afs_mount_params *params) { struct afs_vlocation *vlocation = NULL; struct afs_volume *volume = NULL; struct afs_server *server = NULL; char srvtmask; int ret, loop; _enter("{%*.*s,%d}", params->volnamesz, params->volnamesz, params->volname, params->rwpath); /* lookup the volume location record */ vlocation = afs_vlocation_lookup(params->cell, params->key, params->volname, params->volnamesz); if (IS_ERR(vlocation)) { ret = PTR_ERR(vlocation); vlocation = NULL; goto error; } /* make the final decision on the type we want */ ret = -ENOMEDIUM; if (params->force && !(vlocation->vldb.vidmask & (1 << params->type))) goto error; srvtmask = 0; for (loop = 0; loop < vlocation->vldb.nservers; loop++) srvtmask |= vlocation->vldb.srvtmask[loop]; if (params->force) { if (!(srvtmask & (1 << params->type))) goto error; } else if (srvtmask & AFS_VOL_VTM_RO) { params->type = AFSVL_ROVOL; } else if (srvtmask & AFS_VOL_VTM_RW) { params->type = AFSVL_RWVOL; } else { goto error; } down_write(¶ms->cell->vl_sem); /* is the volume already active? */ if (vlocation->vols[params->type]) { /* yes - re-use it */ volume = vlocation->vols[params->type]; afs_get_volume(volume); goto success; } /* create a new volume record */ _debug("creating new volume record"); ret = -ENOMEM; volume = kzalloc(sizeof(struct afs_volume), GFP_KERNEL); if (!volume) goto error_up; atomic_set(&volume->usage, 1); volume->type = params->type; volume->type_force = params->force; volume->cell = params->cell; volume->vid = vlocation->vldb.vid[params->type]; ret = bdi_setup_and_register(&volume->bdi, "afs", BDI_CAP_MAP_COPY); if (ret) goto error_bdi; init_rwsem(&volume->server_sem); /* look up all the applicable server records */ for (loop = 0; loop < 8; loop++) { if (vlocation->vldb.srvtmask[loop] & (1 << volume->type)) { server = afs_lookup_server( volume->cell, &vlocation->vldb.servers[loop]); if (IS_ERR(server)) { ret = PTR_ERR(server); goto error_discard; } volume->servers[volume->nservers] = server; volume->nservers++; } } /* attach the cache and volume location */ #ifdef CONFIG_AFS_FSCACHE volume->cache = fscache_acquire_cookie(vlocation->cache, &afs_volume_cache_index_def, volume, true); #endif afs_get_vlocation(vlocation); volume->vlocation = vlocation; vlocation->vols[volume->type] = volume; success: _debug("kAFS selected %s volume %08x", afs_voltypes[volume->type], volume->vid); up_write(¶ms->cell->vl_sem); afs_put_vlocation(vlocation); _leave(" = %p", volume); return volume; /* clean up */ error_up: up_write(¶ms->cell->vl_sem); error: afs_put_vlocation(vlocation); _leave(" = %d", ret); return ERR_PTR(ret); error_discard: bdi_destroy(&volume->bdi); error_bdi: up_write(¶ms->cell->vl_sem); for (loop = volume->nservers - 1; loop >= 0; loop--) afs_put_server(volume->servers[loop]); kfree(volume); goto error; }
/* * 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); }
/* * 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); }