1 // SPDX-License-Identifier: GPL-2.0-only
3 * Ceph cache definitions.
5 * Copyright (C) 2013 by Adfin Solutions, Inc. All Rights Reserved.
6 * Written by Milosz Tanski (milosz@adfin.com)
9 #include <linux/ceph/ceph_debug.h>
11 #include <linux/fs_context.h>
15 struct ceph_aux_inode
{
21 struct fscache_netfs ceph_cache_netfs
= {
26 static DEFINE_MUTEX(ceph_fscache_lock
);
27 static LIST_HEAD(ceph_fscache_list
);
29 struct ceph_fscache_entry
{
30 struct list_head list
;
31 struct fscache_cookie
*fscache
;
33 /* The following members must be last */
34 struct ceph_fsid fsid
;
38 static const struct fscache_cookie_def ceph_fscache_fsid_object_def
= {
40 .type
= FSCACHE_COOKIE_TYPE_INDEX
,
43 int __init
ceph_fscache_register(void)
45 return fscache_register_netfs(&ceph_cache_netfs
);
48 void ceph_fscache_unregister(void)
50 fscache_unregister_netfs(&ceph_cache_netfs
);
53 int ceph_fscache_register_fs(struct ceph_fs_client
* fsc
, struct fs_context
*fc
)
55 const struct ceph_fsid
*fsid
= &fsc
->client
->fsid
;
56 const char *fscache_uniq
= fsc
->mount_options
->fscache_uniq
;
57 size_t uniq_len
= fscache_uniq
? strlen(fscache_uniq
) : 0;
58 struct ceph_fscache_entry
*ent
;
61 mutex_lock(&ceph_fscache_lock
);
62 list_for_each_entry(ent
, &ceph_fscache_list
, list
) {
63 if (memcmp(&ent
->fsid
, fsid
, sizeof(*fsid
)))
65 if (ent
->uniq_len
!= uniq_len
)
67 if (uniq_len
&& memcmp(ent
->uniquifier
, fscache_uniq
, uniq_len
))
70 errorfc(fc
, "fscache cookie already registered for fsid %pU, use fsc=<uniquifier> option",
76 ent
= kzalloc(sizeof(*ent
) + uniq_len
, GFP_KERNEL
);
82 memcpy(&ent
->fsid
, fsid
, sizeof(*fsid
));
84 memcpy(&ent
->uniquifier
, fscache_uniq
, uniq_len
);
85 ent
->uniq_len
= uniq_len
;
88 fsc
->fscache
= fscache_acquire_cookie(ceph_cache_netfs
.primary_index
,
89 &ceph_fscache_fsid_object_def
,
90 &ent
->fsid
, sizeof(ent
->fsid
) + uniq_len
,
95 ent
->fscache
= fsc
->fscache
;
96 list_add_tail(&ent
->list
, &ceph_fscache_list
);
99 errorfc(fc
, "unable to register fscache cookie for fsid %pU",
101 /* all other fs ignore this error */
104 mutex_unlock(&ceph_fscache_lock
);
108 static enum fscache_checkaux
ceph_fscache_inode_check_aux(
109 void *cookie_netfs_data
, const void *data
, uint16_t dlen
,
112 struct ceph_aux_inode aux
;
113 struct ceph_inode_info
* ci
= cookie_netfs_data
;
114 struct inode
* inode
= &ci
->vfs_inode
;
116 if (dlen
!= sizeof(aux
) ||
117 i_size_read(inode
) != object_size
)
118 return FSCACHE_CHECKAUX_OBSOLETE
;
120 memset(&aux
, 0, sizeof(aux
));
121 aux
.version
= ci
->i_version
;
122 aux
.mtime_sec
= inode
->i_mtime
.tv_sec
;
123 aux
.mtime_nsec
= inode
->i_mtime
.tv_nsec
;
125 if (memcmp(data
, &aux
, sizeof(aux
)) != 0)
126 return FSCACHE_CHECKAUX_OBSOLETE
;
128 dout("ceph inode 0x%p cached okay\n", ci
);
129 return FSCACHE_CHECKAUX_OKAY
;
132 static const struct fscache_cookie_def ceph_fscache_inode_object_def
= {
133 .name
= "CEPH.inode",
134 .type
= FSCACHE_COOKIE_TYPE_DATAFILE
,
135 .check_aux
= ceph_fscache_inode_check_aux
,
138 void ceph_fscache_register_inode_cookie(struct inode
*inode
)
140 struct ceph_inode_info
*ci
= ceph_inode(inode
);
141 struct ceph_fs_client
*fsc
= ceph_inode_to_client(inode
);
142 struct ceph_aux_inode aux
;
144 /* No caching for filesystem */
148 /* Only cache for regular files that are read only */
149 if (!S_ISREG(inode
->i_mode
))
152 inode_lock_nested(inode
, I_MUTEX_CHILD
);
154 memset(&aux
, 0, sizeof(aux
));
155 aux
.version
= ci
->i_version
;
156 aux
.mtime_sec
= inode
->i_mtime
.tv_sec
;
157 aux
.mtime_nsec
= inode
->i_mtime
.tv_nsec
;
158 ci
->fscache
= fscache_acquire_cookie(fsc
->fscache
,
159 &ceph_fscache_inode_object_def
,
160 &ci
->i_vino
, sizeof(ci
->i_vino
),
162 ci
, i_size_read(inode
), false);
167 void ceph_fscache_unregister_inode_cookie(struct ceph_inode_info
* ci
)
169 struct fscache_cookie
* cookie
;
171 if ((cookie
= ci
->fscache
) == NULL
)
176 fscache_relinquish_cookie(cookie
, &ci
->i_vino
, false);
179 static bool ceph_fscache_can_enable(void *data
)
181 struct inode
*inode
= data
;
182 return !inode_is_open_for_write(inode
);
185 void ceph_fscache_file_set_cookie(struct inode
*inode
, struct file
*filp
)
187 struct ceph_inode_info
*ci
= ceph_inode(inode
);
189 if (!fscache_cookie_valid(ci
->fscache
))
192 if (inode_is_open_for_write(inode
)) {
193 dout("fscache_file_set_cookie %p %p disabling cache\n",
195 fscache_disable_cookie(ci
->fscache
, &ci
->i_vino
, false);
197 fscache_enable_cookie(ci
->fscache
, &ci
->i_vino
, i_size_read(inode
),
198 ceph_fscache_can_enable
, inode
);
199 if (fscache_cookie_enabled(ci
->fscache
)) {
200 dout("fscache_file_set_cookie %p %p enabling cache\n",
206 void ceph_fscache_unregister_fs(struct ceph_fs_client
* fsc
)
208 if (fscache_cookie_valid(fsc
->fscache
)) {
209 struct ceph_fscache_entry
*ent
;
212 mutex_lock(&ceph_fscache_lock
);
213 list_for_each_entry(ent
, &ceph_fscache_list
, list
) {
214 if (ent
->fscache
== fsc
->fscache
) {
215 list_del(&ent
->list
);
221 WARN_ON_ONCE(!found
);
222 mutex_unlock(&ceph_fscache_lock
);
224 __fscache_relinquish_cookie(fsc
->fscache
, NULL
, false);