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