LXR linux/fs/afs/dir

   1// SPDX-License-Identifier: GPL-2.0-or-later
   2/* AFS silly rename handling
   3 *
   4 * Copyright (C) 2019 Red Hat, Inc. All Rights Reserved.
   5 * Written by David Howells (dhowells@redhat.com)
   6 * - Derived from NFS's sillyrename.
   7 */
   8
   9#include <linux/kernel.h>
  10#include <linux/fs.h>
  11#include <linux/namei.h>
  12#include <linux/fsnotify.h>
  13#include "internal.h"
  14
  15/*
  16 * Actually perform the silly rename step.
  17 */
  18static int afs_do_silly_rename(struct afs_vnode *dvnode, struct afs_vnode *vnode,
  19                               struct dentry *old, struct dentry *new,
  20                               struct key *key)
  21{
  22        struct afs_fs_cursor fc;
  23        struct afs_status_cb *scb;
  24        int ret = -ERESTARTSYS;
  25
  26        _enter("%pd,%pd", old, new);
  27
  28        scb = kzalloc(sizeof(struct afs_status_cb), GFP_KERNEL);
  29        if (!scb)
  30                return -ENOMEM;
  31
  32        trace_afs_silly_rename(vnode, false);
  33        if (afs_begin_vnode_operation(&fc, dvnode, key, true)) {
  34                afs_dataversion_t dir_data_version = dvnode->status.data_version + 1;
  35
  36                while (afs_select_fileserver(&fc)) {
  37                        fc.cb_break = afs_calc_vnode_cb_break(dvnode);
  38                        afs_fs_rename(&fc, old->d_name.name,
  39                                      dvnode, new->d_name.name,
  40                                      scb, scb);
  41                }
  42
  43                afs_vnode_commit_status(&fc, dvnode, fc.cb_break,
  44                                        &dir_data_version, scb);
  45                ret = afs_end_vnode_operation(&fc);
  46        }
  47
  48        if (ret == 0) {
  49                spin_lock(&old->d_lock);
  50                old->d_flags |= DCACHE_NFSFS_RENAMED;
  51                spin_unlock(&old->d_lock);
  52                if (dvnode->silly_key != key) {
  53                        key_put(dvnode->silly_key);
  54                        dvnode->silly_key = key_get(key);
  55                }
  56
  57                if (test_bit(AFS_VNODE_DIR_VALID, &dvnode->flags))
  58                        afs_edit_dir_remove(dvnode, &old->d_name,
  59                                            afs_edit_dir_for_silly_0);
  60                if (test_bit(AFS_VNODE_DIR_VALID, &dvnode->flags))
  61                        afs_edit_dir_add(dvnode, &new->d_name,
  62                                         &vnode->fid, afs_edit_dir_for_silly_1);
  63        }
  64
  65        kfree(scb);
  66        _leave(" = %d", ret);
  67        return ret;
  68}
  69
  70/**
  71 * afs_sillyrename - Perform a silly-rename of a dentry
  72 *
  73 * AFS is stateless and the server doesn't know when the client is holding a
  74 * file open.  To prevent application problems when a file is unlinked while
  75 * it's still open, the client performs a "silly-rename".  That is, it renames
  76 * the file to a hidden file in the same directory, and only performs the
  77 * unlink once the last reference to it is put.
  78 *
  79 * The final cleanup is done during dentry_iput.
  80 */
  81int afs_sillyrename(struct afs_vnode *dvnode, struct afs_vnode *vnode,
  82                    struct dentry *dentry, struct key *key)
  83{
  84        static unsigned int sillycounter;
  85        struct dentry *sdentry = NULL;
  86        unsigned char silly[16];
  87        int ret = -EBUSY;
  88
  89        _enter("");
  90
  91        /* We don't allow a dentry to be silly-renamed twice. */
  92        if (dentry->d_flags & DCACHE_NFSFS_RENAMED)
  93                return -EBUSY;
  94
  95        sdentry = NULL;
  96        do {
  97                int slen;
  98
  99                dput(sdentry);
 100                sillycounter++;
 101
 102                /* Create a silly name.  Note that the ".__afs" prefix is
 103                 * understood by the salvager and must not be changed.
 104                 */
 105                slen = scnprintf(silly, sizeof(silly), ".__afs%04X", sillycounter);
 106                sdentry = lookup_one_len(silly, dentry->d_parent, slen);
 107
 108                /* N.B. Better to return EBUSY here ... it could be dangerous
 109                 * to delete the file while it's in use.
 110                 */
 111                if (IS_ERR(sdentry))
 112                        goto out;
 113        } while (!d_is_negative(sdentry));
 114
 115        ihold(&vnode->vfs_inode);
 116
 117        ret = afs_do_silly_rename(dvnode, vnode, dentry, sdentry, key);
 118        switch (ret) {
 119        case 0:
 120                /* The rename succeeded. */
 121                d_move(dentry, sdentry);
 122                break;
 123        case -ERESTARTSYS:
 124                /* The result of the rename is unknown. Play it safe by forcing
 125                 * a new lookup.
 126                 */
 127                d_drop(dentry);
 128                d_drop(sdentry);
 129        }
 130
 131        iput(&vnode->vfs_inode);
 132        dput(sdentry);
 133out:
 134        _leave(" = %d", ret);
 135        return ret;
 136}
 137
 138/*
 139 * Tell the server to remove a sillyrename file.
 140 */
 141static int afs_do_silly_unlink(struct afs_vnode *dvnode, struct afs_vnode *vnode,
 142                               struct dentry *dentry, struct key *key)
 143{
 144        struct afs_fs_cursor fc;
 145        struct afs_status_cb *scb;
 146        int ret = -ERESTARTSYS;
 147
 148        _enter("");
 149
 150        scb = kcalloc(2, sizeof(struct afs_status_cb), GFP_KERNEL);
 151        if (!scb)
 152                return -ENOMEM;
 153
 154        trace_afs_silly_rename(vnode, true);
 155        if (afs_begin_vnode_operation(&fc, dvnode, key, false)) {
 156                afs_dataversion_t dir_data_version = dvnode->status.data_version + 1;
 157
 158                while (afs_select_fileserver(&fc)) {
 159                        fc.cb_break = afs_calc_vnode_cb_break(dvnode);
 160
 161                        if (test_bit(AFS_SERVER_FL_IS_YFS, &fc.cbi->server->flags) &&
 162                            !test_bit(AFS_SERVER_FL_NO_RM2, &fc.cbi->server->flags)) {
 163                                yfs_fs_remove_file2(&fc, vnode, dentry->d_name.name,
 164                                                    &scb[0], &scb[1]);
 165                                if (fc.ac.error != -ECONNABORTED ||
 166                                    fc.ac.abort_code != RXGEN_OPCODE)
 167                                        continue;
 168                                set_bit(AFS_SERVER_FL_NO_RM2, &fc.cbi->server->flags);
 169                        }
 170
 171                        afs_fs_remove(&fc, vnode, dentry->d_name.name, false, &scb[0]);
 172                }
 173
 174                afs_vnode_commit_status(&fc, dvnode, fc.cb_break,
 175                                        &dir_data_version, &scb[0]);
 176                ret = afs_end_vnode_operation(&fc);
 177                if (ret == 0) {
 178                        drop_nlink(&vnode->vfs_inode);
 179                        if (vnode->vfs_inode.i_nlink == 0) {
 180                                set_bit(AFS_VNODE_DELETED, &vnode->flags);
 181                                clear_bit(AFS_VNODE_CB_PROMISED, &vnode->flags);
 182                        }
 183                }
 184                if (ret == 0 &&
 185                    test_bit(AFS_VNODE_DIR_VALID, &dvnode->flags))
 186                        afs_edit_dir_remove(dvnode, &dentry->d_name,
 187                                            afs_edit_dir_for_unlink);
 188        }
 189
 190        kfree(scb);
 191        _leave(" = %d", ret);
 192        return ret;
 193}
 194
 195/*
 196 * Remove sillyrename file on iput.
 197 */
 198int afs_silly_iput(struct dentry *dentry, struct inode *inode)
 199{
 200        struct afs_vnode *dvnode = AFS_FS_I(d_inode(dentry->d_parent));
 201        struct afs_vnode *vnode = AFS_FS_I(inode);
 202        struct dentry *alias;
 203        int ret;
 204
 205        DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq);
 206
 207        _enter("%p{%pd},%llx", dentry, dentry, vnode->fid.vnode);
 208
 209        down_read(&dvnode->rmdir_lock);
 210
 211        alias = d_alloc_parallel(dentry->d_parent, &dentry->d_name, &wq);
 212        if (IS_ERR(alias)) {
 213                up_read(&dvnode->rmdir_lock);
 214                return 0;
 215        }
 216
 217        if (!d_in_lookup(alias)) {
 218                /* We raced with lookup...  See if we need to transfer the
 219                 * sillyrename information to the aliased dentry.
 220                 */
 221                ret = 0;
 222                spin_lock(&alias->d_lock);
 223                if (d_really_is_positive(alias) &&
 224                    !(alias->d_flags & DCACHE_NFSFS_RENAMED)) {
 225                        alias->d_flags |= DCACHE_NFSFS_RENAMED;
 226                        ret = 1;
 227                }
 228                spin_unlock(&alias->d_lock);
 229                up_read(&dvnode->rmdir_lock);
 230                dput(alias);
 231                return ret;
 232        }
 233
 234        /* Stop lock-release from complaining. */
 235        spin_lock(&vnode->lock);
 236        vnode->lock_state = AFS_VNODE_LOCK_DELETED;
 237        trace_afs_flock_ev(vnode, NULL, afs_flock_silly_delete, 0);
 238        spin_unlock(&vnode->lock);
 239
 240        afs_do_silly_unlink(dvnode, vnode, dentry, dvnode->silly_key);
 241        up_read(&dvnode->rmdir_lock);
 242        d_lookup_done(alias);
 243        dput(alias);
 244        return 1;
 245}
 246