Lines Matching defs:inode
22 * The Ceph metadata servers control client access to inode metadata
24 * to read and/or write both inode field and file data to OSDs
29 * that can be safely read from the cached inode.
32 * client is allowed to change inode attributes (e.g., file size,
39 * In order for a client to cache an inode, it must hold a capability
502 * If I_FLUSH is set, leave the inode at the front of the list.
527 * Queue an inode for immediate writeback. Mark inode with I_FLUSH,
601 * change_auth_cap_ses - move inode to appropriate lists when auth caps change
602 * @ci: inode to be moved
630 void ceph_add_cap(struct inode *inode,
636 struct ceph_mds_client *mdsc = ceph_inode_to_client(inode)->mdsc;
637 struct ceph_inode_info *ci = ceph_inode(inode);
645 dout("add_cap %p mds%d cap %llx %s seq %d\n", inode,
682 * auth mds of the inode changed. we received the cap export
704 * add this inode to the appropriate snap realm
721 realm->inode = inode;
762 dout("add_cap inode %p (%llx.%llx) cap %p %s now %s seq %d mds%d\n",
763 inode, ceph_vinop(inode), cap, ceph_cap_string(issued),
974 struct inode *inode = &ci->vfs_inode;
980 dout("ceph_caps_revoking %p %s = %d\n", inode,
1107 int ceph_is_any_caps(struct inode *inode)
1109 struct ceph_inode_info *ci = ceph_inode(inode);
1127 realm->inode = NULL;
1148 dout("%s: cap inode is NULL\n", __func__);
1156 /* remove from inode's cap rbtree, and clear auth cap */
1327 * Queue cap releases when an inode is dropped from our cache.
1334 * may call __ceph_caps_issued_mask() on a freeing inode. */
1358 struct inode *inode = &ci->vfs_inode;
1368 __func__, inode, cap, cap->session,
1386 arg->ino = ceph_vino(inode).ino;
1392 arg->size = inode->i_size;
1411 arg->mtime = inode->i_mtime;
1412 arg->atime = inode->i_atime;
1413 arg->ctime = inode->i_ctime;
1415 arg->change_attr = inode_peek_iversion_raw(inode);
1427 arg->uid = inode->i_uid;
1428 arg->gid = inode->i_gid;
1429 arg->mode = inode->i_mode;
1448 * Send a cap msg on the given inode.
1455 struct inode *inode = &ci->vfs_inode;
1460 ceph_vinop(inode), ceph_cap_string(arg->dirty),
1476 static inline int __send_flush_snap(struct inode *inode,
1489 arg.ino = ceph_vino(inode).ino;
1544 struct inode *inode = &ci->vfs_inode;
1550 dout("__flush_snaps %p session %p\n", inode, session);
1598 "stop\n", inode, cap, session->s_mds);
1619 inode, capsnap, cf->tid, ceph_cap_string(capsnap->dirty));
1621 ret = __send_flush_snap(inode, session, capsnap, cap->mseq,
1626 ceph_vinop(inode), cf->tid, capsnap->follows);
1637 struct inode *inode = &ci->vfs_inode;
1638 struct ceph_mds_client *mdsc = ceph_inode_to_client(inode)->mdsc;
1643 dout("ceph_flush_snaps %p\n", inode);
1690 /* we flushed them all; remove this inode from the queue */
1698 iput(inode);
1702 * Mark caps dirty. If inode is newly dirty, return the dirty flags.
1711 struct inode *inode = &ci->vfs_inode;
1720 inode, ceph_ino(inode), ceph_cap_string(mask));
1739 dout(" inode %p now dirty snapc %p auth cap %p\n",
1746 ihold(inode);
1790 * Remove cap_flush from the mdsc's or inode's flushing cap list.
1824 * Add dirty inode to the flushing list. Assigned a seq number so we
1829 static u64 __mark_caps_flushing(struct inode *inode,
1833 struct ceph_mds_client *mdsc = ceph_sb_to_client(inode->i_sb)->mdsc;
1834 struct ceph_inode_info *ci = ceph_inode(inode);
1850 dout(" inode %p now !dirty\n", inode);
1877 static int try_nonblocking_invalidate(struct inode *inode)
1881 struct ceph_inode_info *ci = ceph_inode(inode);
1885 ceph_fscache_invalidate(inode);
1886 invalidate_mapping_pages(&inode->i_data, 0, -1);
1889 if (inode->i_data.nrpages == 0 &&
1892 dout("try_nonblocking_invalidate %p success\n", inode);
1897 dout("try_nonblocking_invalidate %p failed\n", inode);
1928 struct inode *inode = &ci->vfs_inode;
1929 struct ceph_mds_client *mdsc = ceph_sb_to_mdsc(inode->i_sb);
1968 if (!mdsc->stopping && inode->i_nlink > 0) {
1971 } else if (S_ISDIR(inode->i_mode) &&
1980 if (IS_RDONLY(inode)) {
2000 " issued %s revoking %s retain %s %s%s\n", inode,
2015 S_ISREG(inode->i_mode) &&
2017 inode->i_data.nrpages && /* have cached pages */
2021 dout("check_caps trying to invalidate on %p\n", inode);
2022 if (try_nonblocking_invalidate(inode) < 0) {
2155 inode);
2166 flush_tid = __mark_caps_flushing(inode, session, false,
2201 ceph_queue_invalidate(inode);
2212 static int try_flush_caps(struct inode *inode, u64 *ptid)
2214 struct ceph_mds_client *mdsc = ceph_sb_to_client(inode->i_sb)->mdsc;
2215 struct ceph_inode_info *ci = ceph_inode(inode);
2250 flush_tid = __mark_caps_flushing(inode, session, true,
2282 static int caps_are_flushed(struct inode *inode, u64 flush_tid)
2284 struct ceph_inode_info *ci = ceph_inode(inode);
2302 static int unsafe_request_wait(struct inode *inode)
2304 struct ceph_mds_client *mdsc = ceph_sb_to_client(inode->i_sb)->mdsc;
2305 struct ceph_inode_info *ci = ceph_inode(inode);
2310 if (S_ISDIR(inode->i_mode) && !list_empty(&ci->i_unsafe_dirops)) {
2395 inode, req1 ? req1->r_tid : 0ULL, req2 ? req2->r_tid : 0ULL);
2419 struct inode *inode = file->f_mapping->host;
2420 struct ceph_inode_info *ci = ceph_inode(inode);
2425 dout("fsync %p%s\n", inode, datasync ? " datasync" : "");
2431 ret = ceph_wait_on_async_create(inode);
2435 dirty = try_flush_caps(inode, &flush_tid);
2438 err = unsafe_request_wait(inode);
2447 caps_are_flushed(inode, flush_tid));
2457 dout("fsync %p%s result=%d\n", inode, datasync ? " datasync" : "", ret);
2463 * queue inode for flush but don't do so immediately, because we can
2467 int ceph_write_inode(struct inode *inode, struct writeback_control *wbc)
2469 struct ceph_inode_info *ci = ceph_inode(inode);
2475 dout("write_inode %p wait=%d\n", inode, wait);
2477 dirty = try_flush_caps(inode, &flush_tid);
2480 caps_are_flushed(inode, flush_tid));
2483 ceph_sb_to_client(inode->i_sb)->mdsc;
2500 struct inode *inode = &ci->vfs_inode;
2523 inode, cap, session->s_mds);
2533 inode, cap, cf->tid, ceph_cap_string(cf->caps));
2548 inode, capsnap, cf->tid,
2554 ret = __send_flush_snap(inode, session, capsnap, cap->mseq,
2560 ceph_vinop(inode), cf->tid,
2728 static int try_get_cap_refs(struct inode *inode, int need, int want,
2731 struct ceph_inode_info *ci = ceph_inode(inode);
2732 struct ceph_mds_client *mdsc = ceph_inode_to_client(inode)->mdsc;
2737 dout("get_cap_refs %p need %s want %s\n", inode,
2745 dout("try_get_cap_refs %p error filelock\n", inode);
2757 __ceph_do_pending_vmtruncate(inode);
2766 inode, endoff, ci->i_max_size);
2776 dout("get_cap_refs %p cap_snap_pending\n", inode);
2791 inode, ceph_cap_string(have), ceph_cap_string(not),
2818 if (S_ISREG(inode->i_mode) &&
2837 inode, ceph_cap_string(need), ci->i_auth_cap->mds);
2843 dout("get_cap_refs %p forced umount\n", inode);
2850 inode, ceph_cap_string(need),
2856 dout("get_cap_refs %p have %s need %s\n", inode,
2872 dout("get_cap_refs %p ret %d got %s\n", inode,
2882 static void check_max_size(struct inode *inode, loff_t endoff)
2884 struct ceph_inode_info *ci = ceph_inode(inode);
2891 inode, endoff);
2915 int ceph_try_get_caps(struct inode *inode, int need, int want,
2925 ret = ceph_pool_perm_check(inode, need);
2934 ret = try_get_cap_refs(inode, need, want, 0, flags, got);
2950 struct inode *inode = file_inode(filp);
2951 struct ceph_inode_info *ci = ceph_inode(inode);
2952 struct ceph_fs_client *fsc = ceph_inode_to_client(inode);
2955 ret = ceph_pool_perm_check(inode, need);
2967 if (vfs_inode_has_locks(inode))
2970 ret = try_get_cap_refs(inode, need, want, endoff,
2978 cw.ino = ceph_ino(inode);
2992 while (!(ret = try_get_cap_refs(inode, need, want,
3021 int ret2 = ceph_wait_on_async_create(inode);
3026 check_max_size(inode, endoff);
3031 ret = ceph_renew_caps(inode, flags);
3041 i_size_read(inode) > 0) {
3043 find_get_page(inode->i_mapping, 0);
3062 ret = __ceph_do_getattr(inode, NULL,
3127 struct inode *inode = &ci->vfs_inode;
3148 inode, ci->i_wb_ref+1, ci->i_wb_ref);
3178 dout("put_cap_refs %p had %s%s%s\n", inode, ceph_cap_string(had),
3190 iput(inode);
3213 struct inode *inode = &ci->vfs_inode;
3239 inode,
3274 inode, capsnap, capsnap->context->seq,
3293 ceph_async_iput(inode);
3298 * Invalidate unlinked inode's aliases, so we can drop the inode ASAP.
3300 static void invalidate_aliases(struct inode *inode)
3304 dout("invalidate_aliases inode %p\n", inode);
3305 d_prune_aliases(inode);
3307 * For non-directory inode, d_find_alias() only returns
3311 * For directory inode, d_find_alias() can return
3312 * unhashed dentry. But directory inode should have
3315 while ((dn = d_find_alias(inode))) {
3351 static void handle_cap_grant(struct inode *inode,
3360 struct ceph_inode_info *ci = ceph_inode(inode);
3375 dout("handle_cap_grant inode %p cap %p mds%d seq %d %s\n",
3376 inode, cap, session->s_mds, seq, ceph_cap_string(newcaps));
3378 inode->i_size);
3386 if (S_ISREG(inode->i_mode) && /* don't invalidate readdir cache */
3390 if (try_nonblocking_invalidate(inode)) {
3404 * auth mds of the inode changed. we received the cap export message,
3424 inode_set_max_iversion_raw(inode, extra_info->change_attr);
3428 inode->i_mode = le32_to_cpu(grant->mode);
3429 inode->i_uid = make_kuid(&init_user_ns, le32_to_cpu(grant->uid));
3430 inode->i_gid = make_kgid(&init_user_ns, le32_to_cpu(grant->gid));
3432 dout("%p mode 0%o uid.gid %d.%d\n", inode, inode->i_mode,
3433 from_kuid(&init_user_ns, inode->i_uid),
3434 from_kgid(&init_user_ns, inode->i_gid));
3439 set_nlink(inode, le32_to_cpu(grant->nlink));
3440 if (inode->i_nlink == 0 &&
3452 version, inode, len);
3457 ceph_forget_all_cached_acls(inode);
3458 ceph_security_invalidate_secctx(inode);
3468 ceph_fill_file_time(inode, extra_info->issued,
3495 queue_trunc = ceph_fill_file_size(inode, extra_info->issued,
3546 if (S_ISREG(inode->i_mode) &&
3614 ceph_fill_inline_data(inode, NULL, extra_info->inline_data,
3618 ceph_queue_vmtruncate(inode);
3622 * queue inode for writeback: we can't actually call
3626 ceph_queue_writeback(inode);
3628 ceph_queue_invalidate(inode);
3630 invalidate_aliases(inode);
3647 static void handle_cap_flush_ack(struct inode *inode, u64 flush_tid,
3653 struct ceph_inode_info *ci = ceph_inode(inode);
3654 struct ceph_mds_client *mdsc = ceph_sb_to_client(inode->i_sb)->mdsc;
3691 dout("handle_cap_flush_ack inode %p mds%d seq %d on %s cleaned %s,"
3693 inode, session->s_mds, seq, ceph_cap_string(dirty),
3719 dout(" inode %p now !flushing\n", inode);
3722 dout(" inode %p now clean\n", inode);
3753 iput(inode);
3756 void __ceph_remove_capsnap(struct inode *inode, struct ceph_cap_snap *capsnap,
3759 struct ceph_inode_info *ci = ceph_inode(inode);
3760 struct ceph_mds_client *mdsc = ceph_sb_to_client(inode->i_sb)->mdsc;
3765 dout("removing capsnap %p, inode %p ci %p\n", capsnap, inode, ci);
3782 void ceph_remove_capsnap(struct inode *inode, struct ceph_cap_snap *capsnap,
3785 struct ceph_inode_info *ci = ceph_inode(inode);
3790 __ceph_remove_capsnap(inode, capsnap, wake_ci, wake_mdsc);
3799 static void handle_cap_flushsnap_ack(struct inode *inode, u64 flush_tid,
3803 struct ceph_inode_info *ci = ceph_inode(inode);
3804 struct ceph_mds_client *mdsc = ceph_sb_to_client(inode->i_sb)->mdsc;
3811 dout("handle_cap_flushsnap_ack inode %p ci %p mds%d follows %lld\n",
3812 inode, ci, session->s_mds, follows);
3831 ceph_remove_capsnap(inode, capsnap, &wake_ci, &wake_mdsc);
3841 iput(inode);
3850 static bool handle_cap_trunc(struct inode *inode,
3854 struct ceph_inode_info *ci = ceph_inode(inode);
3862 int issued = __ceph_caps_issued(ceph_inode(inode), &implemented);
3869 dout("handle_cap_trunc inode %p mds%d seq %d to %lld seq %d\n",
3870 inode, mds, seq, truncate_size, truncate_seq);
3871 queue_trunc = ceph_fill_file_size(inode, issued,
3884 static void handle_cap_export(struct inode *inode, struct ceph_mds_caps *ex,
3888 struct ceph_mds_client *mdsc = ceph_inode_to_client(inode)->mdsc;
3891 struct ceph_inode_info *ci = ceph_inode(inode);
3908 dout("handle_cap_export inode %p ci %p mds%d mseq %d target %d\n",
3909 inode, ci, mds, mseq, target);
3931 ceph_vinop(inode), mds, cap->seq, cap->mseq,
3958 ceph_add_cap(inode, tsession, t_cap_id, issued, 0,
4014 struct inode *inode, struct ceph_mds_caps *im,
4019 struct ceph_inode_info *ci = ceph_inode(inode);
4040 dout("handle_cap_import inode %p ci %p mds%d mseq %d peer %d\n",
4041 inode, ci, mds, mseq, peer);
4062 ceph_add_cap(inode, session, cap_id, caps, wanted, seq, mseq,
4076 ceph_vinop(inode), peer, ocap->seq,
4090 * Identify the appropriate session, inode, and call the right handler
4097 struct inode *inode;
4209 inode = ceph_find_inode(mdsc->fsc->sb, vino);
4210 ci = ceph_inode(inode);
4211 dout(" op %s ino %llx.%llx inode %p\n", ceph_cap_op_name(op), vino.ino,
4212 vino.snap, inode);
4219 if (!inode) {
4240 handle_cap_flushsnap_ack(inode, le64_to_cpu(msg->hdr.tid),
4245 handle_cap_export(inode, h, peer, session);
4260 handle_cap_import(mdsc, inode, h, peer, session,
4262 handle_cap_grant(inode, session, cap,
4271 cap = __get_cap_for_mds(ceph_inode(inode), session->s_mds);
4274 inode, ceph_ino(inode), ceph_snap(inode),
4286 handle_cap_grant(inode, session, cap,
4291 handle_cap_flush_ack(inode, le64_to_cpu(msg->hdr.tid),
4296 queue_trunc = handle_cap_trunc(inode, h, session);
4299 ceph_queue_vmtruncate(inode);
4313 ceph_async_iput(inode);
4340 struct inode *inode;
4363 inode = igrab(&ci->vfs_inode);
4364 if (inode) {
4366 dout("check_delayed_caps on %p\n", inode);
4369 ceph_async_iput(inode);
4385 struct inode *inode;
4392 inode = &ci->vfs_inode;
4393 ihold(inode);
4394 dout("flush_dirty_caps %p\n", inode);
4397 iput(inode);
4495 int ceph_drop_caps_for_unlink(struct inode *inode)
4497 struct ceph_inode_info *ci = ceph_inode(inode);
4501 if (inode->i_nlink == 1) {
4506 ceph_inode_to_client(inode)->mdsc;
4519 * record for the directory inode, even when there aren't any caps to
4522 int ceph_encode_inode_release(void **p, struct inode *inode,
4525 struct ceph_inode_info *ci = ceph_inode(inode);
4536 inode, mds, ceph_cap_string(used|dirty), ceph_cap_string(drop),
4560 "%s -> %s, wanted %s -> %s\n", inode, cap,
4574 " (force)\n", inode, cap,
4578 rel->ino = cpu_to_le64(ceph_ino(inode));
4591 inode, cap, ceph_cap_string(cap->issued));
4599 struct inode *dir,