Branch data     Line data    Source code

       1                 :            : // SPDX-License-Identifier: GPL-2.0
       2                 :            : /*
       3                 :            :  *  linux/fs/nfs/unlink.c
       4                 :            :  *
       5                 :            :  * nfs sillydelete handling
       6                 :            :  *
       7                 :            :  */
       8                 :            : 
       9                 :            : #include <linux/slab.h>
      10                 :            : #include <linux/string.h>
      11                 :            : #include <linux/dcache.h>
      12                 :            : #include <linux/sunrpc/sched.h>
      13                 :            : #include <linux/sunrpc/clnt.h>
      14                 :            : #include <linux/nfs_fs.h>
      15                 :            : #include <linux/sched.h>
      16                 :            : #include <linux/wait.h>
      17                 :            : #include <linux/namei.h>
      18                 :            : #include <linux/fsnotify.h>
      19                 :            : 
      20                 :            : #include "internal.h"
      21                 :            : #include "nfs4_fs.h"
      22                 :            : #include "iostat.h"
      23                 :            : #include "delegation.h"
      24                 :            : 
      25                 :            : #include "nfstrace.h"
      26                 :            : 
      27                 :            : /**
      28                 :            :  * nfs_free_unlinkdata - release data from a sillydelete operation.
      29                 :            :  * @data: pointer to unlink structure.
      30                 :            :  */
      31                 :            : static void
      32                 :          0 : nfs_free_unlinkdata(struct nfs_unlinkdata *data)
      33                 :            : {
      34                 :          0 :         put_cred(data->cred);
      35                 :          0 :         kfree(data->args.name.name);
      36                 :          0 :         kfree(data);
      37                 :          0 : }
      38                 :            : 
      39                 :            : /**
      40                 :            :  * nfs_async_unlink_done - Sillydelete post-processing
      41                 :            :  * @task: rpc_task of the sillydelete
      42                 :            :  * @calldata: pointer to nfs_unlinkdata
      43                 :            :  *
      44                 :            :  * Do the directory attribute update.
      45                 :            :  */
      46                 :          0 : static void nfs_async_unlink_done(struct rpc_task *task, void *calldata)
      47                 :            : {
      48                 :            :         struct nfs_unlinkdata *data = calldata;
      49                 :          0 :         struct inode *dir = d_inode(data->dentry->d_parent);
      50                 :            : 
      51                 :          0 :         trace_nfs_sillyrename_unlink(data, task->tk_status);
      52                 :          0 :         if (!NFS_PROTO(dir)->unlink_done(task, dir))
      53                 :          0 :                 rpc_restart_call_prepare(task);
      54                 :          0 : }
      55                 :            : 
      56                 :            : /**
      57                 :            :  * nfs_async_unlink_release - Release the sillydelete data.
      58                 :            :  * @calldata: struct nfs_unlinkdata to release
      59                 :            :  *
      60                 :            :  * We need to call nfs_put_unlinkdata as a 'tk_release' task since the
      61                 :            :  * rpc_task would be freed too.
      62                 :            :  */
      63                 :          0 : static void nfs_async_unlink_release(void *calldata)
      64                 :            : {
      65                 :            :         struct nfs_unlinkdata   *data = calldata;
      66                 :          0 :         struct dentry *dentry = data->dentry;
      67                 :          0 :         struct super_block *sb = dentry->d_sb;
      68                 :            : 
      69                 :          0 :         up_read_non_owner(&NFS_I(d_inode(dentry->d_parent))->rmdir_sem);
      70                 :          0 :         d_lookup_done(dentry);
      71                 :          0 :         nfs_free_unlinkdata(data);
      72                 :          0 :         dput(dentry);
      73                 :          0 :         nfs_sb_deactive(sb);
      74                 :          0 : }
      75                 :            : 
      76                 :          0 : static void nfs_unlink_prepare(struct rpc_task *task, void *calldata)
      77                 :            : {
      78                 :            :         struct nfs_unlinkdata *data = calldata;
      79                 :          0 :         struct inode *dir = d_inode(data->dentry->d_parent);
      80                 :          0 :         NFS_PROTO(dir)->unlink_rpc_prepare(task, data);
      81                 :          0 : }
      82                 :            : 
      83                 :            : static const struct rpc_call_ops nfs_unlink_ops = {
      84                 :            :         .rpc_call_done = nfs_async_unlink_done,
      85                 :            :         .rpc_release = nfs_async_unlink_release,
      86                 :            :         .rpc_call_prepare = nfs_unlink_prepare,
      87                 :            : };
      88                 :            : 
      89                 :          0 : static void nfs_do_call_unlink(struct inode *inode, struct nfs_unlinkdata *data)
      90                 :            : {
      91                 :          0 :         struct rpc_message msg = {
      92                 :          0 :                 .rpc_argp = &data->args,
      93                 :          0 :                 .rpc_resp = &data->res,
      94                 :          0 :                 .rpc_cred = data->cred,
      95                 :            :         };
      96                 :          0 :         struct rpc_task_setup task_setup_data = {
      97                 :            :                 .rpc_message = &msg,
      98                 :            :                 .callback_ops = &nfs_unlink_ops,
      99                 :            :                 .callback_data = data,
     100                 :            :                 .workqueue = nfsiod_workqueue,
     101                 :            :                 .flags = RPC_TASK_ASYNC,
     102                 :            :         };
     103                 :            :         struct rpc_task *task;
     104                 :          0 :         struct inode *dir = d_inode(data->dentry->d_parent);
     105                 :          0 :         nfs_sb_active(dir->i_sb);
     106                 :          0 :         data->args.fh = NFS_FH(dir);
     107                 :          0 :         nfs_fattr_init(data->res.dir_attr);
     108                 :            : 
     109                 :          0 :         NFS_PROTO(dir)->unlink_setup(&msg, data->dentry, inode);
     110                 :            : 
     111                 :          0 :         task_setup_data.rpc_client = NFS_CLIENT(dir);
     112                 :          0 :         task = rpc_run_task(&task_setup_data);
     113                 :          0 :         if (!IS_ERR(task))
     114                 :          0 :                 rpc_put_task_async(task);
     115                 :          0 : }
     116                 :            : 
     117                 :          0 : static int nfs_call_unlink(struct dentry *dentry, struct inode *inode, struct nfs_unlinkdata *data)
     118                 :            : {
     119                 :          0 :         struct inode *dir = d_inode(dentry->d_parent);
     120                 :            :         struct dentry *alias;
     121                 :            : 
     122                 :          0 :         down_read_non_owner(&NFS_I(dir)->rmdir_sem);
     123                 :          0 :         alias = d_alloc_parallel(dentry->d_parent, &data->args.name, &data->wq);
     124                 :          0 :         if (IS_ERR(alias)) {
     125                 :          0 :                 up_read_non_owner(&NFS_I(dir)->rmdir_sem);
     126                 :          0 :                 return 0;
     127                 :            :         }
     128                 :          0 :         if (!d_in_lookup(alias)) {
     129                 :            :                 int ret;
     130                 :            :                 void *devname_garbage = NULL;
     131                 :            : 
     132                 :            :                 /*
     133                 :            :                  * Hey, we raced with lookup... See if we need to transfer
     134                 :            :                  * the sillyrename information to the aliased dentry.
     135                 :            :                  */
     136                 :            :                 spin_lock(&alias->d_lock);
     137                 :          0 :                 if (d_really_is_positive(alias) &&
     138                 :          0 :                     !(alias->d_flags & DCACHE_NFSFS_RENAMED)) {
     139                 :          0 :                         devname_garbage = alias->d_fsdata;
     140                 :          0 :                         alias->d_fsdata = data;
     141                 :          0 :                         alias->d_flags |= DCACHE_NFSFS_RENAMED;
     142                 :          0 :                         ret = 1;
     143                 :            :                 } else
     144                 :            :                         ret = 0;
     145                 :            :                 spin_unlock(&alias->d_lock);
     146                 :          0 :                 dput(alias);
     147                 :          0 :                 up_read_non_owner(&NFS_I(dir)->rmdir_sem);
     148                 :            :                 /*
     149                 :            :                  * If we'd displaced old cached devname, free it.  At that
     150                 :            :                  * point dentry is definitely not a root, so we won't need
     151                 :            :                  * that anymore.
     152                 :            :                  */
     153                 :          0 :                 kfree(devname_garbage);
     154                 :          0 :                 return ret;
     155                 :            :         }
     156                 :          0 :         data->dentry = alias;
     157                 :          0 :         nfs_do_call_unlink(inode, data);
     158                 :          0 :         return 1;
     159                 :            : }
     160                 :            : 
     161                 :            : /**
     162                 :            :  * nfs_async_unlink - asynchronous unlinking of a file
     163                 :            :  * @dentry: parent directory of dentry
     164                 :            :  * @name: name of dentry to unlink
     165                 :            :  */
     166                 :            : static int
     167                 :          0 : nfs_async_unlink(struct dentry *dentry, const struct qstr *name)
     168                 :            : {
     169                 :            :         struct nfs_unlinkdata *data;
     170                 :            :         int status = -ENOMEM;
     171                 :            :         void *devname_garbage = NULL;
     172                 :            : 
     173                 :          0 :         data = kzalloc(sizeof(*data), GFP_KERNEL);
     174                 :          0 :         if (data == NULL)
     175                 :            :                 goto out;
     176                 :          0 :         data->args.name.name = kstrdup(name->name, GFP_KERNEL);
     177                 :          0 :         if (!data->args.name.name)
     178                 :            :                 goto out_free;
     179                 :          0 :         data->args.name.len = name->len;
     180                 :            : 
     181                 :          0 :         data->cred = get_current_cred();
     182                 :          0 :         data->res.dir_attr = &data->dir_attr;
     183                 :          0 :         init_waitqueue_head(&data->wq);
     184                 :            : 
     185                 :            :         status = -EBUSY;
     186                 :            :         spin_lock(&dentry->d_lock);
     187                 :          0 :         if (dentry->d_flags & DCACHE_NFSFS_RENAMED)
     188                 :            :                 goto out_unlock;
     189                 :          0 :         dentry->d_flags |= DCACHE_NFSFS_RENAMED;
     190                 :          0 :         devname_garbage = dentry->d_fsdata;
     191                 :          0 :         dentry->d_fsdata = data;
     192                 :            :         spin_unlock(&dentry->d_lock);
     193                 :            :         /*
     194                 :            :          * If we'd displaced old cached devname, free it.  At that
     195                 :            :          * point dentry is definitely not a root, so we won't need
     196                 :            :          * that anymore.
     197                 :            :          */
     198                 :          0 :         kfree(devname_garbage);
     199                 :          0 :         return 0;
     200                 :            : out_unlock:
     201                 :            :         spin_unlock(&dentry->d_lock);
     202                 :          0 :         put_cred(data->cred);
     203                 :          0 :         kfree(data->args.name.name);
     204                 :            : out_free:
     205                 :          0 :         kfree(data);
     206                 :            : out:
     207                 :          0 :         return status;
     208                 :            : }
     209                 :            : 
     210                 :            : /**
     211                 :            :  * nfs_complete_unlink - Initialize completion of the sillydelete
     212                 :            :  * @dentry: dentry to delete
     213                 :            :  * @inode: inode
     214                 :            :  *
     215                 :            :  * Since we're most likely to be called by dentry_iput(), we
     216                 :            :  * only use the dentry to find the sillydelete. We then copy the name
     217                 :            :  * into the qstr.
     218                 :            :  */
     219                 :            : void
     220                 :          0 : nfs_complete_unlink(struct dentry *dentry, struct inode *inode)
     221                 :            : {
     222                 :            :         struct nfs_unlinkdata   *data;
     223                 :            : 
     224                 :            :         spin_lock(&dentry->d_lock);
     225                 :          0 :         dentry->d_flags &= ~DCACHE_NFSFS_RENAMED;
     226                 :          0 :         data = dentry->d_fsdata;
     227                 :          0 :         dentry->d_fsdata = NULL;
     228                 :            :         spin_unlock(&dentry->d_lock);
     229                 :            : 
     230                 :          0 :         if (NFS_STALE(inode) || !nfs_call_unlink(dentry, inode, data))
     231                 :          0 :                 nfs_free_unlinkdata(data);
     232                 :          0 : }
     233                 :            : 
     234                 :            : /* Cancel a queued async unlink. Called when a sillyrename run fails. */
     235                 :            : static void
     236                 :          0 : nfs_cancel_async_unlink(struct dentry *dentry)
     237                 :            : {
     238                 :            :         spin_lock(&dentry->d_lock);
     239                 :          0 :         if (dentry->d_flags & DCACHE_NFSFS_RENAMED) {
     240                 :          0 :                 struct nfs_unlinkdata *data = dentry->d_fsdata;
     241                 :            : 
     242                 :          0 :                 dentry->d_flags &= ~DCACHE_NFSFS_RENAMED;
     243                 :          0 :                 dentry->d_fsdata = NULL;
     244                 :            :                 spin_unlock(&dentry->d_lock);
     245                 :          0 :                 nfs_free_unlinkdata(data);
     246                 :          0 :                 return;
     247                 :            :         }
     248                 :            :         spin_unlock(&dentry->d_lock);
     249                 :            : }
     250                 :            : 
     251                 :            : /**
     252                 :            :  * nfs_async_rename_done - Sillyrename post-processing
     253                 :            :  * @task: rpc_task of the sillyrename
     254                 :            :  * @calldata: nfs_renamedata for the sillyrename
     255                 :            :  *
     256                 :            :  * Do the directory attribute updates and the d_move
     257                 :            :  */
     258                 :          0 : static void nfs_async_rename_done(struct rpc_task *task, void *calldata)
     259                 :            : {
     260                 :            :         struct nfs_renamedata *data = calldata;
     261                 :          0 :         struct inode *old_dir = data->old_dir;
     262                 :          0 :         struct inode *new_dir = data->new_dir;
     263                 :          0 :         struct dentry *old_dentry = data->old_dentry;
     264                 :            : 
     265                 :          0 :         trace_nfs_sillyrename_rename(old_dir, old_dentry,
     266                 :          0 :                         new_dir, data->new_dentry, task->tk_status);
     267                 :          0 :         if (!NFS_PROTO(old_dir)->rename_done(task, old_dir, new_dir)) {
     268                 :          0 :                 rpc_restart_call_prepare(task);
     269                 :          0 :                 return;
     270                 :            :         }
     271                 :            : 
     272                 :          0 :         if (data->complete)
     273                 :          0 :                 data->complete(task, data);
     274                 :            : }
     275                 :            : 
     276                 :            : /**
     277                 :            :  * nfs_async_rename_release - Release the sillyrename data.
     278                 :            :  * @calldata: the struct nfs_renamedata to be released
     279                 :            :  */
     280                 :          0 : static void nfs_async_rename_release(void *calldata)
     281                 :            : {
     282                 :            :         struct nfs_renamedata   *data = calldata;
     283                 :          0 :         struct super_block *sb = data->old_dir->i_sb;
     284                 :            : 
     285                 :          0 :         if (d_really_is_positive(data->old_dentry))
     286                 :          0 :                 nfs_mark_for_revalidate(d_inode(data->old_dentry));
     287                 :            : 
     288                 :            :         /* The result of the rename is unknown. Play it safe by
     289                 :            :          * forcing a new lookup */
     290                 :          0 :         if (data->cancelled) {
     291                 :          0 :                 spin_lock(&data->old_dir->i_lock);
     292                 :          0 :                 nfs_force_lookup_revalidate(data->old_dir);
     293                 :          0 :                 spin_unlock(&data->old_dir->i_lock);
     294                 :          0 :                 if (data->new_dir != data->old_dir) {
     295                 :            :                         spin_lock(&data->new_dir->i_lock);
     296                 :          0 :                         nfs_force_lookup_revalidate(data->new_dir);
     297                 :          0 :                         spin_unlock(&data->new_dir->i_lock);
     298                 :            :                 }
     299                 :            :         }
     300                 :            : 
     301                 :          0 :         dput(data->old_dentry);
     302                 :          0 :         dput(data->new_dentry);
     303                 :          0 :         iput(data->old_dir);
     304                 :          0 :         iput(data->new_dir);
     305                 :          0 :         nfs_sb_deactive(sb);
     306                 :          0 :         put_cred(data->cred);
     307                 :          0 :         kfree(data);
     308                 :          0 : }
     309                 :            : 
     310                 :          0 : static void nfs_rename_prepare(struct rpc_task *task, void *calldata)
     311                 :            : {
     312                 :            :         struct nfs_renamedata *data = calldata;
     313                 :          0 :         NFS_PROTO(data->old_dir)->rename_rpc_prepare(task, data);
     314                 :          0 : }
     315                 :            : 
     316                 :            : static const struct rpc_call_ops nfs_rename_ops = {
     317                 :            :         .rpc_call_done = nfs_async_rename_done,
     318                 :            :         .rpc_release = nfs_async_rename_release,
     319                 :            :         .rpc_call_prepare = nfs_rename_prepare,
     320                 :            : };
     321                 :            : 
     322                 :            : /**
     323                 :            :  * nfs_async_rename - perform an asynchronous rename operation
     324                 :            :  * @old_dir: directory that currently holds the dentry to be renamed
     325                 :            :  * @new_dir: target directory for the rename
     326                 :            :  * @old_dentry: original dentry to be renamed
     327                 :            :  * @new_dentry: dentry to which the old_dentry should be renamed
     328                 :            :  * @complete: Function to run on successful completion
     329                 :            :  *
     330                 :            :  * It's expected that valid references to the dentries and inodes are held
     331                 :            :  */
     332                 :            : struct rpc_task *
     333                 :          0 : nfs_async_rename(struct inode *old_dir, struct inode *new_dir,
     334                 :            :                  struct dentry *old_dentry, struct dentry *new_dentry,
     335                 :            :                  void (*complete)(struct rpc_task *, struct nfs_renamedata *))
     336                 :            : {
     337                 :            :         struct nfs_renamedata *data;
     338                 :          0 :         struct rpc_message msg = { };
     339                 :          0 :         struct rpc_task_setup task_setup_data = {
     340                 :            :                 .rpc_message = &msg,
     341                 :            :                 .callback_ops = &nfs_rename_ops,
     342                 :            :                 .workqueue = nfsiod_workqueue,
     343                 :            :                 .rpc_client = NFS_CLIENT(old_dir),
     344                 :            :                 .flags = RPC_TASK_ASYNC,
     345                 :            :         };
     346                 :            : 
     347                 :          0 :         data = kzalloc(sizeof(*data), GFP_KERNEL);
     348                 :          0 :         if (data == NULL)
     349                 :            :                 return ERR_PTR(-ENOMEM);
     350                 :          0 :         task_setup_data.callback_data = data;
     351                 :            : 
     352                 :          0 :         data->cred = get_current_cred();
     353                 :            : 
     354                 :          0 :         msg.rpc_argp = &data->args;
     355                 :          0 :         msg.rpc_resp = &data->res;
     356                 :          0 :         msg.rpc_cred = data->cred;
     357                 :            : 
     358                 :            :         /* set up nfs_renamedata */
     359                 :          0 :         data->old_dir = old_dir;
     360                 :          0 :         ihold(old_dir);
     361                 :          0 :         data->new_dir = new_dir;
     362                 :          0 :         ihold(new_dir);
     363                 :          0 :         data->old_dentry = dget(old_dentry);
     364                 :          0 :         data->new_dentry = dget(new_dentry);
     365                 :          0 :         nfs_fattr_init(&data->old_fattr);
     366                 :          0 :         nfs_fattr_init(&data->new_fattr);
     367                 :          0 :         data->complete = complete;
     368                 :            : 
     369                 :            :         /* set up nfs_renameargs */
     370                 :          0 :         data->args.old_dir = NFS_FH(old_dir);
     371                 :          0 :         data->args.old_name = &old_dentry->d_name;
     372                 :          0 :         data->args.new_dir = NFS_FH(new_dir);
     373                 :          0 :         data->args.new_name = &new_dentry->d_name;
     374                 :            : 
     375                 :            :         /* set up nfs_renameres */
     376                 :          0 :         data->res.old_fattr = &data->old_fattr;
     377                 :          0 :         data->res.new_fattr = &data->new_fattr;
     378                 :            : 
     379                 :          0 :         nfs_sb_active(old_dir->i_sb);
     380                 :            : 
     381                 :          0 :         NFS_PROTO(data->old_dir)->rename_setup(&msg, old_dentry, new_dentry);
     382                 :            : 
     383                 :          0 :         return rpc_run_task(&task_setup_data);
     384                 :            : }
     385                 :            : 
     386                 :            : /*
     387                 :            :  * Perform tasks needed when a sillyrename is done such as cancelling the
     388                 :            :  * queued async unlink if it failed.
     389                 :            :  */
     390                 :            : static void
     391                 :          0 : nfs_complete_sillyrename(struct rpc_task *task, struct nfs_renamedata *data)
     392                 :            : {
     393                 :          0 :         struct dentry *dentry = data->old_dentry;
     394                 :            : 
     395                 :          0 :         if (task->tk_status != 0) {
     396                 :          0 :                 nfs_cancel_async_unlink(dentry);
     397                 :          0 :                 return;
     398                 :            :         }
     399                 :            : }
     400                 :            : 
     401                 :            : #define SILLYNAME_PREFIX ".nfs"
     402                 :            : #define SILLYNAME_PREFIX_LEN ((unsigned)sizeof(SILLYNAME_PREFIX) - 1)
     403                 :            : #define SILLYNAME_FILEID_LEN ((unsigned)sizeof(u64) << 1)
     404                 :            : #define SILLYNAME_COUNTER_LEN ((unsigned)sizeof(unsigned int) << 1)
     405                 :            : #define SILLYNAME_LEN (SILLYNAME_PREFIX_LEN + \
     406                 :            :                 SILLYNAME_FILEID_LEN + \
     407                 :            :                 SILLYNAME_COUNTER_LEN)
     408                 :            : 
     409                 :            : /**
     410                 :            :  * nfs_sillyrename - Perform a silly-rename of a dentry
     411                 :            :  * @dir: inode of directory that contains dentry
     412                 :            :  * @dentry: dentry to be sillyrenamed
     413                 :            :  *
     414                 :            :  * NFSv2/3 is stateless and the server doesn't know when the client is
     415                 :            :  * holding a file open. To prevent application problems when a file is
     416                 :            :  * unlinked while it's still open, the client performs a "silly-rename".
     417                 :            :  * That is, it renames the file to a hidden file in the same directory,
     418                 :            :  * and only performs the unlink once the last reference to it is put.
     419                 :            :  *
     420                 :            :  * The final cleanup is done during dentry_iput.
     421                 :            :  *
     422                 :            :  * (Note: NFSv4 is stateful, and has opens, so in theory an NFSv4 server
     423                 :            :  * could take responsibility for keeping open files referenced.  The server
     424                 :            :  * would also need to ensure that opened-but-deleted files were kept over
     425                 :            :  * reboots.  However, we may not assume a server does so.  (RFC 5661
     426                 :            :  * does provide an OPEN4_RESULT_PRESERVE_UNLINKED flag that a server can
     427                 :            :  * use to advertise that it does this; some day we may take advantage of
     428                 :            :  * it.))
     429                 :            :  */
     430                 :            : int
     431                 :          0 : nfs_sillyrename(struct inode *dir, struct dentry *dentry)
     432                 :            : {
     433                 :            :         static unsigned int sillycounter;
     434                 :            :         unsigned char silly[SILLYNAME_LEN + 1];
     435                 :            :         unsigned long long fileid;
     436                 :            :         struct dentry *sdentry;
     437                 :            :         struct inode *inode = d_inode(dentry);
     438                 :            :         struct rpc_task *task;
     439                 :            :         int            error = -EBUSY;
     440                 :            : 
     441                 :            :         dfprintk(VFS, "NFS: silly-rename(%pd2, ct=%d)\n",
     442                 :            :                 dentry, d_count(dentry));
     443                 :          0 :         nfs_inc_stats(dir, NFSIOS_SILLYRENAME);
     444                 :            : 
     445                 :            :         /*
     446                 :            :          * We don't allow a dentry to be silly-renamed twice.
     447                 :            :          */
     448                 :          0 :         if (dentry->d_flags & DCACHE_NFSFS_RENAMED)
     449                 :            :                 goto out;
     450                 :            : 
     451                 :            :         fileid = NFS_FILEID(d_inode(dentry));
     452                 :            : 
     453                 :            :         sdentry = NULL;
     454                 :            :         do {
     455                 :            :                 int slen;
     456                 :          0 :                 dput(sdentry);
     457                 :          0 :                 sillycounter++;
     458                 :          0 :                 slen = scnprintf(silly, sizeof(silly),
     459                 :            :                                 SILLYNAME_PREFIX "%0*llx%0*x",
     460                 :            :                                 SILLYNAME_FILEID_LEN, fileid,
     461                 :            :                                 SILLYNAME_COUNTER_LEN, sillycounter);
     462                 :            : 
     463                 :            :                 dfprintk(VFS, "NFS: trying to rename %pd to %s\n",
     464                 :            :                                 dentry, silly);
     465                 :            : 
     466                 :          0 :                 sdentry = lookup_one_len(silly, dentry->d_parent, slen);
     467                 :            :                 /*
     468                 :            :                  * N.B. Better to return EBUSY here ... it could be
     469                 :            :                  * dangerous to delete the file while it's in use.
     470                 :            :                  */
     471                 :          0 :                 if (IS_ERR(sdentry))
     472                 :            :                         goto out;
     473                 :          0 :         } while (d_inode(sdentry) != NULL); /* need negative lookup */
     474                 :            : 
     475                 :          0 :         ihold(inode);
     476                 :            : 
     477                 :            :         /* queue unlink first. Can't do this from rpc_release as it
     478                 :            :          * has to allocate memory
     479                 :            :          */
     480                 :          0 :         error = nfs_async_unlink(dentry, &sdentry->d_name);
     481                 :          0 :         if (error)
     482                 :            :                 goto out_dput;
     483                 :            : 
     484                 :            :         /* run the rename task, undo unlink if it fails */
     485                 :          0 :         task = nfs_async_rename(dir, dir, dentry, sdentry,
     486                 :            :                                         nfs_complete_sillyrename);
     487                 :          0 :         if (IS_ERR(task)) {
     488                 :            :                 error = -EBUSY;
     489                 :          0 :                 nfs_cancel_async_unlink(dentry);
     490                 :          0 :                 goto out_dput;
     491                 :            :         }
     492                 :            : 
     493                 :            :         /* wait for the RPC task to complete, unless a SIGKILL intervenes */
     494                 :            :         error = rpc_wait_for_completion_task(task);
     495                 :          0 :         if (error == 0)
     496                 :          0 :                 error = task->tk_status;
     497                 :          0 :         switch (error) {
     498                 :            :         case 0:
     499                 :            :                 /* The rename succeeded */
     500                 :            :                 nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
     501                 :            :                 spin_lock(&inode->i_lock);
     502                 :          0 :                 NFS_I(inode)->attr_gencount = nfs_inc_attr_generation_counter();
     503                 :          0 :                 NFS_I(inode)->cache_validity |= NFS_INO_INVALID_CHANGE
     504                 :            :                         | NFS_INO_INVALID_CTIME
     505                 :            :                         | NFS_INO_REVAL_FORCED;
     506                 :            :                 spin_unlock(&inode->i_lock);
     507                 :          0 :                 d_move(dentry, sdentry);
     508                 :          0 :                 break;
     509                 :            :         case -ERESTARTSYS:
     510                 :            :                 /* The result of the rename is unknown. Play it safe by
     511                 :            :                  * forcing a new lookup */
     512                 :          0 :                 d_drop(dentry);
     513                 :          0 :                 d_drop(sdentry);
     514                 :            :         }
     515                 :          0 :         rpc_put_task(task);
     516                 :            : out_dput:
     517                 :          0 :         iput(inode);
     518                 :          0 :         dput(sdentry);
     519                 :            : out:
     520                 :          0 :         return error;
     521                 :            : }