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
,
33 * Initialise an inode from the vnode status.
35 static int afs_inode_init_from_status(struct afs_vnode
*vnode
, struct key
*key
)
37 struct inode
*inode
= AFS_VNODE_TO_I(vnode
);
39 _debug("FS: ft=%d lk=%d sz=%llu ver=%Lu mod=%hu",
42 (unsigned long long) vnode
->status
.size
,
43 vnode
->status
.data_version
,
46 read_seqlock_excl(&vnode
->cb_lock
);
48 afs_update_inode_from_status(vnode
, &vnode
->status
, NULL
,
49 AFS_VNODE_NOT_YET_SET
);
51 switch (vnode
->status
.type
) {
53 inode
->i_mode
= S_IFREG
| vnode
->status
.mode
;
54 inode
->i_op
= &afs_file_inode_operations
;
55 inode
->i_fop
= &afs_file_operations
;
56 inode
->i_mapping
->a_ops
= &afs_fs_aops
;
59 inode
->i_mode
= S_IFDIR
| vnode
->status
.mode
;
60 inode
->i_op
= &afs_dir_inode_operations
;
61 inode
->i_fop
= &afs_dir_file_operations
;
62 inode
->i_mapping
->a_ops
= &afs_dir_aops
;
64 case AFS_FTYPE_SYMLINK
:
65 /* Symlinks with a mode of 0644 are actually mountpoints. */
66 if ((vnode
->status
.mode
& 0777) == 0644) {
67 inode
->i_flags
|= S_AUTOMOUNT
;
69 set_bit(AFS_VNODE_MOUNTPOINT
, &vnode
->flags
);
71 inode
->i_mode
= S_IFDIR
| 0555;
72 inode
->i_op
= &afs_mntpt_inode_operations
;
73 inode
->i_fop
= &afs_mntpt_file_operations
;
74 inode
->i_mapping
->a_ops
= &afs_fs_aops
;
76 inode
->i_mode
= S_IFLNK
| vnode
->status
.mode
;
77 inode
->i_op
= &afs_symlink_inode_operations
;
78 inode
->i_mapping
->a_ops
= &afs_fs_aops
;
80 inode_nohighmem(inode
);
83 printk("kAFS: AFS vnode with undefined type\n");
84 read_sequnlock_excl(&vnode
->cb_lock
);
85 return afs_protocol_error(NULL
, -EBADMSG
, afs_eproto_file_type
);
89 vnode
->invalid_before
= vnode
->status
.data_version
;
91 read_sequnlock_excl(&vnode
->cb_lock
);
96 * Fetch file status from the volume.
98 int afs_fetch_status(struct afs_vnode
*vnode
, struct key
*key
, bool new_inode
)
100 struct afs_fs_cursor fc
;
103 _enter("%s,{%llx:%llu.%u,S=%lx}",
105 vnode
->fid
.vid
, vnode
->fid
.vnode
, vnode
->fid
.unique
,
109 if (afs_begin_vnode_operation(&fc
, vnode
, key
)) {
110 while (afs_select_fileserver(&fc
)) {
111 fc
.cb_break
= afs_calc_vnode_cb_break(vnode
);
112 afs_fs_fetch_file_status(&fc
, NULL
, new_inode
);
115 afs_check_for_remote_deletion(&fc
, fc
.vnode
);
116 afs_vnode_commit_status(&fc
, vnode
, fc
.cb_break
);
117 ret
= afs_end_vnode_operation(&fc
);
120 _leave(" = %d", ret
);
127 int afs_iget5_test(struct inode
*inode
, void *opaque
)
129 struct afs_iget_data
*data
= opaque
;
130 struct afs_vnode
*vnode
= AFS_FS_I(inode
);
132 return memcmp(&vnode
->fid
, &data
->fid
, sizeof(data
->fid
)) == 0;
136 * iget5() comparator for inode created by autocell operations
138 * These pseudo inodes don't match anything.
140 static int afs_iget5_pseudo_dir_test(struct inode
*inode
, void *opaque
)
146 * iget5() inode initialiser
148 static int afs_iget5_set(struct inode
*inode
, void *opaque
)
150 struct afs_iget_data
*data
= opaque
;
151 struct afs_vnode
*vnode
= AFS_FS_I(inode
);
153 vnode
->fid
= data
->fid
;
154 vnode
->volume
= data
->volume
;
156 /* YFS supports 96-bit vnode IDs, but Linux only supports
157 * 64-bit inode numbers.
159 inode
->i_ino
= data
->fid
.vnode
;
160 inode
->i_generation
= data
->fid
.unique
;
165 * Create an inode for a dynamic root directory or an autocell dynamic
168 struct inode
*afs_iget_pseudo_dir(struct super_block
*sb
, bool root
)
170 struct afs_iget_data data
;
171 struct afs_super_info
*as
;
172 struct afs_vnode
*vnode
;
174 static atomic_t afs_autocell_ino
;
180 data
.volume
= as
->volume
;
181 data
.fid
.vid
= as
->volume
->vid
;
187 data
.fid
.vnode
= atomic_inc_return(&afs_autocell_ino
);
191 inode
= iget5_locked(sb
, data
.fid
.vnode
,
192 afs_iget5_pseudo_dir_test
, afs_iget5_set
,
195 _leave(" = -ENOMEM");
196 return ERR_PTR(-ENOMEM
);
199 _debug("GOT INODE %p { ino=%lu, vl=%llx, vn=%llx, u=%x }",
200 inode
, inode
->i_ino
, data
.fid
.vid
, data
.fid
.vnode
,
203 vnode
= AFS_FS_I(inode
);
205 /* there shouldn't be an existing inode */
206 BUG_ON(!(inode
->i_state
& I_NEW
));
209 inode
->i_mode
= S_IFDIR
| S_IRUGO
| S_IXUGO
;
211 inode
->i_op
= &afs_dynroot_inode_operations
;
212 inode
->i_fop
= &afs_dynroot_file_operations
;
214 inode
->i_op
= &afs_autocell_inode_operations
;
217 inode
->i_uid
= GLOBAL_ROOT_UID
;
218 inode
->i_gid
= GLOBAL_ROOT_GID
;
219 inode
->i_ctime
.tv_sec
= get_seconds();
220 inode
->i_ctime
.tv_nsec
= 0;
221 inode
->i_atime
= inode
->i_mtime
= inode
->i_ctime
;
223 inode_set_iversion_raw(inode
, 0);
224 inode
->i_generation
= 0;
226 set_bit(AFS_VNODE_PSEUDODIR
, &vnode
->flags
);
228 set_bit(AFS_VNODE_MOUNTPOINT
, &vnode
->flags
);
229 inode
->i_flags
|= S_AUTOMOUNT
;
232 inode
->i_flags
|= S_NOATIME
;
233 unlock_new_inode(inode
);
234 _leave(" = %p", inode
);
239 * Get a cache cookie for an inode.
241 static void afs_get_inode_cache(struct afs_vnode
*vnode
)
243 #ifdef CONFIG_AFS_FSCACHE
247 u32 vnode_id_ext
[2]; /* Allow for a 96-bit key */
249 struct afs_vnode_cache_aux aux
;
251 if (vnode
->status
.type
== AFS_FTYPE_DIR
) {
256 key
.vnode_id
= vnode
->fid
.vnode
;
257 key
.unique
= vnode
->fid
.unique
;
258 key
.vnode_id_ext
[0] = vnode
->fid
.vnode
>> 32;
259 key
.vnode_id_ext
[1] = vnode
->fid
.vnode_hi
;
260 aux
.data_version
= vnode
->status
.data_version
;
262 vnode
->cache
= fscache_acquire_cookie(vnode
->volume
->cache
,
263 &afs_vnode_cache_index_def
,
266 vnode
, vnode
->status
.size
, true);
273 struct inode
*afs_iget(struct super_block
*sb
, struct key
*key
,
274 struct afs_fid
*fid
, struct afs_file_status
*status
,
275 struct afs_callback
*cb
, struct afs_cb_interest
*cbi
)
277 struct afs_iget_data data
= { .fid
= *fid
};
278 struct afs_super_info
*as
;
279 struct afs_vnode
*vnode
;
283 _enter(",{%llx:%llu.%u},,", fid
->vid
, fid
->vnode
, fid
->unique
);
286 data
.volume
= as
->volume
;
288 inode
= iget5_locked(sb
, fid
->vnode
, afs_iget5_test
, afs_iget5_set
,
291 _leave(" = -ENOMEM");
292 return ERR_PTR(-ENOMEM
);
295 _debug("GOT INODE %p { vl=%llx vn=%llx, u=%x }",
296 inode
, fid
->vid
, fid
->vnode
, fid
->unique
);
298 vnode
= AFS_FS_I(inode
);
300 /* deal with an existing inode */
301 if (!(inode
->i_state
& I_NEW
)) {
302 _leave(" = %p", inode
);
307 /* it's a remotely extant inode */
308 ret
= afs_fetch_status(vnode
, key
, true);
312 /* it's an inode we just created */
313 memcpy(&vnode
->status
, status
, sizeof(vnode
->status
));
316 /* it's a symlink we just created (the fileserver
317 * didn't give us a callback) */
318 vnode
->cb_version
= 0;
320 vnode
->cb_expires_at
= ktime_get();
322 vnode
->cb_version
= cb
->version
;
323 vnode
->cb_type
= cb
->type
;
324 vnode
->cb_expires_at
= cb
->expires_at
;
325 vnode
->cb_interest
= afs_get_cb_interest(cbi
);
326 set_bit(AFS_VNODE_CB_PROMISED
, &vnode
->flags
);
329 vnode
->cb_expires_at
+= ktime_get_real_seconds();
332 ret
= afs_inode_init_from_status(vnode
, key
);
336 afs_get_inode_cache(vnode
);
339 clear_bit(AFS_VNODE_UNSET
, &vnode
->flags
);
340 inode
->i_flags
|= S_NOATIME
;
341 unlock_new_inode(inode
);
342 _leave(" = %p [CB { v=%u t=%u }]", inode
, vnode
->cb_version
, vnode
->cb_type
);
348 _leave(" = %d [bad]", ret
);
353 * mark the data attached to an inode as obsolete due to a write on the server
354 * - might also want to ditch all the outstanding writes and dirty pages
356 void afs_zap_data(struct afs_vnode
*vnode
)
358 _enter("{%llx:%llu}", vnode
->fid
.vid
, vnode
->fid
.vnode
);
360 #ifdef CONFIG_AFS_FSCACHE
361 fscache_invalidate(vnode
->cache
);
364 /* nuke all the non-dirty pages that aren't locked, mapped or being
365 * written back in a regular file and completely discard the pages in a
366 * directory or symlink */
367 if (S_ISREG(vnode
->vfs_inode
.i_mode
))
368 invalidate_remote_inode(&vnode
->vfs_inode
);
370 invalidate_inode_pages2(vnode
->vfs_inode
.i_mapping
);
374 * validate a vnode/inode
375 * - there are several things we need to check
376 * - parent dir data changes (rm, rmdir, rename, mkdir, create, link,
378 * - parent dir metadata changed (security changes)
379 * - dentry data changed (write, truncate)
380 * - dentry metadata changed (security changes)
382 int afs_validate(struct afs_vnode
*vnode
, struct key
*key
)
384 time64_t now
= ktime_get_real_seconds();
388 _enter("{v={%llx:%llu} fl=%lx},%x",
389 vnode
->fid
.vid
, vnode
->fid
.vnode
, vnode
->flags
,
392 /* Quickly check the callback state. Ideally, we'd use read_seqbegin
393 * here, but we have no way to pass the net namespace to the RCU
394 * cleanup for the server record.
396 read_seqlock_excl(&vnode
->cb_lock
);
398 if (test_bit(AFS_VNODE_CB_PROMISED
, &vnode
->flags
)) {
399 if (vnode
->cb_s_break
!= vnode
->cb_interest
->server
->cb_s_break
||
400 vnode
->cb_v_break
!= vnode
->volume
->cb_v_break
) {
401 vnode
->cb_s_break
= vnode
->cb_interest
->server
->cb_s_break
;
402 vnode
->cb_v_break
= vnode
->volume
->cb_v_break
;
404 } else if (vnode
->status
.type
== AFS_FTYPE_DIR
&&
405 (!test_bit(AFS_VNODE_DIR_VALID
, &vnode
->flags
) ||
406 vnode
->cb_expires_at
- 10 <= now
)) {
408 } else if (test_bit(AFS_VNODE_ZAP_DATA
, &vnode
->flags
) ||
409 vnode
->cb_expires_at
- 10 <= now
) {
414 } else if (test_bit(AFS_VNODE_DELETED
, &vnode
->flags
)) {
417 vnode
->cb_s_break
= vnode
->cb_interest
->server
->cb_s_break
;
418 vnode
->cb_v_break
= vnode
->volume
->cb_v_break
;
422 read_sequnlock_excl(&vnode
->cb_lock
);
424 if (test_bit(AFS_VNODE_DELETED
, &vnode
->flags
))
425 clear_nlink(&vnode
->vfs_inode
);
430 down_write(&vnode
->validate_lock
);
432 /* if the promise has expired, we need to check the server again to get
433 * a new promise - note that if the (parent) directory's metadata was
434 * changed then the security may be different and we may no longer have
436 if (!test_bit(AFS_VNODE_CB_PROMISED
, &vnode
->flags
)) {
437 _debug("not promised");
438 ret
= afs_fetch_status(vnode
, key
, false);
440 if (ret
== -ENOENT
) {
441 set_bit(AFS_VNODE_DELETED
, &vnode
->flags
);
446 _debug("new promise [fl=%lx]", vnode
->flags
);
449 if (test_bit(AFS_VNODE_DELETED
, &vnode
->flags
)) {
450 _debug("file already deleted");
455 /* if the vnode's data version number changed then its contents are
457 if (test_and_clear_bit(AFS_VNODE_ZAP_DATA
, &vnode
->flags
))
459 up_write(&vnode
->validate_lock
);
465 up_write(&vnode
->validate_lock
);
466 _leave(" = %d", ret
);
471 * read the attributes of an inode
473 int afs_getattr(const struct path
*path
, struct kstat
*stat
,
474 u32 request_mask
, unsigned int query_flags
)
476 struct inode
*inode
= d_inode(path
->dentry
);
477 struct afs_vnode
*vnode
= AFS_FS_I(inode
);
480 _enter("{ ino=%lu v=%u }", inode
->i_ino
, inode
->i_generation
);
483 read_seqbegin_or_lock(&vnode
->cb_lock
, &seq
);
484 generic_fillattr(inode
, stat
);
485 } while (need_seqretry(&vnode
->cb_lock
, seq
));
487 done_seqretry(&vnode
->cb_lock
, seq
);
492 * discard an AFS inode
494 int afs_drop_inode(struct inode
*inode
)
498 if (test_bit(AFS_VNODE_PSEUDODIR
, &AFS_FS_I(inode
)->flags
))
499 return generic_delete_inode(inode
);
501 return generic_drop_inode(inode
);
507 void afs_evict_inode(struct inode
*inode
)
509 struct afs_vnode
*vnode
;
511 vnode
= AFS_FS_I(inode
);
513 _enter("{%llx:%llu.%d}",
518 _debug("CLEAR INODE %p", inode
);
520 ASSERTCMP(inode
->i_ino
, ==, vnode
->fid
.vnode
);
522 truncate_inode_pages_final(&inode
->i_data
);
525 if (vnode
->cb_interest
) {
526 afs_put_cb_interest(afs_i2net(inode
), vnode
->cb_interest
);
527 vnode
->cb_interest
= NULL
;
530 while (!list_empty(&vnode
->wb_keys
)) {
531 struct afs_wb_key
*wbk
= list_entry(vnode
->wb_keys
.next
,
532 struct afs_wb_key
, vnode_link
);
533 list_del(&wbk
->vnode_link
);
537 #ifdef CONFIG_AFS_FSCACHE
539 struct afs_vnode_cache_aux aux
;
541 aux
.data_version
= vnode
->status
.data_version
;
542 fscache_relinquish_cookie(vnode
->cache
, &aux
,
543 test_bit(AFS_VNODE_DELETED
, &vnode
->flags
));
548 afs_put_permits(rcu_access_pointer(vnode
->permit_cache
));
553 * set the attributes of an inode
555 int afs_setattr(struct dentry
*dentry
, struct iattr
*attr
)
557 struct afs_fs_cursor fc
;
558 struct afs_vnode
*vnode
= AFS_FS_I(d_inode(dentry
));
562 _enter("{%llx:%llu},{n=%pd},%x",
563 vnode
->fid
.vid
, vnode
->fid
.vnode
, dentry
,
566 if (!(attr
->ia_valid
& (ATTR_SIZE
| ATTR_MODE
| ATTR_UID
| ATTR_GID
|
568 _leave(" = 0 [unsupported]");
572 /* flush any dirty data outstanding on a regular file */
573 if (S_ISREG(vnode
->vfs_inode
.i_mode
))
574 filemap_write_and_wait(vnode
->vfs_inode
.i_mapping
);
576 if (attr
->ia_valid
& ATTR_FILE
) {
577 key
= afs_file_key(attr
->ia_file
);
579 key
= afs_request_key(vnode
->volume
->cell
);
587 if (afs_begin_vnode_operation(&fc
, vnode
, key
)) {
588 while (afs_select_fileserver(&fc
)) {
589 fc
.cb_break
= afs_calc_vnode_cb_break(vnode
);
590 afs_fs_setattr(&fc
, attr
);
593 afs_check_for_remote_deletion(&fc
, fc
.vnode
);
594 afs_vnode_commit_status(&fc
, vnode
, fc
.cb_break
);
595 ret
= afs_end_vnode_operation(&fc
);
598 if (!(attr
->ia_valid
& ATTR_FILE
))
602 _leave(" = %d", ret
);