1 /* 2 * linux/fs/nfs/unlink.c 3 * 4 * nfs sillydelete handling 5 * 6 */ 7 8 #include <linux/slab.h> 9 #include <linux/string.h> 10 #include <linux/dcache.h> 11 #include <linux/sunrpc/sched.h> 12 #include <linux/sunrpc/clnt.h> 13 #include <linux/nfs_fs.h> 14 15 16 struct nfs_unlinkdata { 17 struct nfs_removeargs args; 18 struct nfs_removeres res; 19 struct inode *dir; 20 struct rpc_cred *cred; 21 }; 22 23 /** 24 * nfs_free_unlinkdata - release data from a sillydelete operation. 25 * @data: pointer to unlink structure. 26 */ 27 static void 28 nfs_free_unlinkdata(struct nfs_unlinkdata *data) 29 { 30 iput(data->dir); 31 put_rpccred(data->cred); 32 kfree(data->args.name.name); 33 kfree(data); 34 } 35 36 #define NAME_ALLOC_LEN(len) ((len+16) & ~15) 37 /** 38 * nfs_copy_dname - copy dentry name to data structure 39 * @dentry: pointer to dentry 40 * @data: nfs_unlinkdata 41 */ 42 static int nfs_copy_dname(struct dentry *dentry, struct nfs_unlinkdata *data) 43 { 44 char *str; 45 int len = dentry->d_name.len; 46 47 str = kmemdup(dentry->d_name.name, NAME_ALLOC_LEN(len), GFP_KERNEL); 48 if (!str) 49 return -ENOMEM; 50 data->args.name.len = len; 51 data->args.name.name = str; 52 return 0; 53 } 54 55 /** 56 * nfs_async_unlink_init - Initialize the RPC info 57 * task: rpc_task of the sillydelete 58 */ 59 static void nfs_async_unlink_init(struct rpc_task *task, void *calldata) 60 { 61 struct nfs_unlinkdata *data = calldata; 62 struct inode *dir = data->dir; 63 struct rpc_message msg = { 64 .rpc_argp = &data->args, 65 .rpc_resp = &data->res, 66 .rpc_cred = data->cred, 67 }; 68 69 nfs_begin_data_update(dir); 70 NFS_PROTO(dir)->unlink_setup(&msg, dir); 71 rpc_call_setup(task, &msg, 0); 72 } 73 74 /** 75 * nfs_async_unlink_done - Sillydelete post-processing 76 * @task: rpc_task of the sillydelete 77 * 78 * Do the directory attribute update. 79 */ 80 static void nfs_async_unlink_done(struct rpc_task *task, void *calldata) 81 { 82 struct nfs_unlinkdata *data = calldata; 83 struct inode *dir = data->dir; 84 85 if (!NFS_PROTO(dir)->unlink_done(task, dir)) 86 rpc_restart_call(task); 87 else 88 nfs_end_data_update(dir); 89 } 90 91 /** 92 * nfs_async_unlink_release - Release the sillydelete data. 93 * @task: rpc_task of the sillydelete 94 * 95 * We need to call nfs_put_unlinkdata as a 'tk_release' task since the 96 * rpc_task would be freed too. 97 */ 98 static void nfs_async_unlink_release(void *calldata) 99 { 100 struct nfs_unlinkdata *data = calldata; 101 nfs_free_unlinkdata(data); 102 } 103 104 static const struct rpc_call_ops nfs_unlink_ops = { 105 .rpc_call_prepare = nfs_async_unlink_init, 106 .rpc_call_done = nfs_async_unlink_done, 107 .rpc_release = nfs_async_unlink_release, 108 }; 109 110 static int nfs_call_unlink(struct dentry *dentry, struct nfs_unlinkdata *data) 111 { 112 struct rpc_task *task; 113 struct dentry *parent; 114 struct inode *dir; 115 116 if (nfs_copy_dname(dentry, data) < 0) 117 goto out_free; 118 119 parent = dget_parent(dentry); 120 if (parent == NULL) 121 goto out_free; 122 dir = igrab(parent->d_inode); 123 dput(parent); 124 if (dir == NULL) 125 goto out_free; 126 127 data->dir = dir; 128 data->args.fh = NFS_FH(dir); 129 nfs_fattr_init(&data->res.dir_attr); 130 131 task = rpc_run_task(NFS_CLIENT(dir), RPC_TASK_ASYNC, &nfs_unlink_ops, data); 132 if (!IS_ERR(task)) 133 rpc_put_task(task); 134 return 1; 135 out_free: 136 return 0; 137 } 138 139 /** 140 * nfs_async_unlink - asynchronous unlinking of a file 141 * @dir: parent directory of dentry 142 * @dentry: dentry to unlink 143 */ 144 int 145 nfs_async_unlink(struct inode *dir, struct dentry *dentry) 146 { 147 struct nfs_unlinkdata *data; 148 int status = -ENOMEM; 149 150 data = kzalloc(sizeof(*data), GFP_KERNEL); 151 if (data == NULL) 152 goto out; 153 154 data->cred = rpcauth_lookupcred(NFS_CLIENT(dir)->cl_auth, 0); 155 if (IS_ERR(data->cred)) { 156 status = PTR_ERR(data->cred); 157 goto out_free; 158 } 159 160 status = -EBUSY; 161 spin_lock(&dentry->d_lock); 162 if (dentry->d_flags & DCACHE_NFSFS_RENAMED) 163 goto out_unlock; 164 dentry->d_flags |= DCACHE_NFSFS_RENAMED; 165 dentry->d_fsdata = data; 166 spin_unlock(&dentry->d_lock); 167 return 0; 168 out_unlock: 169 spin_unlock(&dentry->d_lock); 170 put_rpccred(data->cred); 171 out_free: 172 kfree(data); 173 out: 174 return status; 175 } 176 177 /** 178 * nfs_complete_unlink - Initialize completion of the sillydelete 179 * @dentry: dentry to delete 180 * @inode: inode 181 * 182 * Since we're most likely to be called by dentry_iput(), we 183 * only use the dentry to find the sillydelete. We then copy the name 184 * into the qstr. 185 */ 186 void 187 nfs_complete_unlink(struct dentry *dentry, struct inode *inode) 188 { 189 struct nfs_unlinkdata *data = NULL; 190 191 spin_lock(&dentry->d_lock); 192 if (dentry->d_flags & DCACHE_NFSFS_RENAMED) { 193 dentry->d_flags &= ~DCACHE_NFSFS_RENAMED; 194 data = dentry->d_fsdata; 195 } 196 spin_unlock(&dentry->d_lock); 197 198 if (data != NULL && (NFS_STALE(inode) || !nfs_call_unlink(dentry, data))) 199 nfs_free_unlinkdata(data); 200 } 201