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 } 877