2 * Copyright (c) 2002 Red Hat, Inc. All rights reserved.
4 * This software may be freely redistributed under the terms of the
5 * GNU General Public License.
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.
11 * Authors: David Woodhouse <dwmw2@infradead.org>
12 * David Howells <dhowells@redhat.com>
16 #include <linux/kernel.h>
17 #include <linux/module.h>
18 #include <linux/init.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>
27 static const struct inode_operations afs_symlink_inode_operations
= {
28 .get_link
= page_get_link
,
29 .listxattr
= afs_listxattr
,
32 static noinline
void dump_vnode(struct afs_vnode
*vnode
, struct afs_vnode
*parent_vnode
)
34 static unsigned long once_only
;
36 pr_warn("kAFS: AFS vnode with undefined type %u\n",
38 pr_warn("kAFS: A=%d m=%o s=%llx v=%llx\n",
39 vnode
->status
.abort_code
,
42 vnode
->status
.data_version
);
43 pr_warn("kAFS: vnode %llx:%llx:%x\n",
48 pr_warn("kAFS: dir %llx:%llx:%x\n",
49 parent_vnode
->fid
.vid
,
50 parent_vnode
->fid
.vnode
,
51 parent_vnode
->fid
.unique
);
53 if (!test_and_set_bit(0, &once_only
))
58 * Initialise an inode from the vnode status.
60 static int afs_inode_init_from_status(struct afs_vnode
*vnode
, struct key
*key
,
61 struct afs_vnode
*parent_vnode
)
63 struct inode
*inode
= AFS_VNODE_TO_I(vnode
);
65 _debug("FS: ft=%d lk=%d sz=%llu ver=%Lu mod=%hu",
68 (unsigned long long) vnode
->status
.size
,
69 vnode
->status
.data_version
,
72 read_seqlock_excl(&vnode
->cb_lock
);
74 afs_update_inode_from_status(vnode
, &vnode
->status
, NULL
,
75 AFS_VNODE_NOT_YET_SET
);
77 switch (vnode
->status
.type
) {
79 inode
->i_mode
= S_IFREG
| vnode
->status
.mode
;
80 inode
->i_op
= &afs_file_inode_operations
;
81 inode
->i_fop
= &afs_file_operations
;
82 inode
->i_mapping
->a_ops
= &afs_fs_aops
;
85 inode
->i_mode
= S_IFDIR
| vnode
->status
.mode
;
86 inode
->i_op
= &afs_dir_inode_operations
;
87 inode
->i_fop
= &afs_dir_file_operations
;
88 inode
->i_mapping
->a_ops
= &afs_dir_aops
;
90 case AFS_FTYPE_SYMLINK
:
91 /* Symlinks with a mode of 0644 are actually mountpoints. */
92 if ((vnode
->status
.mode
& 0777) == 0644) {
93 inode
->i_flags
|= S_AUTOMOUNT
;
95 set_bit(AFS_VNODE_MOUNTPOINT
, &vnode
->flags
);
97 inode
->i_mode
= S_IFDIR
| 0555;
98 inode
->i_op
= &afs_mntpt_inode_operations
;
99 inode
->i_fop
= &afs_mntpt_file_operations
;
100 inode
->i_mapping
->a_ops
= &afs_fs_aops
;
102 inode
->i_mode
= S_IFLNK
| vnode
->status
.mode
;
103 inode
->i_op
= &afs_symlink_inode_operations
;
104 inode
->i_mapping
->a_ops
= &afs_fs_aops
;
106 inode_nohighmem(inode
);
109 dump_vnode(vnode
, parent_vnode
);
110 read_sequnlock_excl(&vnode
->cb_lock
);
111 return afs_protocol_error(NULL
, -EBADMSG
, afs_eproto_file_type
);
115 * Estimate 512 bytes blocks used, rounded up to nearest 1K
116 * for consistency with other AFS clients.
118 inode
->i_blocks
= ((i_size_read(inode
) + 1023) >> 10) << 1;
119 vnode
->invalid_before
= vnode
->status
.data_version
;
121 read_sequnlock_excl(&vnode
->cb_lock
);
126 * Fetch file status from the volume.
128 int afs_fetch_status(struct afs_vnode
*vnode
, struct key
*key
, bool new_inode
)
130 struct afs_fs_cursor fc
;
133 _enter("%s,{%llx:%llu.%u,S=%lx}",
135 vnode
->fid
.vid
, vnode
->fid
.vnode
, vnode
->fid
.unique
,
139 if (afs_begin_vnode_operation(&fc
, vnode
, key
, true)) {
140 while (afs_select_fileserver(&fc
)) {
141 fc
.cb_break
= afs_calc_vnode_cb_break(vnode
);
142 afs_fs_fetch_file_status(&fc
, NULL
, new_inode
);
145 afs_check_for_remote_deletion(&fc
, fc
.vnode
);
146 afs_vnode_commit_status(&fc
, vnode
, fc
.cb_break
);
147 ret
= afs_end_vnode_operation(&fc
);
150 _leave(" = %d", ret
);
157 int afs_iget5_test(struct inode
*inode
, void *opaque
)
159 struct afs_iget_data
*data
= opaque
;
160 struct afs_vnode
*vnode
= AFS_FS_I(inode
);
162 return memcmp(&vnode
->fid
, &data
->fid
, sizeof(data
->fid
)) == 0;
166 * iget5() comparator for inode created by autocell operations
168 * These pseudo inodes don't match anything.
170 static int afs_iget5_pseudo_dir_test(struct inode
*inode
, void *opaque
)
176 * iget5() inode initialiser
178 static int afs_iget5_set(struct inode
*inode
, void *opaque
)
180 struct afs_iget_data
*data
= opaque
;
181 struct afs_vnode
*vnode
= AFS_FS_I(inode
);
183 vnode
->fid
= data
->fid
;
184 vnode
->volume
= data
->volume
;
186 /* YFS supports 96-bit vnode IDs, but Linux only supports
187 * 64-bit inode numbers.
189 inode
->i_ino
= data
->fid
.vnode
;
190 inode
->i_generation
= data
->fid
.unique
;
195 * Create an inode for a dynamic root directory or an autocell dynamic
198 struct inode
*afs_iget_pseudo_dir(struct super_block
*sb
, bool root
)
200 struct afs_iget_data data
;
201 struct afs_super_info
*as
;
202 struct afs_vnode
*vnode
;
204 static atomic_t afs_autocell_ino
;
210 data
.volume
= as
->volume
;
211 data
.fid
.vid
= as
->volume
->vid
;
217 data
.fid
.vnode
= atomic_inc_return(&afs_autocell_ino
);
221 inode
= iget5_locked(sb
, data
.fid
.vnode
,
222 afs_iget5_pseudo_dir_test
, afs_iget5_set
,
225 _leave(" = -ENOMEM");
226 return ERR_PTR(-ENOMEM
);
229 _debug("GOT INODE %p { ino=%lu, vl=%llx, vn=%llx, u=%x }",
230 inode
, inode
->i_ino
, data
.fid
.vid
, data
.fid
.vnode
,
233 vnode
= AFS_FS_I(inode
);
235 /* there shouldn't be an existing inode */
236 BUG_ON(!(inode
->i_state
& I_NEW
));
239 inode
->i_mode
= S_IFDIR
| S_IRUGO
| S_IXUGO
;
241 inode
->i_op
= &afs_dynroot_inode_operations
;
242 inode
->i_fop
= &afs_dynroot_file_operations
;
244 inode
->i_op
= &afs_autocell_inode_operations
;
247 inode
->i_uid
= GLOBAL_ROOT_UID
;
248 inode
->i_gid
= GLOBAL_ROOT_GID
;
249 inode
->i_ctime
= inode
->i_atime
= inode
->i_mtime
= current_time(inode
);
251 inode_set_iversion_raw(inode
, 0);
252 inode
->i_generation
= 0;
254 set_bit(AFS_VNODE_PSEUDODIR
, &vnode
->flags
);
256 set_bit(AFS_VNODE_MOUNTPOINT
, &vnode
->flags
);
257 inode
->i_flags
|= S_AUTOMOUNT
;
260 inode
->i_flags
|= S_NOATIME
;
261 unlock_new_inode(inode
);
262 _leave(" = %p", inode
);
267 * Get a cache cookie for an inode.
269 static void afs_get_inode_cache(struct afs_vnode
*vnode
)
271 #ifdef CONFIG_AFS_FSCACHE
275 u32 vnode_id_ext
[2]; /* Allow for a 96-bit key */
277 struct afs_vnode_cache_aux aux
;
279 if (vnode
->status
.type
== AFS_FTYPE_DIR
) {
284 key
.vnode_id
= vnode
->fid
.vnode
;
285 key
.unique
= vnode
->fid
.unique
;
286 key
.vnode_id_ext
[0] = vnode
->fid
.vnode
>> 32;
287 key
.vnode_id_ext
[1] = vnode
->fid
.vnode_hi
;
288 aux
.data_version
= vnode
->status
.data_version
;
290 vnode
->cache
= fscache_acquire_cookie(vnode
->volume
->cache
,
291 &afs_vnode_cache_index_def
,
294 vnode
, vnode
->status
.size
, true);
301 struct inode
*afs_iget(struct super_block
*sb
, struct key
*key
,
302 struct afs_fid
*fid
, struct afs_file_status
*status
,
303 struct afs_callback
*cb
, struct afs_cb_interest
*cbi
,
304 struct afs_vnode
*parent_vnode
)
306 struct afs_iget_data data
= { .fid
= *fid
};
307 struct afs_super_info
*as
;
308 struct afs_vnode
*vnode
;
312 _enter(",{%llx:%llu.%u},,", fid
->vid
, fid
->vnode
, fid
->unique
);
315 data
.volume
= as
->volume
;
317 inode
= iget5_locked(sb
, fid
->vnode
, afs_iget5_test
, afs_iget5_set
,
320 _leave(" = -ENOMEM");
321 return ERR_PTR(-ENOMEM
);
324 _debug("GOT INODE %p { vl=%llx vn=%llx, u=%x }",
325 inode
, fid
->vid
, fid
->vnode
, fid
->unique
);
327 vnode
= AFS_FS_I(inode
);
329 /* deal with an existing inode */
330 if (!(inode
->i_state
& I_NEW
)) {
331 _leave(" = %p", inode
);
336 /* it's a remotely extant inode */
337 ret
= afs_fetch_status(vnode
, key
, true);
341 /* it's an inode we just created */
342 memcpy(&vnode
->status
, status
, sizeof(vnode
->status
));
345 /* it's a symlink we just created (the fileserver
346 * didn't give us a callback) */
347 vnode
->cb_version
= 0;
349 vnode
->cb_expires_at
= ktime_get();
351 vnode
->cb_version
= cb
->version
;
352 vnode
->cb_type
= cb
->type
;
353 vnode
->cb_expires_at
= cb
->expires_at
;
354 vnode
->cb_interest
= afs_get_cb_interest(cbi
);
355 set_bit(AFS_VNODE_CB_PROMISED
, &vnode
->flags
);
358 vnode
->cb_expires_at
+= ktime_get_real_seconds();
361 ret
= afs_inode_init_from_status(vnode
, key
, parent_vnode
);
365 afs_get_inode_cache(vnode
);
368 clear_bit(AFS_VNODE_UNSET
, &vnode
->flags
);
369 inode
->i_flags
|= S_NOATIME
;
370 unlock_new_inode(inode
);
371 _leave(" = %p [CB { v=%u t=%u }]", inode
, vnode
->cb_version
, vnode
->cb_type
);
377 _leave(" = %d [bad]", ret
);
382 * mark the data attached to an inode as obsolete due to a write on the server
383 * - might also want to ditch all the outstanding writes and dirty pages
385 void afs_zap_data(struct afs_vnode
*vnode
)
387 _enter("{%llx:%llu}", vnode
->fid
.vid
, vnode
->fid
.vnode
);
389 #ifdef CONFIG_AFS_FSCACHE
390 fscache_invalidate(vnode
->cache
);
393 /* nuke all the non-dirty pages that aren't locked, mapped or being
394 * written back in a regular file and completely discard the pages in a
395 * directory or symlink */
396 if (S_ISREG(vnode
->vfs_inode
.i_mode
))
397 invalidate_remote_inode(&vnode
->vfs_inode
);
399 invalidate_inode_pages2(vnode
->vfs_inode
.i_mapping
);
403 * validate a vnode/inode
404 * - there are several things we need to check
405 * - parent dir data changes (rm, rmdir, rename, mkdir, create, link,
407 * - parent dir metadata changed (security changes)
408 * - dentry data changed (write, truncate)
409 * - dentry metadata changed (security changes)
411 int afs_validate(struct afs_vnode
*vnode
, struct key
*key
)
413 time64_t now
= ktime_get_real_seconds();
417 _enter("{v={%llx:%llu} fl=%lx},%x",
418 vnode
->fid
.vid
, vnode
->fid
.vnode
, vnode
->flags
,
421 /* Quickly check the callback state. Ideally, we'd use read_seqbegin
422 * here, but we have no way to pass the net namespace to the RCU
423 * cleanup for the server record.
425 read_seqlock_excl(&vnode
->cb_lock
);
427 if (test_bit(AFS_VNODE_CB_PROMISED
, &vnode
->flags
)) {
428 if (vnode
->cb_s_break
!= vnode
->cb_interest
->server
->cb_s_break
||
429 vnode
->cb_v_break
!= vnode
->volume
->cb_v_break
) {
430 vnode
->cb_s_break
= vnode
->cb_interest
->server
->cb_s_break
;
431 vnode
->cb_v_break
= vnode
->volume
->cb_v_break
;
433 } else if (test_bit(AFS_VNODE_ZAP_DATA
, &vnode
->flags
)) {
435 } else if (vnode
->cb_expires_at
- 10 <= now
) {
440 } else if (test_bit(AFS_VNODE_DELETED
, &vnode
->flags
)) {
443 vnode
->cb_v_break
= vnode
->volume
->cb_v_break
;
447 read_sequnlock_excl(&vnode
->cb_lock
);
449 if (test_bit(AFS_VNODE_DELETED
, &vnode
->flags
))
450 clear_nlink(&vnode
->vfs_inode
);
455 down_write(&vnode
->validate_lock
);
457 /* if the promise has expired, we need to check the server again to get
458 * a new promise - note that if the (parent) directory's metadata was
459 * changed then the security may be different and we may no longer have
461 if (!test_bit(AFS_VNODE_CB_PROMISED
, &vnode
->flags
)) {
462 _debug("not promised");
463 ret
= afs_fetch_status(vnode
, key
, false);
465 if (ret
== -ENOENT
) {
466 set_bit(AFS_VNODE_DELETED
, &vnode
->flags
);
471 _debug("new promise [fl=%lx]", vnode
->flags
);
474 if (test_bit(AFS_VNODE_DELETED
, &vnode
->flags
)) {
475 _debug("file already deleted");
480 /* if the vnode's data version number changed then its contents are
482 if (test_and_clear_bit(AFS_VNODE_ZAP_DATA
, &vnode
->flags
))
484 up_write(&vnode
->validate_lock
);
490 up_write(&vnode
->validate_lock
);
491 _leave(" = %d", ret
);
496 * read the attributes of an inode
498 int afs_getattr(const struct path
*path
, struct kstat
*stat
,
499 u32 request_mask
, unsigned int query_flags
)
501 struct inode
*inode
= d_inode(path
->dentry
);
502 struct afs_vnode
*vnode
= AFS_FS_I(inode
);
505 _enter("{ ino=%lu v=%u }", inode
->i_ino
, inode
->i_generation
);
508 read_seqbegin_or_lock(&vnode
->cb_lock
, &seq
);
509 generic_fillattr(inode
, stat
);
510 } while (need_seqretry(&vnode
->cb_lock
, seq
));
512 done_seqretry(&vnode
->cb_lock
, seq
);
517 * discard an AFS inode
519 int afs_drop_inode(struct inode
*inode
)
523 if (test_bit(AFS_VNODE_PSEUDODIR
, &AFS_FS_I(inode
)->flags
))
524 return generic_delete_inode(inode
);
526 return generic_drop_inode(inode
);
532 void afs_evict_inode(struct inode
*inode
)
534 struct afs_vnode
*vnode
;
536 vnode
= AFS_FS_I(inode
);
538 _enter("{%llx:%llu.%d}",
543 _debug("CLEAR INODE %p", inode
);
545 ASSERTCMP(inode
->i_ino
, ==, vnode
->fid
.vnode
);
547 truncate_inode_pages_final(&inode
->i_data
);
550 if (vnode
->cb_interest
) {
551 afs_put_cb_interest(afs_i2net(inode
), vnode
->cb_interest
);
552 vnode
->cb_interest
= NULL
;
555 while (!list_empty(&vnode
->wb_keys
)) {
556 struct afs_wb_key
*wbk
= list_entry(vnode
->wb_keys
.next
,
557 struct afs_wb_key
, vnode_link
);
558 list_del(&wbk
->vnode_link
);
562 #ifdef CONFIG_AFS_FSCACHE
564 struct afs_vnode_cache_aux aux
;
566 aux
.data_version
= vnode
->status
.data_version
;
567 fscache_relinquish_cookie(vnode
->cache
, &aux
,
568 test_bit(AFS_VNODE_DELETED
, &vnode
->flags
));
573 afs_prune_wb_keys(vnode
);
574 afs_put_permits(rcu_access_pointer(vnode
->permit_cache
));
575 key_put(vnode
->silly_key
);
576 vnode
->silly_key
= NULL
;
577 key_put(vnode
->lock_key
);
578 vnode
->lock_key
= NULL
;
583 * set the attributes of an inode
585 int afs_setattr(struct dentry
*dentry
, struct iattr
*attr
)
587 struct afs_fs_cursor fc
;
588 struct afs_vnode
*vnode
= AFS_FS_I(d_inode(dentry
));
592 _enter("{%llx:%llu},{n=%pd},%x",
593 vnode
->fid
.vid
, vnode
->fid
.vnode
, dentry
,
596 if (!(attr
->ia_valid
& (ATTR_SIZE
| ATTR_MODE
| ATTR_UID
| ATTR_GID
|
598 _leave(" = 0 [unsupported]");
602 /* flush any dirty data outstanding on a regular file */
603 if (S_ISREG(vnode
->vfs_inode
.i_mode
))
604 filemap_write_and_wait(vnode
->vfs_inode
.i_mapping
);
606 if (attr
->ia_valid
& ATTR_FILE
) {
607 key
= afs_file_key(attr
->ia_file
);
609 key
= afs_request_key(vnode
->volume
->cell
);
617 if (afs_begin_vnode_operation(&fc
, vnode
, key
, false)) {
618 while (afs_select_fileserver(&fc
)) {
619 fc
.cb_break
= afs_calc_vnode_cb_break(vnode
);
620 afs_fs_setattr(&fc
, attr
);
623 afs_check_for_remote_deletion(&fc
, fc
.vnode
);
624 afs_vnode_commit_status(&fc
, vnode
, fc
.cb_break
);
625 ret
= afs_end_vnode_operation(&fc
);
628 if (!(attr
->ia_valid
& ATTR_FILE
))
632 _leave(" = %d", ret
);