fs/afs/inode.c

   1 /*
   2  * Copyright (c) 2002 Red Hat, Inc. All rights reserved.
   3  *
   4  * This software may be freely redistributed under the terms of the
   5  * GNU General Public License.
   6  *
   7  * You should have received a copy of the GNU General Public License
   8  * along with this program; if not, write to the Free Software
   9  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  10  *
  11  * Authors: David Woodhouse <dwmw2@infradead.org>
  12  *          David Howells <dhowells@redhat.com>
  13  *
  14  */
  15
  16 #include <linux/kernel.h>
  17 #include <linux/module.h>
  18 #include <linux/init.h>
  19 #include <linux/fs.h>
  20 #include <linux/pagemap.h>
  21 #include <linux/sched.h>
  22 #include <linux/mount.h>
  23 #include <linux/namei.h>
  24 #include <linux/iversion.h>
  25 #include "internal.h"
  26 #include "afs_fs.h"
  27
  28 static const struct inode_operations afs_symlink_inode_operations = {
  29         .get_link       = page_get_link,
  30         .listxattr      = afs_listxattr,
  31 };
  32
  33 static noinline void dump_vnode(struct afs_vnode *vnode, struct afs_vnode *parent_vnode)
  34 {
  35         static unsigned long once_only;
  36
  37         pr_warn("kAFS: AFS vnode with undefined type %u\n", vnode->status.type);
  38         pr_warn("kAFS: A=%d m=%o s=%llx v=%llx\n",
  39                 vnode->status.abort_code,
  40                 vnode->status.mode,
  41                 vnode->status.size,
  42                 vnode->status.data_version);
  43         pr_warn("kAFS: vnode %llx:%llx:%x\n",
  44                 vnode->fid.vid,
  45                 vnode->fid.vnode,
  46                 vnode->fid.unique);
  47         if (parent_vnode)
  48                 pr_warn("kAFS: dir %llx:%llx:%x\n",
  49                         parent_vnode->fid.vid,
  50                         parent_vnode->fid.vnode,
  51                         parent_vnode->fid.unique);
  52
  53         if (!test_and_set_bit(0, &once_only))
  54                 dump_stack();
  55 }
  56
  57 /*
  58  * Set the file size and block count.  Estimate the number of 512 bytes blocks
  59  * used, rounded up to nearest 1K for consistency with other AFS clients.
  60  */
  61 static void afs_set_i_size(struct afs_vnode *vnode, u64 size)
  62 {
  63         i_size_write(&vnode->vfs_inode, size);
  64         vnode->vfs_inode.i_blocks = ((size + 1023) >> 10) << 1;
  65 }
  66
  67 /*
  68  * Initialise an inode from the vnode status.
  69  */
  70 static int afs_inode_init_from_status(struct afs_vnode *vnode, struct key *key,
  71                                       struct afs_cb_interest *cbi,
  72                                       struct afs_vnode *parent_vnode,
  73                                       struct afs_status_cb *scb)
  74 {
  75         struct afs_cb_interest *old_cbi = NULL;
  76         struct afs_file_status *status = &scb->status;
  77         struct inode *inode = AFS_VNODE_TO_I(vnode);
  78         struct timespec64 t;
  79
  80         _debug("FS: ft=%d lk=%d sz=%llu ver=%Lu mod=%hu",
  81                status->type,
  82                status->nlink,
  83                (unsigned long long) status->size,
  84                status->data_version,
  85                status->mode);
  86
  87         write_seqlock(&vnode->cb_lock);
  88
  89         vnode->status = *status;
  90
  91         t = status->mtime_client;
  92         inode->i_ctime = t;
  93         inode->i_mtime = t;
  94         inode->i_atime = t;
  95         inode->i_uid = make_kuid(&init_user_ns, status->owner);
  96         inode->i_gid = make_kgid(&init_user_ns, status->group);
  97         set_nlink(&vnode->vfs_inode, status->nlink);
  98
  99         switch (status->type) {
 100         case AFS_FTYPE_FILE:
 101                 inode->i_mode   = S_IFREG | status->mode;
 102                 inode->i_op     = &afs_file_inode_operations;
 103                 inode->i_fop    = &afs_file_operations;
 104                 inode->i_mapping->a_ops = &afs_fs_aops;
 105                 break;
 106         case AFS_FTYPE_DIR:
 107                 inode->i_mode   = S_IFDIR | status->mode;
 108                 inode->i_op     = &afs_dir_inode_operations;
 109                 inode->i_fop    = &afs_dir_file_operations;
 110                 inode->i_mapping->a_ops = &afs_dir_aops;
 111                 break;
 112         case AFS_FTYPE_SYMLINK:
 113                 /* Symlinks with a mode of 0644 are actually mountpoints. */
 114                 if ((status->mode & 0777) == 0644) {
 115                         inode->i_flags |= S_AUTOMOUNT;
 116
 117                         set_bit(AFS_VNODE_MOUNTPOINT, &vnode->flags);
 118
 119                         inode->i_mode   = S_IFDIR | 0555;
 120                         inode->i_op     = &afs_mntpt_inode_operations;
 121                         inode->i_fop    = &afs_mntpt_file_operations;
 122                         inode->i_mapping->a_ops = &afs_fs_aops;
 123                 } else {
 124                         inode->i_mode   = S_IFLNK | status->mode;
 125                         inode->i_op     = &afs_symlink_inode_operations;
 126                         inode->i_mapping->a_ops = &afs_fs_aops;
 127                 }
 128                 inode_nohighmem(inode);
 129                 break;
 130         default:
 131                 dump_vnode(vnode, parent_vnode);
 132                 write_sequnlock(&vnode->cb_lock);
 133                 return afs_protocol_error(NULL, -EBADMSG, afs_eproto_file_type);
 134         }
 135
 136         afs_set_i_size(vnode, status->size);
 137
 138         vnode->invalid_before   = status->data_version;
 139         inode_set_iversion_raw(&vnode->vfs_inode, status->data_version);
 140
 141         if (!scb->have_cb) {
 142                 /* it's a symlink we just created (the fileserver
 143                  * didn't give us a callback) */
 144                 vnode->cb_expires_at = ktime_get_real_seconds();
 145         } else {
 146                 vnode->cb_expires_at = scb->callback.expires_at;
 147                 old_cbi = rcu_dereference_protected(vnode->cb_interest,
 148                                                     lockdep_is_held(&vnode->cb_lock.lock));
 149                 if (cbi != old_cbi)
 150                         rcu_assign_pointer(vnode->cb_interest, afs_get_cb_interest(cbi));
 151                 else
 152                         old_cbi = NULL;
 153                 set_bit(AFS_VNODE_CB_PROMISED, &vnode->flags);
 154         }
 155
 156         write_sequnlock(&vnode->cb_lock);
 157         afs_put_cb_interest(afs_v2net(vnode), old_cbi);
 158         return 0;
 159 }
 160
 161 /*
 162  * Update the core inode struct from a returned status record.
 163  */
 164 static void afs_apply_status(struct afs_fs_cursor *fc,
 165                              struct afs_vnode *vnode,
 166                              struct afs_status_cb *scb,
 167                              const afs_dataversion_t *expected_version)
 168 {
 169         struct afs_file_status *status = &scb->status;
 170         struct timespec64 t;
 171         umode_t mode;
 172         bool data_changed = false;
 173
 174         BUG_ON(test_bit(AFS_VNODE_UNSET, &vnode->flags));
 175
 176         if (status->type != vnode->status.type) {
 177                 pr_warn("Vnode %llx:%llx:%x changed type %u to %u\n",
 178                         vnode->fid.vid,
 179                         vnode->fid.vnode,
 180                         vnode->fid.unique,
 181                         status->type, vnode->status.type);
 182                 afs_protocol_error(NULL, -EBADMSG, afs_eproto_bad_status);
 183                 return;
 184         }
 185
 186         if (status->nlink != vnode->status.nlink)
 187                 set_nlink(&vnode->vfs_inode, status->nlink);
 188
 189         if (status->owner != vnode->status.owner)
 190                 vnode->vfs_inode.i_uid = make_kuid(&init_user_ns, status->owner);
 191
 192         if (status->group != vnode->status.group)
 193                 vnode->vfs_inode.i_gid = make_kgid(&init_user_ns, status->group);
 194
 195         if (status->mode != vnode->status.mode) {
 196                 mode = vnode->vfs_inode.i_mode;
 197                 mode &= ~S_IALLUGO;
 198                 mode |= status->mode;
 199                 WRITE_ONCE(vnode->vfs_inode.i_mode, mode);
 200         }
 201
 202         t = status->mtime_client;
 203         vnode->vfs_inode.i_ctime = t;
 204         vnode->vfs_inode.i_mtime = t;
 205         vnode->vfs_inode.i_atime = t;
 206
 207         if (vnode->status.data_version != status->data_version)
 208                 data_changed = true;
 209
 210         vnode->status = *status;
 211
 212         if (expected_version &&
 213             *expected_version != status->data_version) {
 214                 if (test_bit(AFS_VNODE_CB_PROMISED, &vnode->flags))
 215                         pr_warn("kAFS: vnode modified {%llx:%llu} %llx->%llx %s\n",
 216                                 vnode->fid.vid, vnode->fid.vnode,
 217                                 (unsigned long long)*expected_version,
 218                                 (unsigned long long)status->data_version,
 219                                 fc->type ? fc->type->name : "???");
 220
 221                 vnode->invalid_before = status->data_version;
 222                 if (vnode->status.type == AFS_FTYPE_DIR) {
 223                         if (test_and_clear_bit(AFS_VNODE_DIR_VALID, &vnode->flags))
 224                                 afs_stat_v(vnode, n_inval);
 225                 } else {
 226                         set_bit(AFS_VNODE_ZAP_DATA, &vnode->flags);
 227                 }
 228         } else if (vnode->status.type == AFS_FTYPE_DIR) {
 229                 /* Expected directory change is handled elsewhere so
 230                  * that we can locally edit the directory and save on a
 231                  * download.
 232                  */
 233                 if (test_bit(AFS_VNODE_DIR_VALID, &vnode->flags))
 234                         data_changed = false;
 235         }
 236
 237         if (data_changed) {
 238                 inode_set_iversion_raw(&vnode->vfs_inode, status->data_version);
 239                 afs_set_i_size(vnode, status->size);
 240         }
 241 }
 242
 243 /*
 244  * Apply a callback to a vnode.
 245  */
 246 static void afs_apply_callback(struct afs_fs_cursor *fc,
 247                                struct afs_vnode *vnode,
 248                                struct afs_status_cb *scb,
 249                                unsigned int cb_break)
 250 {
 251         struct afs_cb_interest *old;
 252         struct afs_callback *cb = &scb->callback;
 253
 254         if (!afs_cb_is_broken(cb_break, vnode, fc->cbi)) {
 255                 vnode->cb_expires_at    = cb->expires_at;
 256                 old = rcu_dereference_protected(vnode->cb_interest,
 257                                                 lockdep_is_held(&vnode->cb_lock.lock));
 258                 if (old != fc->cbi) {
 259                         rcu_assign_pointer(vnode->cb_interest, afs_get_cb_interest(fc->cbi));
 260                         afs_put_cb_interest(afs_v2net(vnode), old);
 261                 }
 262                 set_bit(AFS_VNODE_CB_PROMISED, &vnode->flags);
 263         }
 264 }
 265
 266 /*
 267  * Apply the received status and callback to an inode all in the same critical
 268  * section to avoid races with afs_validate().
 269  */
 270 void afs_vnode_commit_status(struct afs_fs_cursor *fc,
 271                              struct afs_vnode *vnode,
 272                              unsigned int cb_break,
 273                              const afs_dataversion_t *expected_version,
 274                              struct afs_status_cb *scb)
 275 {
 276         if (fc->ac.error != 0)
 277                 return;
 278
 279         write_seqlock(&vnode->cb_lock);
 280
 281         if (scb->have_error) {
 282                 if (scb->status.abort_code == VNOVNODE) {
 283                         set_bit(AFS_VNODE_DELETED, &vnode->flags);
 284                         clear_nlink(&vnode->vfs_inode);
 285                         __afs_break_callback(vnode, afs_cb_break_for_deleted);
 286                 }
 287         } else {
 288                 if (scb->have_status)
 289                         afs_apply_status(fc, vnode, scb, expected_version);
 290                 if (scb->have_cb)
 291                         afs_apply_callback(fc, vnode, scb, cb_break);
 292         }
 293
 294         write_sequnlock(&vnode->cb_lock);
 295
 296         if (fc->ac.error == 0 && scb->have_status)
 297                 afs_cache_permit(vnode, fc->key, cb_break, scb);
 298 }
 299
 300 /*
 301  * Fetch file status from the volume.
 302  */
 303 int afs_fetch_status(struct afs_vnode *vnode, struct key *key, bool is_new,
 304                      afs_access_t *_caller_access)
 305 {
 306         struct afs_status_cb *scb;
 307         struct afs_fs_cursor fc;
 308         int ret;
 309
 310         _enter("%s,{%llx:%llu.%u,S=%lx}",
 311                vnode->volume->name,
 312                vnode->fid.vid, vnode->fid.vnode, vnode->fid.unique,
 313                vnode->flags);
 314
 315         scb = kzalloc(sizeof(struct afs_status_cb), GFP_KERNEL);
 316         if (!scb)
 317                 return -ENOMEM;
 318
 319         ret = -ERESTARTSYS;
 320         if (afs_begin_vnode_operation(&fc, vnode, key, true)) {
 321                 afs_dataversion_t data_version = vnode->status.data_version;
 322
 323                 while (afs_select_fileserver(&fc)) {
 324                         fc.cb_break = afs_calc_vnode_cb_break(vnode);
 325                         afs_fs_fetch_file_status(&fc, scb, NULL);
 326                 }
 327
 328                 if (fc.error) {
 329                         /* Do nothing. */
 330                 } else if (is_new) {
 331                         ret = afs_inode_init_from_status(vnode, key, fc.cbi,
 332                                                          NULL, scb);
 333                         fc.error = ret;
 334                         if (ret == 0)
 335                                 afs_cache_permit(vnode, key, fc.cb_break, scb);
 336                 } else {
 337                         afs_vnode_commit_status(&fc, vnode, fc.cb_break,
 338                                                 &data_version, scb);
 339                 }
 340                 afs_check_for_remote_deletion(&fc, vnode);
 341                 ret = afs_end_vnode_operation(&fc);
 342         }
 343
 344         if (ret == 0 && _caller_access)
 345                 *_caller_access = scb->status.caller_access;
 346         kfree(scb);
 347         _leave(" = %d", ret);
 348         return ret;
 349 }
 350
 351 /*
 352  * iget5() comparator
 353  */
 354 int afs_iget5_test(struct inode *inode, void *opaque)
 355 {
 356         struct afs_iget_data *iget_data = opaque;
 357         struct afs_vnode *vnode = AFS_FS_I(inode);
 358
 359         return memcmp(&vnode->fid, &iget_data->fid, sizeof(iget_data->fid)) == 0;
 360 }
 361
 362 /*
 363  * iget5() comparator for inode created by autocell operations
 364  *
 365  * These pseudo inodes don't match anything.
 366  */
 367 static int afs_iget5_pseudo_dir_test(struct inode *inode, void *opaque)
 368 {
 369         return 0;
 370 }
 371
 372 /*
 373  * iget5() inode initialiser
 374  */
 375 static int afs_iget5_set(struct inode *inode, void *opaque)
 376 {
 377         struct afs_iget_data *iget_data = opaque;
 378         struct afs_vnode *vnode = AFS_FS_I(inode);
 379
 380         vnode->fid              = iget_data->fid;
 381         vnode->volume           = iget_data->volume;
 382         vnode->cb_v_break       = iget_data->cb_v_break;
 383         vnode->cb_s_break       = iget_data->cb_s_break;
 384
 385         /* YFS supports 96-bit vnode IDs, but Linux only supports
 386          * 64-bit inode numbers.
 387          */
 388         inode->i_ino            = iget_data->fid.vnode;
 389         inode->i_generation     = iget_data->fid.unique;
 390         return 0;
 391 }
 392
 393 /*
 394  * Create an inode for a dynamic root directory or an autocell dynamic
 395  * automount dir.
 396  */
 397 struct inode *afs_iget_pseudo_dir(struct super_block *sb, bool root)
 398 {
 399         struct afs_super_info *as;
 400         struct afs_vnode *vnode;
 401         struct inode *inode;
 402         static atomic_t afs_autocell_ino;
 403
 404         struct afs_iget_data iget_data = {
 405                 .cb_v_break = 0,
 406                 .cb_s_break = 0,
 407         };
 408
 409         _enter("");
 410
 411         as = sb->s_fs_info;
 412         if (as->volume) {
 413                 iget_data.volume = as->volume;
 414                 iget_data.fid.vid = as->volume->vid;
 415         }
 416         if (root) {
 417                 iget_data.fid.vnode = 1;
 418                 iget_data.fid.unique = 1;
 419         } else {
 420                 iget_data.fid.vnode = atomic_inc_return(&afs_autocell_ino);
 421                 iget_data.fid.unique = 0;
 422         }
 423
 424         inode = iget5_locked(sb, iget_data.fid.vnode,
 425                              afs_iget5_pseudo_dir_test, afs_iget5_set,
 426                              &iget_data);
 427         if (!inode) {
 428                 _leave(" = -ENOMEM");
 429                 return ERR_PTR(-ENOMEM);
 430         }
 431
 432         _debug("GOT INODE %p { ino=%lu, vl=%llx, vn=%llx, u=%x }",
 433                inode, inode->i_ino, iget_data.fid.vid, iget_data.fid.vnode,
 434                iget_data.fid.unique);
 435
 436         vnode = AFS_FS_I(inode);
 437
 438         /* there shouldn't be an existing inode */
 439         BUG_ON(!(inode->i_state & I_NEW));
 440
 441         inode->i_size           = 0;
 442         inode->i_mode           = S_IFDIR | S_IRUGO | S_IXUGO;
 443         if (root) {
 444                 inode->i_op     = &afs_dynroot_inode_operations;
 445                 inode->i_fop    = &simple_dir_operations;
 446         } else {
 447                 inode->i_op     = &afs_autocell_inode_operations;
 448         }
 449         set_nlink(inode, 2);
 450         inode->i_uid            = GLOBAL_ROOT_UID;
 451         inode->i_gid            = GLOBAL_ROOT_GID;
 452         inode->i_ctime = inode->i_atime = inode->i_mtime = current_time(inode);
 453         inode->i_blocks         = 0;
 454         inode_set_iversion_raw(inode, 0);
 455         inode->i_generation     = 0;
 456
 457         set_bit(AFS_VNODE_PSEUDODIR, &vnode->flags);
 458         if (!root) {
 459                 set_bit(AFS_VNODE_MOUNTPOINT, &vnode->flags);
 460                 inode->i_flags |= S_AUTOMOUNT;
 461         }
 462
 463         inode->i_flags |= S_NOATIME;
 464         unlock_new_inode(inode);
 465         _leave(" = %p", inode);
 466         return inode;
 467 }
 468
 469 /*
 470  * Get a cache cookie for an inode.
 471  */
 472 static void afs_get_inode_cache(struct afs_vnode *vnode)
 473 {
 474 #ifdef CONFIG_AFS_FSCACHE
 475         struct {
 476                 u32 vnode_id;
 477                 u32 unique;
 478                 u32 vnode_id_ext[2];    /* Allow for a 96-bit key */
 479         } __packed key;
 480         struct afs_vnode_cache_aux aux;
 481
 482         if (vnode->status.type == AFS_FTYPE_DIR) {
 483                 vnode->cache = NULL;
 484                 return;
 485         }
 486
 487         key.vnode_id            = vnode->fid.vnode;
 488         key.unique              = vnode->fid.unique;
 489         key.vnode_id_ext[0]     = vnode->fid.vnode >> 32;
 490         key.vnode_id_ext[1]     = vnode->fid.vnode_hi;
 491         aux.data_version        = vnode->status.data_version;
 492
 493         vnode->cache = fscache_acquire_cookie(vnode->volume->cache,
 494                                               &afs_vnode_cache_index_def,
 495                                               &key, sizeof(key),
 496                                               &aux, sizeof(aux),
 497                                               vnode, vnode->status.size, true);
 498 #endif
 499 }
 500
 501 /*
 502  * inode retrieval
 503  */
 504 struct inode *afs_iget(struct super_block *sb, struct key *key,
 505                        struct afs_iget_data *iget_data,
 506                        struct afs_status_cb *scb,
 507                        struct afs_cb_interest *cbi,
 508                        struct afs_vnode *parent_vnode)
 509 {
 510         struct afs_super_info *as;
 511         struct afs_vnode *vnode;
 512         struct afs_fid *fid = &iget_data->fid;
 513         struct inode *inode;
 514         int ret;
 515
 516         _enter(",{%llx:%llu.%u},,", fid->vid, fid->vnode, fid->unique);
 517
 518         as = sb->s_fs_info;
 519         iget_data->volume = as->volume;
 520
 521         inode = iget5_locked(sb, fid->vnode, afs_iget5_test, afs_iget5_set,
 522                              iget_data);
 523         if (!inode) {
 524                 _leave(" = -ENOMEM");
 525                 return ERR_PTR(-ENOMEM);
 526         }
 527
 528         _debug("GOT INODE %p { vl=%llx vn=%llx, u=%x }",
 529                inode, fid->vid, fid->vnode, fid->unique);
 530
 531         vnode = AFS_FS_I(inode);
 532
 533         /* deal with an existing inode */
 534         if (!(inode->i_state & I_NEW)) {
 535                 _leave(" = %p", inode);
 536                 return inode;
 537         }
 538
 539         if (!scb) {
 540                 /* it's a remotely extant inode */
 541                 ret = afs_fetch_status(vnode, key, true, NULL);
 542                 if (ret < 0)
 543                         goto bad_inode;
 544         } else {
 545                 ret = afs_inode_init_from_status(vnode, key, cbi, parent_vnode,
 546                                                  scb);
 547                 if (ret < 0)
 548                         goto bad_inode;
 549         }
 550
 551         afs_get_inode_cache(vnode);
 552
 553         /* success */
 554         clear_bit(AFS_VNODE_UNSET, &vnode->flags);
 555         inode->i_flags |= S_NOATIME;
 556         unlock_new_inode(inode);
 557         _leave(" = %p", inode);
 558         return inode;
 559
 560         /* failure */
 561 bad_inode:
 562         iget_failed(inode);
 563         _leave(" = %d [bad]", ret);
 564         return ERR_PTR(ret);
 565 }
 566
 567 /*
 568  * mark the data attached to an inode as obsolete due to a write on the server
 569  * - might also want to ditch all the outstanding writes and dirty pages
 570  */
 571 void afs_zap_data(struct afs_vnode *vnode)
 572 {
 573         _enter("{%llx:%llu}", vnode->fid.vid, vnode->fid.vnode);
 574
 575 #ifdef CONFIG_AFS_FSCACHE
 576         fscache_invalidate(vnode->cache);
 577 #endif
 578
 579         /* nuke all the non-dirty pages that aren't locked, mapped or being
 580          * written back in a regular file and completely discard the pages in a
 581          * directory or symlink */
 582         if (S_ISREG(vnode->vfs_inode.i_mode))
 583                 invalidate_remote_inode(&vnode->vfs_inode);
 584         else
 585                 invalidate_inode_pages2(vnode->vfs_inode.i_mapping);
 586 }
 587
 588 /*
 589  * Check the validity of a vnode/inode.
 590  */
 591 bool afs_check_validity(struct afs_vnode *vnode)
 592 {
 593         struct afs_cb_interest *cbi;
 594         struct afs_server *server;
 595         struct afs_volume *volume = vnode->volume;
 596         enum afs_cb_break_reason need_clear = afs_cb_break_no_break;
 597         time64_t now = ktime_get_real_seconds();
 598         bool valid;
 599         unsigned int cb_break, cb_s_break, cb_v_break;
 600         int seq = 0;
 601
 602         do {
 603                 read_seqbegin_or_lock(&vnode->cb_lock, &seq);
 604                 cb_v_break = READ_ONCE(volume->cb_v_break);
 605                 cb_break = vnode->cb_break;
 606
 607                 if (test_bit(AFS_VNODE_CB_PROMISED, &vnode->flags)) {
 608                         cbi = rcu_dereference(vnode->cb_interest);
 609                         server = rcu_dereference(cbi->server);
 610                         cb_s_break = READ_ONCE(server->cb_s_break);
 611
 612                         if (vnode->cb_s_break != cb_s_break ||
 613                             vnode->cb_v_break != cb_v_break) {
 614                                 vnode->cb_s_break = cb_s_break;
 615                                 vnode->cb_v_break = cb_v_break;
 616                                 need_clear = afs_cb_break_for_vsbreak;
 617                                 valid = false;
 618                         } else if (test_bit(AFS_VNODE_ZAP_DATA, &vnode->flags)) {
 619                                 need_clear = afs_cb_break_for_zap;
 620                                 valid = false;
 621                         } else if (vnode->cb_expires_at - 10 <= now) {
 622                                 need_clear = afs_cb_break_for_lapsed;
 623                                 valid = false;
 624                         } else {
 625                                 valid = true;
 626                         }
 627                 } else if (test_bit(AFS_VNODE_DELETED, &vnode->flags)) {
 628                         valid = true;
 629                 } else {
 630                         vnode->cb_v_break = cb_v_break;
 631                         valid = false;
 632                 }
 633
 634         } while (need_seqretry(&vnode->cb_lock, seq));
 635
 636         done_seqretry(&vnode->cb_lock, seq);
 637
 638         if (need_clear != afs_cb_break_no_break) {
 639                 write_seqlock(&vnode->cb_lock);
 640                 if (cb_break == vnode->cb_break)
 641                         __afs_break_callback(vnode, need_clear);
 642                 else
 643                         trace_afs_cb_miss(&vnode->fid, need_clear);
 644                 write_sequnlock(&vnode->cb_lock);
 645                 valid = false;
 646         }
 647
 648         return valid;
 649 }
 650
 651 /*
 652  * validate a vnode/inode
 653  * - there are several things we need to check
 654  *   - parent dir data changes (rm, rmdir, rename, mkdir, create, link,
 655  *     symlink)
 656  *   - parent dir metadata changed (security changes)
 657  *   - dentry data changed (write, truncate)
 658  *   - dentry metadata changed (security changes)
 659  */
 660 int afs_validate(struct afs_vnode *vnode, struct key *key)
 661 {
 662         bool valid;
 663         int ret;
 664
 665         _enter("{v={%llx:%llu} fl=%lx},%x",
 666                vnode->fid.vid, vnode->fid.vnode, vnode->flags,
 667                key_serial(key));
 668
 669         rcu_read_lock();
 670         valid = afs_check_validity(vnode);
 671         rcu_read_unlock();
 672
 673         if (test_bit(AFS_VNODE_DELETED, &vnode->flags))
 674                 clear_nlink(&vnode->vfs_inode);
 675
 676         if (valid)
 677                 goto valid;
 678
 679         down_write(&vnode->validate_lock);
 680
 681         /* if the promise has expired, we need to check the server again to get
 682          * a new promise - note that if the (parent) directory's metadata was
 683          * changed then the security may be different and we may no longer have
 684          * access */
 685         if (!test_bit(AFS_VNODE_CB_PROMISED, &vnode->flags)) {
 686                 _debug("not promised");
 687                 ret = afs_fetch_status(vnode, key, false, NULL);
 688                 if (ret < 0) {
 689                         if (ret == -ENOENT) {
 690                                 set_bit(AFS_VNODE_DELETED, &vnode->flags);
 691                                 ret = -ESTALE;
 692                         }
 693                         goto error_unlock;
 694                 }
 695                 _debug("new promise [fl=%lx]", vnode->flags);
 696         }
 697
 698         if (test_bit(AFS_VNODE_DELETED, &vnode->flags)) {
 699                 _debug("file already deleted");
 700                 ret = -ESTALE;
 701                 goto error_unlock;
 702         }
 703
 704         /* if the vnode's data version number changed then its contents are
 705          * different */
 706         if (test_and_clear_bit(AFS_VNODE_ZAP_DATA, &vnode->flags))
 707                 afs_zap_data(vnode);
 708         up_write(&vnode->validate_lock);
 709 valid:
 710         _leave(" = 0");
 711         return 0;
 712
 713 error_unlock:
 714         up_write(&vnode->validate_lock);
 715         _leave(" = %d", ret);
 716         return ret;
 717 }
 718
 719 /*
 720  * read the attributes of an inode
 721  */
 722 int afs_getattr(const struct path *path, struct kstat *stat,
 723                 u32 request_mask, unsigned int query_flags)
 724 {
 725         struct inode *inode = d_inode(path->dentry);
 726         struct afs_vnode *vnode = AFS_FS_I(inode);
 727         int seq = 0;
 728
 729         _enter("{ ino=%lu v=%u }", inode->i_ino, inode->i_generation);
 730
 731         do {
 732                 read_seqbegin_or_lock(&vnode->cb_lock, &seq);
 733                 generic_fillattr(inode, stat);
 734         } while (need_seqretry(&vnode->cb_lock, seq));
 735
 736         done_seqretry(&vnode->cb_lock, seq);
 737         return 0;
 738 }
 739
 740 /*
 741  * discard an AFS inode
 742  */
 743 int afs_drop_inode(struct inode *inode)
 744 {
 745         _enter("");
 746
 747         if (test_bit(AFS_VNODE_PSEUDODIR, &AFS_FS_I(inode)->flags))
 748                 return generic_delete_inode(inode);
 749         else
 750                 return generic_drop_inode(inode);
 751 }
 752
 753 /*
 754  * clear an AFS inode
 755  */
 756 void afs_evict_inode(struct inode *inode)
 757 {
 758         struct afs_cb_interest *cbi;
 759         struct afs_vnode *vnode;
 760
 761         vnode = AFS_FS_I(inode);
 762
 763         _enter("{%llx:%llu.%d}",
 764                vnode->fid.vid,
 765                vnode->fid.vnode,
 766                vnode->fid.unique);
 767
 768         _debug("CLEAR INODE %p", inode);
 769
 770         ASSERTCMP(inode->i_ino, ==, vnode->fid.vnode);
 771
 772         truncate_inode_pages_final(&inode->i_data);
 773         clear_inode(inode);
 774
 775         write_seqlock(&vnode->cb_lock);
 776         cbi = rcu_dereference_protected(vnode->cb_interest,
 777                                         lockdep_is_held(&vnode->cb_lock.lock));
 778         if (cbi) {
 779                 afs_put_cb_interest(afs_i2net(inode), cbi);
 780                 rcu_assign_pointer(vnode->cb_interest, NULL);
 781         }
 782         write_sequnlock(&vnode->cb_lock);
 783
 784         while (!list_empty(&vnode->wb_keys)) {
 785                 struct afs_wb_key *wbk = list_entry(vnode->wb_keys.next,
 786                                                     struct afs_wb_key, vnode_link);
 787                 list_del(&wbk->vnode_link);
 788                 afs_put_wb_key(wbk);
 789         }
 790
 791 #ifdef CONFIG_AFS_FSCACHE
 792         {
 793                 struct afs_vnode_cache_aux aux;
 794
 795                 aux.data_version = vnode->status.data_version;
 796                 fscache_relinquish_cookie(vnode->cache, &aux,
 797                                           test_bit(AFS_VNODE_DELETED, &vnode->flags));
 798                 vnode->cache = NULL;
 799         }
 800 #endif
 801
 802         afs_prune_wb_keys(vnode);
 803         afs_put_permits(rcu_access_pointer(vnode->permit_cache));
 804         key_put(vnode->silly_key);
 805         vnode->silly_key = NULL;
 806         key_put(vnode->lock_key);
 807         vnode->lock_key = NULL;
 808         _leave("");
 809 }
 810
 811 /*
 812  * set the attributes of an inode
 813  */
 814 int afs_setattr(struct dentry *dentry, struct iattr *attr)
 815 {
 816         struct afs_fs_cursor fc;
 817         struct afs_status_cb *scb;
 818         struct afs_vnode *vnode = AFS_FS_I(d_inode(dentry));
 819         struct key *key;
 820         int ret = -ENOMEM;
 821
 822         _enter("{%llx:%llu},{n=%pd},%x",
 823                vnode->fid.vid, vnode->fid.vnode, dentry,
 824                attr->ia_valid);
 825
 826         if (!(attr->ia_valid & (ATTR_SIZE | ATTR_MODE | ATTR_UID | ATTR_GID |
 827                                 ATTR_MTIME))) {
 828                 _leave(" = 0 [unsupported]");
 829                 return 0;
 830         }
 831
 832         scb = kzalloc(sizeof(struct afs_status_cb), GFP_KERNEL);
 833         if (!scb)
 834                 goto error;
 835
 836         /* flush any dirty data outstanding on a regular file */
 837         if (S_ISREG(vnode->vfs_inode.i_mode))
 838                 filemap_write_and_wait(vnode->vfs_inode.i_mapping);
 839
 840         if (attr->ia_valid & ATTR_FILE) {
 841                 key = afs_file_key(attr->ia_file);
 842         } else {
 843                 key = afs_request_key(vnode->volume->cell);
 844                 if (IS_ERR(key)) {
 845                         ret = PTR_ERR(key);
 846                         goto error_scb;
 847                 }
 848         }
 849
 850         ret = -ERESTARTSYS;
 851         if (afs_begin_vnode_operation(&fc, vnode, key, false)) {
 852                 afs_dataversion_t data_version = vnode->status.data_version;
 853
 854                 if (attr->ia_valid & ATTR_SIZE)
 855                         data_version++;
 856
 857                 while (afs_select_fileserver(&fc)) {
 858                         fc.cb_break = afs_calc_vnode_cb_break(vnode);
 859                         afs_fs_setattr(&fc, attr, scb);
 860                 }
 861
 862                 afs_check_for_remote_deletion(&fc, vnode);
 863                 afs_vnode_commit_status(&fc, vnode, fc.cb_break,
 864                                         &data_version, scb);
 865                 ret = afs_end_vnode_operation(&fc);
 866         }
 867
 868         if (!(attr->ia_valid & ATTR_FILE))
 869                 key_put(key);
 870
 871 error_scb:
 872         kfree(scb);
 873 error:
 874         _leave(" = %d", ret);
 875         return ret;
 876 }