Lines Matching defs:inode
24 * The Ceph metadata servers control client access to inode metadata
26 * to read and/or write both inode field and file data to OSDs
31 * that can be safely read from the cached inode.
34 * client is allowed to change inode attributes (e.g., file size,
41 * In order for a client to cache an inode, it must hold a capability
497 dout("__cap_set_timeouts %p %lu\n", &ci->netfs.inode,
504 * If I_FLUSH is set, leave the inode at the front of the list.
512 dout("__cap_delay_requeue %p flags 0x%lx at %lu\n", &ci->netfs.inode,
529 * Queue an inode for immediate writeback. Mark inode with I_FLUSH,
536 dout("__cap_delay_requeue_front %p\n", &ci->netfs.inode);
553 dout("__cap_delay_cancel %p\n", &ci->netfs.inode);
573 if (S_ISREG(ci->netfs.inode.i_mode) &&
588 if (S_ISDIR(ci->netfs.inode.i_mode)) {
589 dout(" marking %p NOT complete\n", &ci->netfs.inode);
595 if (S_ISDIR(ci->netfs.inode.i_mode) && (had & CEPH_CAP_DIR_CREATE) &&
603 * change_auth_cap_ses - move inode to appropriate lists when auth caps change
604 * @ci: inode to be moved
632 void ceph_add_cap(struct inode *inode,
638 struct ceph_mds_client *mdsc = ceph_inode_to_client(inode)->mdsc;
639 struct ceph_inode_info *ci = ceph_inode(inode);
647 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
709 ceph_change_snap_realm(inode, realm);
745 dout("add_cap inode %p (%llx.%llx) cap %p %s now %s seq %d mds%d\n",
746 inode, ceph_vinop(inode), cap, ceph_cap_string(issued),
777 "but STALE (gen %u vs %u)\n", &cap->ci->netfs.inode,
803 &ci->netfs.inode, cap, ceph_cap_string(cap->issued));
850 dout("__touch_cap %p cap %p mds%d\n", &cap->ci->netfs.inode, cap,
855 &cap->ci->netfs.inode, cap, s->s_mds);
873 " (mask %s)\n", ceph_ino(&ci->netfs.inode),
885 " (mask %s)\n", ceph_ino(&ci->netfs.inode), cap,
897 " (mask %s)\n", ceph_ino(&ci->netfs.inode),
925 struct ceph_fs_client *fsc = ceph_sb_to_client(ci->netfs.inode.i_sb);
956 struct inode *inode = &ci->netfs.inode;
962 dout("ceph_caps_revoking %p %s = %d\n", inode,
975 (S_ISREG(ci->netfs.inode.i_mode) &&
976 ci->netfs.inode.i_data.nrpages))
999 ceph_inode_to_client(&ci->netfs.inode)->mount_options;
1003 if (S_ISDIR(ci->netfs.inode.i_mode)) {
1056 if (S_ISDIR(ci->netfs.inode.i_mode)) {
1089 int ceph_is_any_caps(struct inode *inode)
1091 struct ceph_inode_info *ci = ceph_inode(inode);
1116 dout("%s: cap inode is NULL\n", __func__);
1122 dout("__ceph_remove_cap %p from %p\n", cap, &ci->netfs.inode);
1124 mdsc = ceph_inode_to_client(&ci->netfs.inode)->mdsc;
1126 /* remove from inode's cap rbtree, and clear auth cap */
1175 ceph_change_snap_realm(&ci->netfs.inode, NULL);
1188 dout("%s: cap inode is NULL\n", __func__);
1194 fsc = ceph_inode_to_client(&ci->netfs.inode);
1198 !ceph_inode_is_shutdown(&ci->netfs.inode));
1341 * Queue cap releases when an inode is dropped from our cache.
1348 * may call __ceph_caps_issued_mask() on a freeing inode. */
1372 struct inode *inode = &ci->netfs.inode;
1382 __func__, inode, cap, cap->session,
1400 arg->ino = ceph_vino(inode).ino;
1405 arg->size = i_size_read(inode);
1424 arg->mtime = inode->i_mtime;
1425 arg->atime = inode->i_atime;
1426 arg->ctime = inode_get_ctime(inode);
1428 arg->change_attr = inode_peek_iversion_raw(inode);
1440 arg->uid = inode->i_uid;
1441 arg->gid = inode->i_gid;
1442 arg->mode = inode->i_mode;
1458 arg->encrypted = IS_ENCRYPTED(inode);
1492 * Send a cap msg on the given inode.
1499 struct inode *inode = &ci->netfs.inode;
1505 ceph_vinop(inode), ceph_cap_string(arg->dirty),
1521 static inline int __send_flush_snap(struct inode *inode,
1530 arg.ino = ceph_vino(inode).ino;
1565 arg.encrypted = IS_ENCRYPTED(inode);
1594 struct inode *inode = &ci->netfs.inode;
1600 dout("__flush_snaps %p session %p\n", inode, session);
1648 "stop\n", inode, cap, session->s_mds);
1670 inode, capsnap, cf->tid, ceph_cap_string(capsnap->dirty));
1672 ret = __send_flush_snap(inode, session, capsnap, cap->mseq,
1677 ceph_vinop(inode), cf->tid, capsnap->follows);
1688 struct inode *inode = &ci->netfs.inode;
1689 struct ceph_mds_client *mdsc = ceph_inode_to_client(inode)->mdsc;
1694 dout("ceph_flush_snaps %p\n", inode);
1734 /* we flushed them all; remove this inode from the queue */
1742 iput(inode);
1746 * Mark caps dirty. If inode is newly dirty, return the dirty flags.
1754 ceph_sb_to_client(ci->netfs.inode.i_sb)->mdsc;
1755 struct inode *inode = &ci->netfs.inode;
1764 inode, ceph_ino(inode), ceph_cap_string(mask));
1768 dout("__mark_dirty_caps %p %s dirty %s -> %s\n", &ci->netfs.inode,
1783 dout(" inode %p now dirty snapc %p auth cap %p\n",
1784 &ci->netfs.inode, ci->i_head_snapc, ci->i_auth_cap);
1790 ihold(inode);
1834 * Remove cap_flush from the mdsc's or inode's flushing cap list.
1868 * Add dirty inode to the flushing list. Assigned a seq number so we
1873 static u64 __mark_caps_flushing(struct inode *inode,
1877 struct ceph_mds_client *mdsc = ceph_sb_to_client(inode->i_sb)->mdsc;
1878 struct ceph_inode_info *ci = ceph_inode(inode);
1894 dout(" inode %p now !dirty\n", inode);
1921 static int try_nonblocking_invalidate(struct inode *inode)
1925 struct ceph_inode_info *ci = ceph_inode(inode);
1929 ceph_fscache_invalidate(inode, false);
1930 invalidate_mapping_pages(&inode->i_data, 0, -1);
1933 if (inode->i_data.nrpages == 0 &&
1936 dout("try_nonblocking_invalidate %p success\n", inode);
1941 dout("try_nonblocking_invalidate %p failed\n", inode);
1947 loff_t size = i_size_read(&ci->netfs.inode);
1971 struct inode *inode = &ci->netfs.inode;
1972 struct ceph_mds_client *mdsc = ceph_sb_to_mdsc(inode->i_sb);
2016 if (!mdsc->stopping && inode->i_nlink > 0) {
2019 } else if (S_ISDIR(inode->i_mode) &&
2028 if (IS_RDONLY(inode)) {
2048 " issued %s revoking %s retain %s %s%s%s\n", ceph_vinop(inode),
2064 S_ISREG(inode->i_mode) &&
2066 inode->i_data.nrpages && /* have cached pages */
2071 ceph_vinop(inode));
2072 if (try_nonblocking_invalidate(inode) < 0) {
2153 if (S_ISREG(inode->i_mode) && ci->i_wrbuffer_ref &&
2189 flush_tid = __mark_caps_flushing(inode, session, false,
2226 ceph_queue_writeback(inode);
2228 ceph_queue_invalidate(inode);
2234 static int try_flush_caps(struct inode *inode, u64 *ptid)
2236 struct ceph_mds_client *mdsc = ceph_sb_to_client(inode->i_sb)->mdsc;
2237 struct ceph_inode_info *ci = ceph_inode(inode);
2263 flush_tid = __mark_caps_flushing(inode, session, true,
2292 static int caps_are_flushed(struct inode *inode, u64 flush_tid)
2294 struct ceph_inode_info *ci = ceph_inode(inode);
2312 static int flush_mdlog_and_wait_inode_unsafe_requests(struct inode *inode)
2314 struct ceph_mds_client *mdsc = ceph_sb_to_client(inode->i_sb)->mdsc;
2315 struct ceph_inode_info *ci = ceph_inode(inode);
2320 if (S_ISDIR(inode->i_mode) && !list_empty(&ci->i_unsafe_dirops)) {
2405 inode, req1 ? req1->r_tid : 0ULL, req2 ? req2->r_tid : 0ULL);
2429 struct inode *inode = file->f_mapping->host;
2430 struct ceph_inode_info *ci = ceph_inode(inode);
2435 dout("fsync %p%s\n", inode, datasync ? " datasync" : "");
2441 ret = ceph_wait_on_async_create(inode);
2445 dirty = try_flush_caps(inode, &flush_tid);
2448 err = flush_mdlog_and_wait_inode_unsafe_requests(inode);
2457 caps_are_flushed(inode, flush_tid));
2467 dout("fsync %p%s result=%d\n", inode, datasync ? " datasync" : "", ret);
2473 * queue inode for flush but don't do so immediately, because we can
2477 int ceph_write_inode(struct inode *inode, struct writeback_control *wbc)
2479 struct ceph_inode_info *ci = ceph_inode(inode);
2485 dout("write_inode %p wait=%d\n", inode, wait);
2486 ceph_fscache_unpin_writeback(inode, wbc);
2488 err = ceph_wait_on_async_create(inode);
2491 dirty = try_flush_caps(inode, &flush_tid);
2494 caps_are_flushed(inode, flush_tid));
2497 ceph_sb_to_client(inode->i_sb)->mdsc;
2514 struct inode *inode = &ci->netfs.inode;
2541 inode, cap, session->s_mds);
2551 inode, cap, cf->tid, ceph_cap_string(cf->caps));
2566 inode, capsnap, cf->tid,
2572 ret = __send_flush_snap(inode, session, capsnap, cap->mseq,
2578 ceph_vinop(inode), cf->tid,
2607 &ci->netfs.inode, cap, session->s_mds);
2657 &ci->netfs.inode, cap, session->s_mds);
2677 dout("%s %p flushing %s\n", __func__, &ci->netfs.inode,
2720 ihold(&ci->netfs.inode);
2723 &ci->netfs.inode, ci->i_wb_ref-1, ci->i_wb_ref);
2746 static int try_get_cap_refs(struct inode *inode, int need, int want,
2749 struct ceph_inode_info *ci = ceph_inode(inode);
2750 struct ceph_mds_client *mdsc = ceph_inode_to_client(inode)->mdsc;
2755 dout("get_cap_refs %p need %s want %s\n", inode,
2763 dout("try_get_cap_refs %p error filelock\n", inode);
2775 __ceph_do_pending_vmtruncate(inode);
2784 inode, endoff, ci->i_max_size);
2794 dout("get_cap_refs %p cap_snap_pending\n", inode);
2813 inode, ceph_cap_string(have), ceph_cap_string(not),
2855 inode, ceph_cap_string(need), ci->i_auth_cap->mds);
2860 if (ceph_inode_is_shutdown(inode)) {
2861 dout("get_cap_refs %p inode is shutdown\n", inode);
2868 inode, ceph_cap_string(need),
2874 dout("get_cap_refs %p have %s need %s\n", inode,
2890 dout("get_cap_refs %p ret %d got %s\n", inode,
2900 static void check_max_size(struct inode *inode, loff_t endoff)
2902 struct ceph_inode_info *ci = ceph_inode(inode);
2909 inode, endoff);
2933 int ceph_try_get_caps(struct inode *inode, int need, int want,
2943 ret = ceph_pool_perm_check(inode, need);
2952 ret = try_get_cap_refs(inode, need, want, 0, flags, got);
2964 int __ceph_get_caps(struct inode *inode, struct ceph_file_info *fi, int need,
2967 struct ceph_inode_info *ci = ceph_inode(inode);
2968 struct ceph_fs_client *fsc = ceph_inode_to_client(inode);
2971 ret = ceph_pool_perm_check(inode, need);
2983 if (vfs_inode_has_locks(inode))
2986 ret = try_get_cap_refs(inode, need, want, endoff,
2994 cw.ino = ceph_ino(inode);
3008 while (!(ret = try_get_cap_refs(inode, need, want,
3037 int ret2 = ceph_wait_on_async_create(inode);
3042 check_max_size(inode, endoff);
3047 ret = ceph_renew_caps(inode, flags);
3054 if (S_ISREG(ci->netfs.inode.i_mode) &&
3057 i_size_read(inode) > 0) {
3059 find_get_page(inode->i_mapping, 0);
3078 ret = __ceph_do_getattr(inode, NULL,
3095 struct inode *inode = file_inode(filp);
3097 return __ceph_get_caps(inode, fi, need, want, endoff, got);
3153 struct inode *inode = &ci->netfs.inode;
3177 inode, ci->i_wb_ref+1, ci->i_wb_ref);
3198 ceph_change_snap_realm(inode, NULL);
3217 dout("put_cap_refs %p had %s%s%s\n", inode, ceph_cap_string(had),
3229 ceph_queue_check_caps(inode);
3231 ceph_queue_flush_snaps(inode);
3239 iput(inode);
3267 struct inode *inode = &ci->netfs.inode;
3292 inode,
3327 inode, capsnap, capsnap->context->seq,
3345 iput(inode);
3350 * Invalidate unlinked inode's aliases, so we can drop the inode ASAP.
3352 static void invalidate_aliases(struct inode *inode)
3356 dout("invalidate_aliases inode %p\n", inode);
3357 d_prune_aliases(inode);
3359 * For non-directory inode, d_find_alias() only returns
3363 * For directory inode, d_find_alias() can return
3364 * unhashed dentry. But directory inode should have
3367 while ((dn = d_find_alias(inode))) {
3406 static void handle_cap_grant(struct inode *inode,
3415 struct ceph_inode_info *ci = ceph_inode(inode);
3435 if (IS_ENCRYPTED(inode) && size)
3438 dout("handle_cap_grant inode %p cap %p mds%d seq %d %s\n",
3439 inode, cap, session->s_mds, seq, ceph_cap_string(newcaps));
3441 i_size_read(inode));
3449 if (S_ISREG(inode->i_mode) && /* don't invalidate readdir cache */
3453 if (try_nonblocking_invalidate(inode)) {
3467 * auth mds of the inode changed. we received the cap export message,
3487 inode_set_max_iversion_raw(inode, extra_info->change_attr);
3493 if (inode_wrong_type(inode, mode))
3494 pr_warn_once("inode type changed! (ino %llx.%llx is 0%o, mds says 0%o)\n",
3495 ceph_vinop(inode), inode->i_mode, mode);
3497 inode->i_mode = mode;
3498 inode->i_uid = make_kuid(&init_user_ns, le32_to_cpu(grant->uid));
3499 inode->i_gid = make_kgid(&init_user_ns, le32_to_cpu(grant->gid));
3501 dout("%p mode 0%o uid.gid %d.%d\n", inode, inode->i_mode,
3502 from_kuid(&init_user_ns, inode->i_uid),
3503 from_kgid(&init_user_ns, inode->i_gid));
3508 pr_warn_ratelimited("%s: cap grant attempt to change fscrypt_auth on non-I_NEW inode (old len %d new len %d)\n",
3516 set_nlink(inode, le32_to_cpu(grant->nlink));
3517 if (inode->i_nlink == 0)
3528 version, inode, len);
3533 ceph_forget_all_cached_acls(inode);
3534 ceph_security_invalidate_secctx(inode);
3544 ceph_fill_file_time(inode, extra_info->issued,
3571 queue_trunc = ceph_fill_file_size(inode, extra_info->issued,
3622 if (S_ISREG(inode->i_mode) &&
3693 ceph_fill_inline_data(inode, NULL, extra_info->inline_data,
3697 ceph_queue_vmtruncate(inode);
3701 * queue inode for writeback: we can't actually call
3705 ceph_queue_writeback(inode);
3707 ceph_queue_invalidate(inode);
3709 invalidate_aliases(inode);
3724 static void handle_cap_flush_ack(struct inode *inode, u64 flush_tid,
3730 struct ceph_inode_info *ci = ceph_inode(inode);
3731 struct ceph_mds_client *mdsc = ceph_sb_to_client(inode->i_sb)->mdsc;
3768 dout("handle_cap_flush_ack inode %p mds%d seq %d on %s cleaned %s,"
3770 inode, session->s_mds, seq, ceph_cap_string(dirty),
3792 i_flushing_item)->netfs.inode);
3796 dout(" inode %p now !flushing\n", inode);
3799 dout(" inode %p now clean\n", inode);
3830 iput(inode);
3833 void __ceph_remove_capsnap(struct inode *inode, struct ceph_cap_snap *capsnap,
3836 struct ceph_inode_info *ci = ceph_inode(inode);
3837 struct ceph_mds_client *mdsc = ceph_sb_to_client(inode->i_sb)->mdsc;
3842 dout("removing capsnap %p, inode %p ci %p\n", capsnap, inode, ci);
3859 void ceph_remove_capsnap(struct inode *inode, struct ceph_cap_snap *capsnap,
3862 struct ceph_inode_info *ci = ceph_inode(inode);
3867 __ceph_remove_capsnap(inode, capsnap, wake_ci, wake_mdsc);
3876 static void handle_cap_flushsnap_ack(struct inode *inode, u64 flush_tid,
3880 struct ceph_inode_info *ci = ceph_inode(inode);
3881 struct ceph_mds_client *mdsc = ceph_sb_to_client(inode->i_sb)->mdsc;
3887 dout("handle_cap_flushsnap_ack inode %p ci %p mds%d follows %lld\n",
3888 inode, ci, session->s_mds, follows);
3907 ceph_remove_capsnap(inode, capsnap, &wake_ci, &wake_mdsc);
3917 iput(inode);
3926 static bool handle_cap_trunc(struct inode *inode,
3931 struct ceph_inode_info *ci = ceph_inode(inode);
3939 int issued = __ceph_caps_issued(ceph_inode(inode), &implemented);
3951 if (IS_ENCRYPTED(inode) && size)
3954 dout("%s inode %p mds%d seq %d to %lld truncate seq %d\n",
3955 __func__, inode, mds, seq, truncate_size, truncate_seq);
3956 queue_trunc = ceph_fill_file_size(inode, issued,
3969 static void handle_cap_export(struct inode *inode, struct ceph_mds_caps *ex,
3973 struct ceph_mds_client *mdsc = ceph_inode_to_client(inode)->mdsc;
3976 struct ceph_inode_info *ci = ceph_inode(inode);
3993 dout("handle_cap_export inode %p ci %p mds%d mseq %d target %d\n",
3994 inode, ci, mds, mseq, target);
4017 ceph_vinop(inode), mds, cap->seq, cap->mseq,
4044 ceph_add_cap(inode, tsession, t_cap_id, issued, 0,
4102 struct inode *inode, struct ceph_mds_caps *im,
4107 struct ceph_inode_info *ci = ceph_inode(inode);
4128 dout("handle_cap_import inode %p ci %p mds%d mseq %d peer %d\n",
4129 inode, ci, mds, mseq, peer);
4150 ceph_add_cap(inode, session, cap_id, caps, wanted, seq, mseq,
4164 ceph_vinop(inode), peer, ocap->seq,
4224 * Identify the appropriate session, inode, and call the right handler
4231 struct inode *inode;
4350 inode = ceph_find_inode(mdsc->fsc->sb, vino);
4351 dout(" op %s ino %llx.%llx inode %p\n", ceph_cap_op_name(op), vino.ino,
4352 vino.snap, inode);
4358 if (!inode) {
4372 ci = ceph_inode(inode);
4377 handle_cap_flushsnap_ack(inode, le64_to_cpu(msg->hdr.tid),
4382 handle_cap_export(inode, h, peer, session);
4401 handle_cap_import(mdsc, inode, h, peer, session,
4403 handle_cap_grant(inode, session, cap,
4412 cap = __get_cap_for_mds(ceph_inode(inode), session->s_mds);
4415 inode, ceph_ino(inode), ceph_snap(inode),
4435 handle_cap_grant(inode, session, cap,
4440 handle_cap_flush_ack(inode, le64_to_cpu(msg->hdr.tid),
4445 queue_trunc = handle_cap_trunc(inode, h, session,
4449 ceph_queue_vmtruncate(inode);
4461 iput(inode);
4510 struct inode *inode;
4533 inode = igrab(&ci->netfs.inode);
4534 if (inode) {
4536 dout("check_delayed_caps on %p\n", inode);
4538 iput(inode);
4554 struct inode *inode;
4561 inode = &ci->netfs.inode;
4562 ihold(inode);
4563 dout("flush_dirty_caps %llx.%llx\n", ceph_vinop(inode));
4565 ceph_wait_on_async_create(inode);
4567 iput(inode);
4596 struct ceph_mds_client *mdsc = ceph_sb_to_mdsc(ci->netfs.inode.i_sb);
4630 struct ceph_mds_client *mdsc = ceph_sb_to_mdsc(ci->netfs.inode.i_sb);
4665 int ceph_drop_caps_for_unlink(struct inode *inode)
4667 struct ceph_inode_info *ci = ceph_inode(inode);
4671 if (inode->i_nlink == 1) {
4676 ceph_inode_to_client(inode)->mdsc;
4689 * record for the directory inode, even when there aren't any caps to
4692 int ceph_encode_inode_release(void **p, struct inode *inode,
4695 struct ceph_inode_info *ci = ceph_inode(inode);
4706 inode, mds, ceph_cap_string(used|dirty), ceph_cap_string(drop),
4730 "%s -> %s, wanted %s -> %s\n", inode, cap,
4744 " (force)\n", inode, cap,
4748 rel->ino = cpu_to_le64(ceph_ino(inode));
4761 inode, cap, ceph_cap_string(cap->issued));
4781 struct inode *dir,
4831 static int remove_capsnaps(struct ceph_mds_client *mdsc, struct inode *inode)
4833 struct ceph_inode_info *ci = ceph_inode(inode);
4839 dout("removing capsnaps, ci is %p, inode is %p\n", ci, inode);
4844 __ceph_remove_capsnap(inode, capsnap, NULL, NULL);
4854 int ceph_purge_inode_cap(struct inode *inode, struct ceph_cap *cap, bool *invalidate)
4856 struct ceph_fs_client *fsc = ceph_inode_to_client(inode);
4858 struct ceph_inode_info *ci = ceph_inode(inode);
4865 dout("removing cap %p, ci is %p, inode is %p\n",
4866 cap, ci, &ci->netfs.inode);
4873 if (ceph_inode_is_shutdown(inode)) {
4874 if (inode->i_data.nrpages > 0)
4877 mapping_set_error(&inode->i_data, -EIO);
4882 /* trash all of the cap flushes for this inode */
4896 inode, ceph_ino(inode));
4905 inode, ceph_ino(inode));
4914 mapping_set_error(inode->i_mapping, -EIO);
4929 inode, ceph_ino(inode));
4940 iputs = remove_capsnaps(mdsc, inode);