blob: c447fa2e2d1feb89ff9333a22203ad81fe41b436 [file] [log] [blame]
Greg Kroah-Hartmanb2441312017-11-01 15:07:57 +01001// SPDX-License-Identifier: GPL-2.0
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -07002#include <linux/ceph/ceph_debug.h>
Sage Weila8599bd2009-10-06 11:31:12 -07003
4#include <linux/fs.h>
5#include <linux/kernel.h>
Ingo Molnar174cd4b2017-02-02 19:15:33 +01006#include <linux/sched/signal.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +09007#include <linux/slab.h>
Sage Weila8599bd2009-10-06 11:31:12 -07008#include <linux/vmalloc.h>
9#include <linux/wait.h>
Stephen Rothwellf1a3d572010-01-18 11:53:08 +110010#include <linux/writeback.h>
Jeff Layton176c77c2019-06-06 08:06:40 -040011#include <linux/iversion.h>
Sage Weila8599bd2009-10-06 11:31:12 -070012
13#include "super.h"
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -070014#include "mds_client.h"
Milosz Tanski99ccbd22013-08-21 17:29:54 -040015#include "cache.h"
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -070016#include <linux/ceph/decode.h>
17#include <linux/ceph/messenger.h>
Sage Weila8599bd2009-10-06 11:31:12 -070018
19/*
20 * Capability management
21 *
22 * The Ceph metadata servers control client access to inode metadata
23 * and file data by issuing capabilities, granting clients permission
24 * to read and/or write both inode field and file data to OSDs
25 * (storage nodes). Each capability consists of a set of bits
26 * indicating which operations are allowed.
27 *
28 * If the client holds a *_SHARED cap, the client has a coherent value
29 * that can be safely read from the cached inode.
30 *
31 * In the case of a *_EXCL (exclusive) or FILE_WR capabilities, the
32 * client is allowed to change inode attributes (e.g., file size,
33 * mtime), note its dirty state in the ceph_cap, and asynchronously
34 * flush that metadata change to the MDS.
35 *
36 * In the event of a conflicting operation (perhaps by another
37 * client), the MDS will revoke the conflicting client capabilities.
38 *
39 * In order for a client to cache an inode, it must hold a capability
40 * with at least one MDS server. When inodes are released, release
41 * notifications are batched and periodically sent en masse to the MDS
42 * cluster to release server state.
43 */
44
Yan, Zheng0e294382016-07-04 18:06:41 +080045static u64 __get_oldest_flush_tid(struct ceph_mds_client *mdsc);
Yan, Zheng7bc00fd2016-07-07 18:34:45 +080046static void __kick_flushing_caps(struct ceph_mds_client *mdsc,
47 struct ceph_mds_session *session,
48 struct ceph_inode_info *ci,
49 u64 oldest_flush_tid);
Sage Weila8599bd2009-10-06 11:31:12 -070050
51/*
52 * Generate readable cap strings for debugging output.
53 */
54#define MAX_CAP_STR 20
55static char cap_str[MAX_CAP_STR][40];
56static DEFINE_SPINLOCK(cap_str_lock);
57static int last_cap_str;
58
59static char *gcap_string(char *s, int c)
60{
61 if (c & CEPH_CAP_GSHARED)
62 *s++ = 's';
63 if (c & CEPH_CAP_GEXCL)
64 *s++ = 'x';
65 if (c & CEPH_CAP_GCACHE)
66 *s++ = 'c';
67 if (c & CEPH_CAP_GRD)
68 *s++ = 'r';
69 if (c & CEPH_CAP_GWR)
70 *s++ = 'w';
71 if (c & CEPH_CAP_GBUFFER)
72 *s++ = 'b';
Yan, Zheng49a9f4f2018-04-25 17:30:23 +080073 if (c & CEPH_CAP_GWREXTEND)
74 *s++ = 'a';
Sage Weila8599bd2009-10-06 11:31:12 -070075 if (c & CEPH_CAP_GLAZYIO)
76 *s++ = 'l';
77 return s;
78}
79
80const char *ceph_cap_string(int caps)
81{
82 int i;
83 char *s;
84 int c;
85
86 spin_lock(&cap_str_lock);
87 i = last_cap_str++;
88 if (last_cap_str == MAX_CAP_STR)
89 last_cap_str = 0;
90 spin_unlock(&cap_str_lock);
91
92 s = cap_str[i];
93
94 if (caps & CEPH_CAP_PIN)
95 *s++ = 'p';
96
97 c = (caps >> CEPH_CAP_SAUTH) & 3;
98 if (c) {
99 *s++ = 'A';
100 s = gcap_string(s, c);
101 }
102
103 c = (caps >> CEPH_CAP_SLINK) & 3;
104 if (c) {
105 *s++ = 'L';
106 s = gcap_string(s, c);
107 }
108
109 c = (caps >> CEPH_CAP_SXATTR) & 3;
110 if (c) {
111 *s++ = 'X';
112 s = gcap_string(s, c);
113 }
114
115 c = caps >> CEPH_CAP_SFILE;
116 if (c) {
117 *s++ = 'F';
118 s = gcap_string(s, c);
119 }
120
121 if (s == cap_str[i])
122 *s++ = '-';
123 *s = 0;
124 return cap_str[i];
125}
126
Yehuda Sadeh37151662010-06-17 16:16:12 -0700127void ceph_caps_init(struct ceph_mds_client *mdsc)
Sage Weila8599bd2009-10-06 11:31:12 -0700128{
Yehuda Sadeh37151662010-06-17 16:16:12 -0700129 INIT_LIST_HEAD(&mdsc->caps_list);
130 spin_lock_init(&mdsc->caps_list_lock);
Sage Weila8599bd2009-10-06 11:31:12 -0700131}
132
Yehuda Sadeh37151662010-06-17 16:16:12 -0700133void ceph_caps_finalize(struct ceph_mds_client *mdsc)
Sage Weila8599bd2009-10-06 11:31:12 -0700134{
135 struct ceph_cap *cap;
136
Yehuda Sadeh37151662010-06-17 16:16:12 -0700137 spin_lock(&mdsc->caps_list_lock);
138 while (!list_empty(&mdsc->caps_list)) {
139 cap = list_first_entry(&mdsc->caps_list,
140 struct ceph_cap, caps_item);
Sage Weila8599bd2009-10-06 11:31:12 -0700141 list_del(&cap->caps_item);
142 kmem_cache_free(ceph_cap_cachep, cap);
143 }
Yehuda Sadeh37151662010-06-17 16:16:12 -0700144 mdsc->caps_total_count = 0;
145 mdsc->caps_avail_count = 0;
146 mdsc->caps_use_count = 0;
147 mdsc->caps_reserve_count = 0;
148 mdsc->caps_min_count = 0;
149 spin_unlock(&mdsc->caps_list_lock);
Sage Weil85ccce42010-02-17 10:02:43 -0800150}
151
Yan, Zhengfe330322019-02-01 14:57:15 +0800152void ceph_adjust_caps_max_min(struct ceph_mds_client *mdsc,
153 struct ceph_mount_options *fsopt)
Sage Weil85ccce42010-02-17 10:02:43 -0800154{
Yehuda Sadeh37151662010-06-17 16:16:12 -0700155 spin_lock(&mdsc->caps_list_lock);
Yan, Zhengfe330322019-02-01 14:57:15 +0800156 mdsc->caps_min_count = fsopt->max_readdir;
157 if (mdsc->caps_min_count < 1024)
158 mdsc->caps_min_count = 1024;
159 mdsc->caps_use_max = fsopt->caps_max;
160 if (mdsc->caps_use_max > 0 &&
161 mdsc->caps_use_max < mdsc->caps_min_count)
162 mdsc->caps_use_max = mdsc->caps_min_count;
Yehuda Sadeh37151662010-06-17 16:16:12 -0700163 spin_unlock(&mdsc->caps_list_lock);
Sage Weila8599bd2009-10-06 11:31:12 -0700164}
165
Chengguang Xu7bf8f732018-07-28 23:15:35 +0800166static void __ceph_unreserve_caps(struct ceph_mds_client *mdsc, int nr_caps)
167{
168 struct ceph_cap *cap;
169 int i;
170
171 if (nr_caps) {
172 BUG_ON(mdsc->caps_reserve_count < nr_caps);
173 mdsc->caps_reserve_count -= nr_caps;
174 if (mdsc->caps_avail_count >=
175 mdsc->caps_reserve_count + mdsc->caps_min_count) {
176 mdsc->caps_total_count -= nr_caps;
177 for (i = 0; i < nr_caps; i++) {
178 cap = list_first_entry(&mdsc->caps_list,
179 struct ceph_cap, caps_item);
180 list_del(&cap->caps_item);
181 kmem_cache_free(ceph_cap_cachep, cap);
182 }
183 } else {
184 mdsc->caps_avail_count += nr_caps;
185 }
186
187 dout("%s: caps %d = %d used + %d resv + %d avail\n",
188 __func__,
189 mdsc->caps_total_count, mdsc->caps_use_count,
190 mdsc->caps_reserve_count, mdsc->caps_avail_count);
191 BUG_ON(mdsc->caps_total_count != mdsc->caps_use_count +
192 mdsc->caps_reserve_count +
193 mdsc->caps_avail_count);
194 }
195}
196
Zhi Zhange30ee582018-01-24 21:24:33 +0800197/*
198 * Called under mdsc->mutex.
199 */
200int ceph_reserve_caps(struct ceph_mds_client *mdsc,
Yehuda Sadeh37151662010-06-17 16:16:12 -0700201 struct ceph_cap_reservation *ctx, int need)
Sage Weila8599bd2009-10-06 11:31:12 -0700202{
Zhi Zhange30ee582018-01-24 21:24:33 +0800203 int i, j;
Sage Weila8599bd2009-10-06 11:31:12 -0700204 struct ceph_cap *cap;
205 int have;
206 int alloc = 0;
Zhi Zhange30ee582018-01-24 21:24:33 +0800207 int max_caps;
Chengguang Xue5bc08d2018-07-28 23:15:37 +0800208 int err = 0;
Zhi Zhange30ee582018-01-24 21:24:33 +0800209 bool trimmed = false;
210 struct ceph_mds_session *s;
Sage Weila8599bd2009-10-06 11:31:12 -0700211 LIST_HEAD(newcaps);
Sage Weila8599bd2009-10-06 11:31:12 -0700212
213 dout("reserve caps ctx=%p need=%d\n", ctx, need);
214
215 /* first reserve any caps that are already allocated */
Yehuda Sadeh37151662010-06-17 16:16:12 -0700216 spin_lock(&mdsc->caps_list_lock);
217 if (mdsc->caps_avail_count >= need)
Sage Weila8599bd2009-10-06 11:31:12 -0700218 have = need;
219 else
Yehuda Sadeh37151662010-06-17 16:16:12 -0700220 have = mdsc->caps_avail_count;
221 mdsc->caps_avail_count -= have;
222 mdsc->caps_reserve_count += have;
223 BUG_ON(mdsc->caps_total_count != mdsc->caps_use_count +
224 mdsc->caps_reserve_count +
225 mdsc->caps_avail_count);
226 spin_unlock(&mdsc->caps_list_lock);
Sage Weila8599bd2009-10-06 11:31:12 -0700227
Chengguang Xu79cd6742018-02-24 18:36:02 +0800228 for (i = have; i < need; ) {
Sage Weila8599bd2009-10-06 11:31:12 -0700229 cap = kmem_cache_alloc(ceph_cap_cachep, GFP_NOFS);
Chengguang Xu79cd6742018-02-24 18:36:02 +0800230 if (cap) {
231 list_add(&cap->caps_item, &newcaps);
232 alloc++;
233 i++;
234 continue;
Zhi Zhange30ee582018-01-24 21:24:33 +0800235 }
Chengguang Xu79cd6742018-02-24 18:36:02 +0800236
237 if (!trimmed) {
238 for (j = 0; j < mdsc->max_sessions; j++) {
239 s = __ceph_lookup_mds_session(mdsc, j);
240 if (!s)
241 continue;
242 mutex_unlock(&mdsc->mutex);
243
244 mutex_lock(&s->s_mutex);
245 max_caps = s->s_nr_caps - (need - i);
246 ceph_trim_caps(mdsc, s, max_caps);
247 mutex_unlock(&s->s_mutex);
248
249 ceph_put_mds_session(s);
250 mutex_lock(&mdsc->mutex);
251 }
252 trimmed = true;
253
254 spin_lock(&mdsc->caps_list_lock);
255 if (mdsc->caps_avail_count) {
256 int more_have;
257 if (mdsc->caps_avail_count >= need - i)
258 more_have = need - i;
259 else
260 more_have = mdsc->caps_avail_count;
261
262 i += more_have;
263 have += more_have;
264 mdsc->caps_avail_count -= more_have;
265 mdsc->caps_reserve_count += more_have;
266
267 }
268 spin_unlock(&mdsc->caps_list_lock);
269
270 continue;
271 }
272
273 pr_warn("reserve caps ctx=%p ENOMEM need=%d got=%d\n",
274 ctx, need, have + alloc);
Chengguang Xue5bc08d2018-07-28 23:15:37 +0800275 err = -ENOMEM;
276 break;
Sage Weila8599bd2009-10-06 11:31:12 -0700277 }
Chengguang Xue5bc08d2018-07-28 23:15:37 +0800278
279 if (!err) {
280 BUG_ON(have + alloc != need);
281 ctx->count = need;
Yan, Zhengfe330322019-02-01 14:57:15 +0800282 ctx->used = 0;
Chengguang Xue5bc08d2018-07-28 23:15:37 +0800283 }
Sage Weila8599bd2009-10-06 11:31:12 -0700284
Yehuda Sadeh37151662010-06-17 16:16:12 -0700285 spin_lock(&mdsc->caps_list_lock);
286 mdsc->caps_total_count += alloc;
287 mdsc->caps_reserve_count += alloc;
288 list_splice(&newcaps, &mdsc->caps_list);
Sage Weila8599bd2009-10-06 11:31:12 -0700289
Yehuda Sadeh37151662010-06-17 16:16:12 -0700290 BUG_ON(mdsc->caps_total_count != mdsc->caps_use_count +
291 mdsc->caps_reserve_count +
292 mdsc->caps_avail_count);
Chengguang Xue5bc08d2018-07-28 23:15:37 +0800293
294 if (err)
295 __ceph_unreserve_caps(mdsc, have + alloc);
296
Yehuda Sadeh37151662010-06-17 16:16:12 -0700297 spin_unlock(&mdsc->caps_list_lock);
Sage Weila8599bd2009-10-06 11:31:12 -0700298
Sage Weila8599bd2009-10-06 11:31:12 -0700299 dout("reserve caps ctx=%p %d = %d used + %d resv + %d avail\n",
Yehuda Sadeh37151662010-06-17 16:16:12 -0700300 ctx, mdsc->caps_total_count, mdsc->caps_use_count,
301 mdsc->caps_reserve_count, mdsc->caps_avail_count);
Chengguang Xue5bc08d2018-07-28 23:15:37 +0800302 return err;
Sage Weila8599bd2009-10-06 11:31:12 -0700303}
304
Chengguang Xu7bf8f732018-07-28 23:15:35 +0800305void ceph_unreserve_caps(struct ceph_mds_client *mdsc,
Yan, Zhengfe330322019-02-01 14:57:15 +0800306 struct ceph_cap_reservation *ctx)
Sage Weila8599bd2009-10-06 11:31:12 -0700307{
Yan, Zhengfe330322019-02-01 14:57:15 +0800308 bool reclaim = false;
309 if (!ctx->count)
310 return;
311
Sage Weila8599bd2009-10-06 11:31:12 -0700312 dout("unreserve caps ctx=%p count=%d\n", ctx, ctx->count);
Chengguang Xu7bf8f732018-07-28 23:15:35 +0800313 spin_lock(&mdsc->caps_list_lock);
314 __ceph_unreserve_caps(mdsc, ctx->count);
315 ctx->count = 0;
Yan, Zhengfe330322019-02-01 14:57:15 +0800316
317 if (mdsc->caps_use_max > 0 &&
318 mdsc->caps_use_count > mdsc->caps_use_max)
319 reclaim = true;
Chengguang Xu7bf8f732018-07-28 23:15:35 +0800320 spin_unlock(&mdsc->caps_list_lock);
Yan, Zhengfe330322019-02-01 14:57:15 +0800321
322 if (reclaim)
323 ceph_reclaim_caps_nr(mdsc, ctx->used);
Sage Weila8599bd2009-10-06 11:31:12 -0700324}
325
Yan, Zhengd9df2782014-04-18 09:57:11 +0800326struct ceph_cap *ceph_get_cap(struct ceph_mds_client *mdsc,
327 struct ceph_cap_reservation *ctx)
Sage Weila8599bd2009-10-06 11:31:12 -0700328{
329 struct ceph_cap *cap = NULL;
330
331 /* temporary, until we do something about cap import/export */
Sage Weil443b3762010-06-29 09:28:39 -0700332 if (!ctx) {
333 cap = kmem_cache_alloc(ceph_cap_cachep, GFP_NOFS);
334 if (cap) {
Yan, Zheng4d1d05342012-11-03 10:32:37 +0800335 spin_lock(&mdsc->caps_list_lock);
Yehuda Sadeh37151662010-06-17 16:16:12 -0700336 mdsc->caps_use_count++;
337 mdsc->caps_total_count++;
Yan, Zheng4d1d05342012-11-03 10:32:37 +0800338 spin_unlock(&mdsc->caps_list_lock);
Chengguang Xue327ce02018-02-24 18:35:29 +0800339 } else {
340 spin_lock(&mdsc->caps_list_lock);
341 if (mdsc->caps_avail_count) {
342 BUG_ON(list_empty(&mdsc->caps_list));
343
344 mdsc->caps_avail_count--;
345 mdsc->caps_use_count++;
346 cap = list_first_entry(&mdsc->caps_list,
347 struct ceph_cap, caps_item);
348 list_del(&cap->caps_item);
349
350 BUG_ON(mdsc->caps_total_count != mdsc->caps_use_count +
351 mdsc->caps_reserve_count + mdsc->caps_avail_count);
352 }
353 spin_unlock(&mdsc->caps_list_lock);
Sage Weil443b3762010-06-29 09:28:39 -0700354 }
Chengguang Xue327ce02018-02-24 18:35:29 +0800355
Sage Weil443b3762010-06-29 09:28:39 -0700356 return cap;
357 }
Sage Weila8599bd2009-10-06 11:31:12 -0700358
Yehuda Sadeh37151662010-06-17 16:16:12 -0700359 spin_lock(&mdsc->caps_list_lock);
Sage Weila8599bd2009-10-06 11:31:12 -0700360 dout("get_cap ctx=%p (%d) %d = %d used + %d resv + %d avail\n",
Yehuda Sadeh37151662010-06-17 16:16:12 -0700361 ctx, ctx->count, mdsc->caps_total_count, mdsc->caps_use_count,
362 mdsc->caps_reserve_count, mdsc->caps_avail_count);
Sage Weila8599bd2009-10-06 11:31:12 -0700363 BUG_ON(!ctx->count);
Yehuda Sadeh37151662010-06-17 16:16:12 -0700364 BUG_ON(ctx->count > mdsc->caps_reserve_count);
365 BUG_ON(list_empty(&mdsc->caps_list));
Sage Weila8599bd2009-10-06 11:31:12 -0700366
367 ctx->count--;
Yan, Zhengfe330322019-02-01 14:57:15 +0800368 ctx->used++;
Yehuda Sadeh37151662010-06-17 16:16:12 -0700369 mdsc->caps_reserve_count--;
370 mdsc->caps_use_count++;
Sage Weila8599bd2009-10-06 11:31:12 -0700371
Yehuda Sadeh37151662010-06-17 16:16:12 -0700372 cap = list_first_entry(&mdsc->caps_list, struct ceph_cap, caps_item);
Sage Weila8599bd2009-10-06 11:31:12 -0700373 list_del(&cap->caps_item);
374
Yehuda Sadeh37151662010-06-17 16:16:12 -0700375 BUG_ON(mdsc->caps_total_count != mdsc->caps_use_count +
376 mdsc->caps_reserve_count + mdsc->caps_avail_count);
377 spin_unlock(&mdsc->caps_list_lock);
Sage Weila8599bd2009-10-06 11:31:12 -0700378 return cap;
379}
380
Yehuda Sadeh37151662010-06-17 16:16:12 -0700381void ceph_put_cap(struct ceph_mds_client *mdsc, struct ceph_cap *cap)
Sage Weila8599bd2009-10-06 11:31:12 -0700382{
Yehuda Sadeh37151662010-06-17 16:16:12 -0700383 spin_lock(&mdsc->caps_list_lock);
Sage Weil7c1332b2010-02-16 11:39:45 -0800384 dout("put_cap %p %d = %d used + %d resv + %d avail\n",
Yehuda Sadeh37151662010-06-17 16:16:12 -0700385 cap, mdsc->caps_total_count, mdsc->caps_use_count,
386 mdsc->caps_reserve_count, mdsc->caps_avail_count);
387 mdsc->caps_use_count--;
Sage Weila8599bd2009-10-06 11:31:12 -0700388 /*
Sage Weil85ccce42010-02-17 10:02:43 -0800389 * Keep some preallocated caps around (ceph_min_count), to
390 * avoid lots of free/alloc churn.
Sage Weila8599bd2009-10-06 11:31:12 -0700391 */
Yehuda Sadeh37151662010-06-17 16:16:12 -0700392 if (mdsc->caps_avail_count >= mdsc->caps_reserve_count +
393 mdsc->caps_min_count) {
394 mdsc->caps_total_count--;
Sage Weila8599bd2009-10-06 11:31:12 -0700395 kmem_cache_free(ceph_cap_cachep, cap);
396 } else {
Yehuda Sadeh37151662010-06-17 16:16:12 -0700397 mdsc->caps_avail_count++;
398 list_add(&cap->caps_item, &mdsc->caps_list);
Sage Weila8599bd2009-10-06 11:31:12 -0700399 }
400
Yehuda Sadeh37151662010-06-17 16:16:12 -0700401 BUG_ON(mdsc->caps_total_count != mdsc->caps_use_count +
402 mdsc->caps_reserve_count + mdsc->caps_avail_count);
403 spin_unlock(&mdsc->caps_list_lock);
Sage Weila8599bd2009-10-06 11:31:12 -0700404}
405
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700406void ceph_reservation_status(struct ceph_fs_client *fsc,
Sage Weil85ccce42010-02-17 10:02:43 -0800407 int *total, int *avail, int *used, int *reserved,
408 int *min)
Sage Weila8599bd2009-10-06 11:31:12 -0700409{
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700410 struct ceph_mds_client *mdsc = fsc->mdsc;
Yehuda Sadeh37151662010-06-17 16:16:12 -0700411
Chengguang Xub8840142018-02-23 17:09:38 +0800412 spin_lock(&mdsc->caps_list_lock);
413
Sage Weila8599bd2009-10-06 11:31:12 -0700414 if (total)
Yehuda Sadeh37151662010-06-17 16:16:12 -0700415 *total = mdsc->caps_total_count;
Sage Weila8599bd2009-10-06 11:31:12 -0700416 if (avail)
Yehuda Sadeh37151662010-06-17 16:16:12 -0700417 *avail = mdsc->caps_avail_count;
Sage Weila8599bd2009-10-06 11:31:12 -0700418 if (used)
Yehuda Sadeh37151662010-06-17 16:16:12 -0700419 *used = mdsc->caps_use_count;
Sage Weila8599bd2009-10-06 11:31:12 -0700420 if (reserved)
Yehuda Sadeh37151662010-06-17 16:16:12 -0700421 *reserved = mdsc->caps_reserve_count;
Sage Weil85ccce42010-02-17 10:02:43 -0800422 if (min)
Yehuda Sadeh37151662010-06-17 16:16:12 -0700423 *min = mdsc->caps_min_count;
Chengguang Xub8840142018-02-23 17:09:38 +0800424
425 spin_unlock(&mdsc->caps_list_lock);
Sage Weila8599bd2009-10-06 11:31:12 -0700426}
427
428/*
429 * Find ceph_cap for given mds, if any.
430 *
Sage Weilbe655592011-11-30 09:47:09 -0800431 * Called with i_ceph_lock held.
Sage Weila8599bd2009-10-06 11:31:12 -0700432 */
433static struct ceph_cap *__get_cap_for_mds(struct ceph_inode_info *ci, int mds)
434{
435 struct ceph_cap *cap;
436 struct rb_node *n = ci->i_caps.rb_node;
437
438 while (n) {
439 cap = rb_entry(n, struct ceph_cap, ci_node);
440 if (mds < cap->mds)
441 n = n->rb_left;
442 else if (mds > cap->mds)
443 n = n->rb_right;
444 else
445 return cap;
446 }
447 return NULL;
448}
449
Greg Farnum2bc50252010-06-30 12:44:34 -0700450struct ceph_cap *ceph_get_cap_for_mds(struct ceph_inode_info *ci, int mds)
451{
452 struct ceph_cap *cap;
453
Sage Weilbe655592011-11-30 09:47:09 -0800454 spin_lock(&ci->i_ceph_lock);
Greg Farnum2bc50252010-06-30 12:44:34 -0700455 cap = __get_cap_for_mds(ci, mds);
Sage Weilbe655592011-11-30 09:47:09 -0800456 spin_unlock(&ci->i_ceph_lock);
Greg Farnum2bc50252010-06-30 12:44:34 -0700457 return cap;
458}
459
Sage Weila8599bd2009-10-06 11:31:12 -0700460/*
Sage Weilbe655592011-11-30 09:47:09 -0800461 * Called under i_ceph_lock.
Sage Weila8599bd2009-10-06 11:31:12 -0700462 */
463static void __insert_cap_node(struct ceph_inode_info *ci,
464 struct ceph_cap *new)
465{
466 struct rb_node **p = &ci->i_caps.rb_node;
467 struct rb_node *parent = NULL;
468 struct ceph_cap *cap = NULL;
469
470 while (*p) {
471 parent = *p;
472 cap = rb_entry(parent, struct ceph_cap, ci_node);
473 if (new->mds < cap->mds)
474 p = &(*p)->rb_left;
475 else if (new->mds > cap->mds)
476 p = &(*p)->rb_right;
477 else
478 BUG();
479 }
480
481 rb_link_node(&new->ci_node, parent, p);
482 rb_insert_color(&new->ci_node, &ci->i_caps);
483}
484
485/*
486 * (re)set cap hold timeouts, which control the delayed release
487 * of unused caps back to the MDS. Should be called on cap use.
488 */
489static void __cap_set_timeouts(struct ceph_mds_client *mdsc,
490 struct ceph_inode_info *ci)
491{
Yan, Zhengfe330322019-02-01 14:57:15 +0800492 struct ceph_mount_options *opt = mdsc->fsc->mount_options;
Sage Weila8599bd2009-10-06 11:31:12 -0700493 ci->i_hold_caps_max = round_jiffies(jiffies +
Yan, Zhengfe330322019-02-01 14:57:15 +0800494 opt->caps_wanted_delay_max * HZ);
Yan, Zhenga0d93e32020-03-05 20:21:01 +0800495 dout("__cap_set_timeouts %p %lu\n", &ci->vfs_inode,
496 ci->i_hold_caps_max - jiffies);
Sage Weila8599bd2009-10-06 11:31:12 -0700497}
498
499/*
500 * (Re)queue cap at the end of the delayed cap release list.
501 *
502 * If I_FLUSH is set, leave the inode at the front of the list.
503 *
Sage Weilbe655592011-11-30 09:47:09 -0800504 * Caller holds i_ceph_lock
Sage Weila8599bd2009-10-06 11:31:12 -0700505 * -> we take mdsc->cap_delay_lock
506 */
507static void __cap_delay_requeue(struct ceph_mds_client *mdsc,
Yan, Zhenga0d93e32020-03-05 20:21:01 +0800508 struct ceph_inode_info *ci)
Sage Weila8599bd2009-10-06 11:31:12 -0700509{
Jeff Layton891f3f52020-01-14 15:06:40 -0500510 dout("__cap_delay_requeue %p flags 0x%lx at %lu\n", &ci->vfs_inode,
Sage Weila8599bd2009-10-06 11:31:12 -0700511 ci->i_ceph_flags, ci->i_hold_caps_max);
512 if (!mdsc->stopping) {
513 spin_lock(&mdsc->cap_delay_lock);
514 if (!list_empty(&ci->i_cap_delay_list)) {
515 if (ci->i_ceph_flags & CEPH_I_FLUSH)
516 goto no_change;
517 list_del_init(&ci->i_cap_delay_list);
518 }
Yan, Zhenga0d93e32020-03-05 20:21:01 +0800519 __cap_set_timeouts(mdsc, ci);
Sage Weila8599bd2009-10-06 11:31:12 -0700520 list_add_tail(&ci->i_cap_delay_list, &mdsc->cap_delay_list);
521no_change:
522 spin_unlock(&mdsc->cap_delay_lock);
523 }
524}
525
526/*
527 * Queue an inode for immediate writeback. Mark inode with I_FLUSH,
528 * indicating we should send a cap message to flush dirty metadata
529 * asap, and move to the front of the delayed cap list.
530 */
531static void __cap_delay_requeue_front(struct ceph_mds_client *mdsc,
532 struct ceph_inode_info *ci)
533{
534 dout("__cap_delay_requeue_front %p\n", &ci->vfs_inode);
535 spin_lock(&mdsc->cap_delay_lock);
536 ci->i_ceph_flags |= CEPH_I_FLUSH;
537 if (!list_empty(&ci->i_cap_delay_list))
538 list_del_init(&ci->i_cap_delay_list);
539 list_add(&ci->i_cap_delay_list, &mdsc->cap_delay_list);
540 spin_unlock(&mdsc->cap_delay_lock);
541}
542
543/*
544 * Cancel delayed work on cap.
545 *
Sage Weilbe655592011-11-30 09:47:09 -0800546 * Caller must hold i_ceph_lock.
Sage Weila8599bd2009-10-06 11:31:12 -0700547 */
548static void __cap_delay_cancel(struct ceph_mds_client *mdsc,
549 struct ceph_inode_info *ci)
550{
551 dout("__cap_delay_cancel %p\n", &ci->vfs_inode);
552 if (list_empty(&ci->i_cap_delay_list))
553 return;
554 spin_lock(&mdsc->cap_delay_lock);
555 list_del_init(&ci->i_cap_delay_list);
556 spin_unlock(&mdsc->cap_delay_lock);
557}
558
Jeff Layton785892f2020-01-02 07:11:38 -0500559/* Common issue checks for add_cap, handle_cap_grant. */
Sage Weila8599bd2009-10-06 11:31:12 -0700560static void __check_cap_issue(struct ceph_inode_info *ci, struct ceph_cap *cap,
561 unsigned issued)
562{
563 unsigned had = __ceph_caps_issued(ci, NULL);
564
Jeff Layton785892f2020-01-02 07:11:38 -0500565 lockdep_assert_held(&ci->i_ceph_lock);
566
Sage Weila8599bd2009-10-06 11:31:12 -0700567 /*
568 * Each time we receive FILE_CACHE anew, we increment
569 * i_rdcache_gen.
570 */
Yan, Zheng525d15e2019-05-11 17:27:59 +0800571 if (S_ISREG(ci->vfs_inode.i_mode) &&
572 (issued & (CEPH_CAP_FILE_CACHE|CEPH_CAP_FILE_LAZYIO)) &&
Milosz Tanski99ccbd22013-08-21 17:29:54 -0400573 (had & (CEPH_CAP_FILE_CACHE|CEPH_CAP_FILE_LAZYIO)) == 0) {
Sage Weila8599bd2009-10-06 11:31:12 -0700574 ci->i_rdcache_gen++;
Milosz Tanski99ccbd22013-08-21 17:29:54 -0400575 }
Sage Weila8599bd2009-10-06 11:31:12 -0700576
577 /*
Yan, Zheng15b51bd2017-09-06 10:15:16 +0800578 * If FILE_SHARED is newly issued, mark dir not complete. We don't
579 * know what happened to this directory while we didn't have the cap.
580 * If FILE_SHARED is being revoked, also mark dir not complete. It
581 * stops on-going cached readdir.
Sage Weila8599bd2009-10-06 11:31:12 -0700582 */
Yan, Zheng15b51bd2017-09-06 10:15:16 +0800583 if ((issued & CEPH_CAP_FILE_SHARED) != (had & CEPH_CAP_FILE_SHARED)) {
584 if (issued & CEPH_CAP_FILE_SHARED)
Yan, Zheng97aeb6b2017-11-27 10:47:46 +0800585 atomic_inc(&ci->i_shared_gen);
Yan, Zhenga8673d62013-02-18 16:38:14 +0800586 if (S_ISDIR(ci->vfs_inode.i_mode)) {
587 dout(" marking %p NOT complete\n", &ci->vfs_inode);
Yan, Zheng2f276c52013-03-13 19:44:32 +0800588 __ceph_dir_clear_complete(ci);
Yan, Zhenga8673d62013-02-18 16:38:14 +0800589 }
Sage Weila8599bd2009-10-06 11:31:12 -0700590 }
Jeff Layton785892f2020-01-02 07:11:38 -0500591
592 /* Wipe saved layout if we're losing DIR_CREATE caps */
593 if (S_ISDIR(ci->vfs_inode.i_mode) && (had & CEPH_CAP_DIR_CREATE) &&
594 !(issued & CEPH_CAP_DIR_CREATE)) {
595 ceph_put_string(rcu_dereference_raw(ci->i_cached_layout.pool_ns));
596 memset(&ci->i_cached_layout, 0, sizeof(ci->i_cached_layout));
597 }
Sage Weila8599bd2009-10-06 11:31:12 -0700598}
599
Jeff Layton1cf03a62020-04-01 17:07:52 -0400600/**
601 * change_auth_cap_ses - move inode to appropriate lists when auth caps change
602 * @ci: inode to be moved
603 * @session: new auth caps session
604 */
605static void change_auth_cap_ses(struct ceph_inode_info *ci,
606 struct ceph_mds_session *session)
607{
608 lockdep_assert_held(&ci->i_ceph_lock);
609
610 if (list_empty(&ci->i_dirty_item) && list_empty(&ci->i_flushing_item))
611 return;
612
613 spin_lock(&session->s_mdsc->cap_dirty_lock);
614 if (!list_empty(&ci->i_dirty_item))
615 list_move(&ci->i_dirty_item, &session->s_cap_dirty);
616 if (!list_empty(&ci->i_flushing_item))
617 list_move_tail(&ci->i_flushing_item, &session->s_cap_flushing);
618 spin_unlock(&session->s_mdsc->cap_dirty_lock);
619}
620
Sage Weila8599bd2009-10-06 11:31:12 -0700621/*
622 * Add a capability under the given MDS session.
623 *
Jeff Layton354c63a2019-07-19 09:41:02 -0400624 * Caller should hold session snap_rwsem (read) and ci->i_ceph_lock
Sage Weila8599bd2009-10-06 11:31:12 -0700625 *
626 * @fmode is the open file mode, if we are opening a file, otherwise
627 * it is < 0. (This is so we can atomically add the cap and add an
628 * open file reference to it.)
629 */
Yan, Zhengd9df2782014-04-18 09:57:11 +0800630void ceph_add_cap(struct inode *inode,
631 struct ceph_mds_session *session, u64 cap_id,
Yan, Zheng135e6712020-03-05 20:21:02 +0800632 unsigned issued, unsigned wanted,
Yan, Zhengd9df2782014-04-18 09:57:11 +0800633 unsigned seq, unsigned mseq, u64 realmino, int flags,
634 struct ceph_cap **new_cap)
Sage Weila8599bd2009-10-06 11:31:12 -0700635{
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700636 struct ceph_mds_client *mdsc = ceph_inode_to_client(inode)->mdsc;
Sage Weila8599bd2009-10-06 11:31:12 -0700637 struct ceph_inode_info *ci = ceph_inode(inode);
Sage Weila8599bd2009-10-06 11:31:12 -0700638 struct ceph_cap *cap;
639 int mds = session->s_mds;
640 int actual_wanted;
Jeff Layton606d1022019-07-22 13:12:01 -0400641 u32 gen;
Sage Weila8599bd2009-10-06 11:31:12 -0700642
Jeff Layton354c63a2019-07-19 09:41:02 -0400643 lockdep_assert_held(&ci->i_ceph_lock);
644
Sage Weila8599bd2009-10-06 11:31:12 -0700645 dout("add_cap %p mds%d cap %llx %s seq %d\n", inode,
646 session->s_mds, cap_id, ceph_cap_string(issued), seq);
647
Jeff Layton52d60f82021-06-04 12:03:09 -0400648 gen = atomic_read(&session->s_cap_gen);
Jeff Layton606d1022019-07-22 13:12:01 -0400649
Sage Weila8599bd2009-10-06 11:31:12 -0700650 cap = __get_cap_for_mds(ci, mds);
651 if (!cap) {
Yan, Zhengd9df2782014-04-18 09:57:11 +0800652 cap = *new_cap;
653 *new_cap = NULL;
Sage Weila8599bd2009-10-06 11:31:12 -0700654
655 cap->issued = 0;
656 cap->implemented = 0;
657 cap->mds = mds;
658 cap->mds_wanted = 0;
Yan, Zheng964266c2013-02-27 09:26:09 +0800659 cap->mseq = 0;
Sage Weila8599bd2009-10-06 11:31:12 -0700660
661 cap->ci = ci;
662 __insert_cap_node(ci, cap);
663
Sage Weila8599bd2009-10-06 11:31:12 -0700664 /* add to session cap list */
665 cap->session = session;
666 spin_lock(&session->s_cap_lock);
667 list_add_tail(&cap->session_caps, &session->s_caps);
668 session->s_nr_caps++;
Xiubo Li4f1d7562020-06-30 03:52:16 -0400669 atomic64_inc(&mdsc->metric.total_caps);
Sage Weila8599bd2009-10-06 11:31:12 -0700670 spin_unlock(&session->s_cap_lock);
Yan, Zheng11df2df2013-11-24 14:44:38 +0800671 } else {
Yan, Zheng32f65112019-01-23 11:20:00 +0800672 spin_lock(&session->s_cap_lock);
673 list_move_tail(&cap->session_caps, &session->s_caps);
674 spin_unlock(&session->s_cap_lock);
675
Jeff Layton606d1022019-07-22 13:12:01 -0400676 if (cap->cap_gen < gen)
Yan, Zhengd2f8bb22018-12-10 16:35:09 +0800677 cap->issued = cap->implemented = CEPH_CAP_PIN;
678
Yan, Zheng11df2df2013-11-24 14:44:38 +0800679 /*
680 * auth mds of the inode changed. we received the cap export
681 * message, but still haven't received the cap import message.
682 * handle_cap_export() updated the new auth MDS' cap.
683 *
684 * "ceph_seq_cmp(seq, cap->seq) <= 0" means we are processing
685 * a message that was send before the cap import message. So
686 * don't remove caps.
687 */
688 if (ceph_seq_cmp(seq, cap->seq) <= 0) {
689 WARN_ON(cap != ci->i_auth_cap);
690 WARN_ON(cap->cap_id != cap_id);
691 seq = cap->seq;
692 mseq = cap->mseq;
693 issued |= cap->issued;
694 flags |= CEPH_CAP_FLAG_AUTH;
695 }
696 }
Sage Weila8599bd2009-10-06 11:31:12 -0700697
Yan, Zheng7d9c9192017-12-19 18:00:54 +0800698 if (!ci->i_snap_realm ||
699 ((flags & CEPH_CAP_FLAG_AUTH) &&
700 realmino != (u64)-1 && ci->i_snap_realm->ino != realmino)) {
Sage Weila8599bd2009-10-06 11:31:12 -0700701 /*
702 * add this inode to the appropriate snap realm
703 */
704 struct ceph_snap_realm *realm = ceph_lookup_snap_realm(mdsc,
705 realmino);
Jeff Layton692e1712021-08-02 15:32:47 -0400706 if (realm)
Jeff Layton0ba92e12021-08-02 11:01:26 -0400707 ceph_change_snap_realm(inode, realm);
Jeff Layton692e1712021-08-02 15:32:47 -0400708 else
709 WARN(1, "%s: couldn't find snap realm 0x%llx (ino 0x%llx oldrealm 0x%llx)\n",
710 __func__, realmino, ci->i_vino.ino,
711 ci->i_snap_realm ? ci->i_snap_realm->ino : 0);
Sage Weila8599bd2009-10-06 11:31:12 -0700712 }
713
714 __check_cap_issue(ci, cap, issued);
715
716 /*
717 * If we are issued caps we don't want, or the mds' wanted
718 * value appears to be off, queue a check so we'll release
719 * later and/or update the mds wanted value.
720 */
721 actual_wanted = __ceph_caps_wanted(ci);
722 if ((wanted & ~actual_wanted) ||
723 (issued & ~actual_wanted & CEPH_CAP_ANY_WR)) {
724 dout(" issued %s, mds wanted %s, actual %s, queueing\n",
725 ceph_cap_string(issued), ceph_cap_string(wanted),
726 ceph_cap_string(actual_wanted));
Yan, Zhenga0d93e32020-03-05 20:21:01 +0800727 __cap_delay_requeue(mdsc, ci);
Sage Weila8599bd2009-10-06 11:31:12 -0700728 }
729
Yan, Zhengb8c2f3a2013-05-31 16:37:11 +0800730 if (flags & CEPH_CAP_FLAG_AUTH) {
Markus Elfringd37b1d92017-08-20 20:22:02 +0200731 if (!ci->i_auth_cap ||
Yan, Zhengd9ffc4f2014-03-18 10:15:29 +0800732 ceph_seq_cmp(ci->i_auth_cap->mseq, mseq) < 0) {
Jeff Layton1cf03a62020-04-01 17:07:52 -0400733 if (ci->i_auth_cap &&
734 ci->i_auth_cap->session != cap->session)
735 change_auth_cap_ses(ci, cap->session);
Yan, Zhengb8c2f3a2013-05-31 16:37:11 +0800736 ci->i_auth_cap = cap;
Yan, Zhengd9ffc4f2014-03-18 10:15:29 +0800737 cap->mds_wanted = wanted;
738 }
Yan, Zheng11df2df2013-11-24 14:44:38 +0800739 } else {
740 WARN_ON(ci->i_auth_cap == cap);
Yan, Zheng8a92a112013-01-04 14:28:07 +0800741 }
Sage Weila8599bd2009-10-06 11:31:12 -0700742
743 dout("add_cap inode %p (%llx.%llx) cap %p %s now %s seq %d mds%d\n",
744 inode, ceph_vinop(inode), cap, ceph_cap_string(issued),
745 ceph_cap_string(issued|cap->issued), seq, mds);
746 cap->cap_id = cap_id;
747 cap->issued = issued;
748 cap->implemented |= issued;
Yan, Zhengd1b87802013-11-13 14:47:19 +0800749 if (ceph_seq_cmp(mseq, cap->mseq) > 0)
Yan, Zheng964266c2013-02-27 09:26:09 +0800750 cap->mds_wanted = wanted;
751 else
752 cap->mds_wanted |= wanted;
Sage Weila8599bd2009-10-06 11:31:12 -0700753 cap->seq = seq;
754 cap->issue_seq = seq;
755 cap->mseq = mseq;
Jeff Layton606d1022019-07-22 13:12:01 -0400756 cap->cap_gen = gen;
Sage Weila8599bd2009-10-06 11:31:12 -0700757}
758
759/*
760 * Return true if cap has not timed out and belongs to the current
761 * generation of the MDS session (i.e. has not gone 'stale' due to
762 * us losing touch with the mds).
763 */
764static int __cap_is_valid(struct ceph_cap *cap)
765{
766 unsigned long ttl;
Sage Weilcdac8302009-11-10 16:02:23 -0800767 u32 gen;
Sage Weila8599bd2009-10-06 11:31:12 -0700768
Jeff Layton52d60f82021-06-04 12:03:09 -0400769 gen = atomic_read(&cap->session->s_cap_gen);
Sage Weila8599bd2009-10-06 11:31:12 -0700770 ttl = cap->session->s_cap_ttl;
Sage Weila8599bd2009-10-06 11:31:12 -0700771
Sage Weil685f9a5d2009-11-09 12:05:48 -0800772 if (cap->cap_gen < gen || time_after_eq(jiffies, ttl)) {
Sage Weila8599bd2009-10-06 11:31:12 -0700773 dout("__cap_is_valid %p cap %p issued %s "
774 "but STALE (gen %u vs %u)\n", &cap->ci->vfs_inode,
Sage Weil685f9a5d2009-11-09 12:05:48 -0800775 cap, ceph_cap_string(cap->issued), cap->cap_gen, gen);
Sage Weila8599bd2009-10-06 11:31:12 -0700776 return 0;
777 }
778
779 return 1;
780}
781
782/*
783 * Return set of valid cap bits issued to us. Note that caps time
784 * out, and may be invalidated in bulk if the client session times out
785 * and session->s_cap_gen is bumped.
786 */
787int __ceph_caps_issued(struct ceph_inode_info *ci, int *implemented)
788{
Yan, Zhengd9df2782014-04-18 09:57:11 +0800789 int have = ci->i_snap_caps;
Sage Weila8599bd2009-10-06 11:31:12 -0700790 struct ceph_cap *cap;
791 struct rb_node *p;
792
793 if (implemented)
794 *implemented = 0;
795 for (p = rb_first(&ci->i_caps); p; p = rb_next(p)) {
796 cap = rb_entry(p, struct ceph_cap, ci_node);
797 if (!__cap_is_valid(cap))
798 continue;
799 dout("__ceph_caps_issued %p cap %p issued %s\n",
800 &ci->vfs_inode, cap, ceph_cap_string(cap->issued));
801 have |= cap->issued;
802 if (implemented)
803 *implemented |= cap->implemented;
804 }
Yan, Zhengb1530f52013-07-02 12:40:20 +0800805 /*
806 * exclude caps issued by non-auth MDS, but are been revoking
807 * by the auth MDS. The non-auth MDS should be revoking/exporting
808 * these caps, but the message is delayed.
809 */
810 if (ci->i_auth_cap) {
811 cap = ci->i_auth_cap;
812 have &= ~cap->implemented | cap->issued;
813 }
Sage Weila8599bd2009-10-06 11:31:12 -0700814 return have;
815}
816
817/*
818 * Get cap bits issued by caps other than @ocap
819 */
820int __ceph_caps_issued_other(struct ceph_inode_info *ci, struct ceph_cap *ocap)
821{
822 int have = ci->i_snap_caps;
823 struct ceph_cap *cap;
824 struct rb_node *p;
825
826 for (p = rb_first(&ci->i_caps); p; p = rb_next(p)) {
827 cap = rb_entry(p, struct ceph_cap, ci_node);
828 if (cap == ocap)
829 continue;
830 if (!__cap_is_valid(cap))
831 continue;
832 have |= cap->issued;
833 }
834 return have;
835}
836
837/*
838 * Move a cap to the end of the LRU (oldest caps at list head, newest
839 * at list tail).
840 */
841static void __touch_cap(struct ceph_cap *cap)
842{
843 struct ceph_mds_session *s = cap->session;
844
Sage Weila8599bd2009-10-06 11:31:12 -0700845 spin_lock(&s->s_cap_lock);
Markus Elfringd37b1d92017-08-20 20:22:02 +0200846 if (!s->s_cap_iterator) {
Sage Weil5dacf092009-12-21 20:40:34 -0800847 dout("__touch_cap %p cap %p mds%d\n", &cap->ci->vfs_inode, cap,
848 s->s_mds);
849 list_move_tail(&cap->session_caps, &s->s_caps);
850 } else {
851 dout("__touch_cap %p cap %p mds%d NOP, iterating over caps\n",
852 &cap->ci->vfs_inode, cap, s->s_mds);
853 }
Sage Weila8599bd2009-10-06 11:31:12 -0700854 spin_unlock(&s->s_cap_lock);
855}
856
857/*
858 * Check if we hold the given mask. If so, move the cap(s) to the
859 * front of their respective LRUs. (This is the preferred way for
860 * callers to check for caps they want.)
861 */
862int __ceph_caps_issued_mask(struct ceph_inode_info *ci, int mask, int touch)
863{
864 struct ceph_cap *cap;
865 struct rb_node *p;
866 int have = ci->i_snap_caps;
867
868 if ((have & mask) == mask) {
Jeff Laytonebce3eb2020-08-18 08:03:48 -0400869 dout("__ceph_caps_issued_mask ino 0x%llx snap issued %s"
870 " (mask %s)\n", ceph_ino(&ci->vfs_inode),
Sage Weila8599bd2009-10-06 11:31:12 -0700871 ceph_cap_string(have),
872 ceph_cap_string(mask));
873 return 1;
874 }
875
876 for (p = rb_first(&ci->i_caps); p; p = rb_next(p)) {
877 cap = rb_entry(p, struct ceph_cap, ci_node);
878 if (!__cap_is_valid(cap))
879 continue;
880 if ((cap->issued & mask) == mask) {
Jeff Laytonebce3eb2020-08-18 08:03:48 -0400881 dout("__ceph_caps_issued_mask ino 0x%llx cap %p issued %s"
882 " (mask %s)\n", ceph_ino(&ci->vfs_inode), cap,
Sage Weila8599bd2009-10-06 11:31:12 -0700883 ceph_cap_string(cap->issued),
884 ceph_cap_string(mask));
885 if (touch)
886 __touch_cap(cap);
887 return 1;
888 }
889
890 /* does a combination of caps satisfy mask? */
891 have |= cap->issued;
892 if ((have & mask) == mask) {
Jeff Laytonebce3eb2020-08-18 08:03:48 -0400893 dout("__ceph_caps_issued_mask ino 0x%llx combo issued %s"
894 " (mask %s)\n", ceph_ino(&ci->vfs_inode),
Sage Weila8599bd2009-10-06 11:31:12 -0700895 ceph_cap_string(cap->issued),
896 ceph_cap_string(mask));
897 if (touch) {
898 struct rb_node *q;
899
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300900 /* touch this + preceding caps */
Sage Weila8599bd2009-10-06 11:31:12 -0700901 __touch_cap(cap);
902 for (q = rb_first(&ci->i_caps); q != p;
903 q = rb_next(q)) {
904 cap = rb_entry(q, struct ceph_cap,
905 ci_node);
906 if (!__cap_is_valid(cap))
907 continue;
Xiubo Li9f8b72b2019-12-16 00:12:07 -0500908 if (cap->issued & mask)
909 __touch_cap(cap);
Sage Weila8599bd2009-10-06 11:31:12 -0700910 }
911 }
912 return 1;
913 }
914 }
915
916 return 0;
917}
918
Xiubo Li1af16d52020-03-19 23:45:00 -0400919int __ceph_caps_issued_mask_metric(struct ceph_inode_info *ci, int mask,
920 int touch)
921{
922 struct ceph_fs_client *fsc = ceph_sb_to_client(ci->vfs_inode.i_sb);
923 int r;
924
925 r = __ceph_caps_issued_mask(ci, mask, touch);
926 if (r)
927 ceph_update_cap_hit(&fsc->mdsc->metric);
928 else
929 ceph_update_cap_mis(&fsc->mdsc->metric);
930 return r;
931}
932
Sage Weila8599bd2009-10-06 11:31:12 -0700933/*
934 * Return true if mask caps are currently being revoked by an MDS.
935 */
Yan, Zheng6ee6b9532013-07-02 12:40:21 +0800936int __ceph_caps_revoking_other(struct ceph_inode_info *ci,
937 struct ceph_cap *ocap, int mask)
938{
939 struct ceph_cap *cap;
940 struct rb_node *p;
941
942 for (p = rb_first(&ci->i_caps); p; p = rb_next(p)) {
943 cap = rb_entry(p, struct ceph_cap, ci_node);
Yan, Zheng9563f882013-11-22 13:50:45 +0800944 if (cap != ocap &&
Yan, Zheng6ee6b9532013-07-02 12:40:21 +0800945 (cap->implemented & ~cap->issued & mask))
946 return 1;
947 }
948 return 0;
949}
950
Sage Weila8599bd2009-10-06 11:31:12 -0700951int ceph_caps_revoking(struct ceph_inode_info *ci, int mask)
952{
953 struct inode *inode = &ci->vfs_inode;
Yan, Zheng6ee6b9532013-07-02 12:40:21 +0800954 int ret;
Sage Weila8599bd2009-10-06 11:31:12 -0700955
Sage Weilbe655592011-11-30 09:47:09 -0800956 spin_lock(&ci->i_ceph_lock);
Yan, Zheng6ee6b9532013-07-02 12:40:21 +0800957 ret = __ceph_caps_revoking_other(ci, NULL, mask);
Sage Weilbe655592011-11-30 09:47:09 -0800958 spin_unlock(&ci->i_ceph_lock);
Sage Weila8599bd2009-10-06 11:31:12 -0700959 dout("ceph_caps_revoking %p %s = %d\n", inode,
960 ceph_cap_string(mask), ret);
961 return ret;
962}
963
964int __ceph_caps_used(struct ceph_inode_info *ci)
965{
966 int used = 0;
967 if (ci->i_pin_ref)
968 used |= CEPH_CAP_PIN;
969 if (ci->i_rd_ref)
970 used |= CEPH_CAP_FILE_RD;
Yan, Zhengfdd4e152015-06-16 20:48:56 +0800971 if (ci->i_rdcache_ref ||
Yan, Zheng525d15e2019-05-11 17:27:59 +0800972 (S_ISREG(ci->vfs_inode.i_mode) &&
Yan, Zhengfdd4e152015-06-16 20:48:56 +0800973 ci->vfs_inode.i_data.nrpages))
Sage Weila8599bd2009-10-06 11:31:12 -0700974 used |= CEPH_CAP_FILE_CACHE;
975 if (ci->i_wr_ref)
976 used |= CEPH_CAP_FILE_WR;
Henry C Changd3d07202011-05-11 10:29:54 +0000977 if (ci->i_wb_ref || ci->i_wrbuffer_ref)
Sage Weila8599bd2009-10-06 11:31:12 -0700978 used |= CEPH_CAP_FILE_BUFFER;
Jeff Laytonf85122a2019-04-02 08:04:30 -0400979 if (ci->i_fx_ref)
980 used |= CEPH_CAP_FILE_EXCL;
Sage Weila8599bd2009-10-06 11:31:12 -0700981 return used;
982}
983
Yan, Zheng719a2512020-03-05 20:21:00 +0800984#define FMODE_WAIT_BIAS 1000
985
Sage Weila8599bd2009-10-06 11:31:12 -0700986/*
987 * wanted, by virtue of open file modes
988 */
989int __ceph_caps_file_wanted(struct ceph_inode_info *ci)
990{
Yan, Zheng719a2512020-03-05 20:21:00 +0800991 const int PIN_SHIFT = ffs(CEPH_FILE_MODE_PIN);
992 const int RD_SHIFT = ffs(CEPH_FILE_MODE_RD);
993 const int WR_SHIFT = ffs(CEPH_FILE_MODE_WR);
994 const int LAZY_SHIFT = ffs(CEPH_FILE_MODE_LAZY);
995 struct ceph_mount_options *opt =
996 ceph_inode_to_client(&ci->vfs_inode)->mount_options;
997 unsigned long used_cutoff = jiffies - opt->caps_wanted_delay_max * HZ;
998 unsigned long idle_cutoff = jiffies - opt->caps_wanted_delay_min * HZ;
999
1000 if (S_ISDIR(ci->vfs_inode.i_mode)) {
1001 int want = 0;
1002
1003 /* use used_cutoff here, to keep dir's wanted caps longer */
1004 if (ci->i_nr_by_mode[RD_SHIFT] > 0 ||
1005 time_after(ci->i_last_rd, used_cutoff))
1006 want |= CEPH_CAP_ANY_SHARED;
1007
1008 if (ci->i_nr_by_mode[WR_SHIFT] > 0 ||
1009 time_after(ci->i_last_wr, used_cutoff)) {
1010 want |= CEPH_CAP_ANY_SHARED | CEPH_CAP_FILE_EXCL;
1011 if (opt->flags & CEPH_MOUNT_OPT_ASYNC_DIROPS)
1012 want |= CEPH_CAP_ANY_DIR_OPS;
1013 }
1014
1015 if (want || ci->i_nr_by_mode[PIN_SHIFT] > 0)
1016 want |= CEPH_CAP_PIN;
1017
1018 return want;
1019 } else {
1020 int bits = 0;
1021
1022 if (ci->i_nr_by_mode[RD_SHIFT] > 0) {
1023 if (ci->i_nr_by_mode[RD_SHIFT] >= FMODE_WAIT_BIAS ||
1024 time_after(ci->i_last_rd, used_cutoff))
1025 bits |= 1 << RD_SHIFT;
1026 } else if (time_after(ci->i_last_rd, idle_cutoff)) {
1027 bits |= 1 << RD_SHIFT;
1028 }
1029
1030 if (ci->i_nr_by_mode[WR_SHIFT] > 0) {
1031 if (ci->i_nr_by_mode[WR_SHIFT] >= FMODE_WAIT_BIAS ||
1032 time_after(ci->i_last_wr, used_cutoff))
1033 bits |= 1 << WR_SHIFT;
1034 } else if (time_after(ci->i_last_wr, idle_cutoff)) {
1035 bits |= 1 << WR_SHIFT;
1036 }
1037
1038 /* check lazyio only when read/write is wanted */
1039 if ((bits & (CEPH_FILE_MODE_RDWR << 1)) &&
1040 ci->i_nr_by_mode[LAZY_SHIFT] > 0)
1041 bits |= 1 << LAZY_SHIFT;
1042
1043 return bits ? ceph_caps_for_mode(bits >> 1) : 0;
Yan, Zheng774a6a12016-06-06 16:01:39 +08001044 }
Sage Weila8599bd2009-10-06 11:31:12 -07001045}
1046
1047/*
Yan, Zheng525d15e2019-05-11 17:27:59 +08001048 * wanted, by virtue of open file modes AND cap refs (buffered/cached data)
1049 */
1050int __ceph_caps_wanted(struct ceph_inode_info *ci)
1051{
1052 int w = __ceph_caps_file_wanted(ci) | __ceph_caps_used(ci);
Jeff Laytona25949b2020-02-18 14:12:45 -05001053 if (S_ISDIR(ci->vfs_inode.i_mode)) {
1054 /* we want EXCL if holding caps of dir ops */
1055 if (w & CEPH_CAP_ANY_DIR_OPS)
1056 w |= CEPH_CAP_FILE_EXCL;
1057 } else {
Yan, Zheng525d15e2019-05-11 17:27:59 +08001058 /* we want EXCL if dirty data */
1059 if (w & CEPH_CAP_FILE_BUFFER)
1060 w |= CEPH_CAP_FILE_EXCL;
1061 }
1062 return w;
1063}
1064
1065/*
Sage Weila8599bd2009-10-06 11:31:12 -07001066 * Return caps we have registered with the MDS(s) as 'wanted'.
1067 */
Yan, Zhengc1944fe2017-01-29 22:15:47 +08001068int __ceph_caps_mds_wanted(struct ceph_inode_info *ci, bool check)
Sage Weila8599bd2009-10-06 11:31:12 -07001069{
1070 struct ceph_cap *cap;
1071 struct rb_node *p;
1072 int mds_wanted = 0;
1073
1074 for (p = rb_first(&ci->i_caps); p; p = rb_next(p)) {
1075 cap = rb_entry(p, struct ceph_cap, ci_node);
Yan, Zhengc1944fe2017-01-29 22:15:47 +08001076 if (check && !__cap_is_valid(cap))
Sage Weila8599bd2009-10-06 11:31:12 -07001077 continue;
Yan, Zhenga2550602014-03-08 09:51:45 +08001078 if (cap == ci->i_auth_cap)
1079 mds_wanted |= cap->mds_wanted;
1080 else
1081 mds_wanted |= (cap->mds_wanted & ~CEPH_CAP_ANY_FILE_WR);
Sage Weila8599bd2009-10-06 11:31:12 -07001082 }
1083 return mds_wanted;
1084}
1085
Yan, Zheng9215aee2013-11-30 12:47:41 +08001086int ceph_is_any_caps(struct inode *inode)
1087{
1088 struct ceph_inode_info *ci = ceph_inode(inode);
1089 int ret;
1090
1091 spin_lock(&ci->i_ceph_lock);
Xiubo Libd84fbc2019-12-03 03:00:51 -05001092 ret = __ceph_is_any_real_caps(ci);
Yan, Zheng9215aee2013-11-30 12:47:41 +08001093 spin_unlock(&ci->i_ceph_lock);
1094
1095 return ret;
1096}
1097
Sage Weila8599bd2009-10-06 11:31:12 -07001098/*
Sage Weilf818a732010-05-11 20:56:31 -07001099 * Remove a cap. Take steps to deal with a racing iterate_session_caps.
1100 *
Sage Weilbe655592011-11-30 09:47:09 -08001101 * caller should hold i_ceph_lock.
Sage Weila6369742010-02-22 13:59:00 -08001102 * caller will not hold session s_mutex if called from destroy_inode.
Sage Weila8599bd2009-10-06 11:31:12 -07001103 */
Yan, Zhenga096b092013-09-22 10:15:58 +08001104void __ceph_remove_cap(struct ceph_cap *cap, bool queue_release)
Sage Weila8599bd2009-10-06 11:31:12 -07001105{
1106 struct ceph_mds_session *session = cap->session;
1107 struct ceph_inode_info *ci = cap->ci;
Luis Henriquese5cafce2020-11-12 10:45:12 +00001108 struct ceph_mds_client *mdsc;
Sage Weilf818a732010-05-11 20:56:31 -07001109 int removed = 0;
Sage Weila8599bd2009-10-06 11:31:12 -07001110
Luis Henriquese5cafce2020-11-12 10:45:12 +00001111 /* 'ci' being NULL means the remove have already occurred */
1112 if (!ci) {
1113 dout("%s: cap inode is NULL\n", __func__);
1114 return;
1115 }
1116
Xiubo Lia76d0a92021-08-25 21:45:45 +08001117 lockdep_assert_held(&ci->i_ceph_lock);
1118
Sage Weila8599bd2009-10-06 11:31:12 -07001119 dout("__ceph_remove_cap %p from %p\n", cap, &ci->vfs_inode);
1120
Luis Henriquese5cafce2020-11-12 10:45:12 +00001121 mdsc = ceph_inode_to_client(&ci->vfs_inode)->mdsc;
1122
Luis Henriquesea60ed62019-10-25 14:05:24 +01001123 /* remove from inode's cap rbtree, and clear auth cap */
1124 rb_erase(&cap->ci_node, &ci->i_caps);
Xiubo Lia76d0a92021-08-25 21:45:45 +08001125 if (ci->i_auth_cap == cap)
Luis Henriquesea60ed62019-10-25 14:05:24 +01001126 ci->i_auth_cap = NULL;
1127
Sage Weil7c1332b2010-02-16 11:39:45 -08001128 /* remove from session list */
1129 spin_lock(&session->s_cap_lock);
1130 if (session->s_cap_iterator == cap) {
1131 /* not yet, we are iterating over this very cap */
1132 dout("__ceph_remove_cap delaying %p removal from session %p\n",
1133 cap, cap->session);
1134 } else {
1135 list_del_init(&cap->session_caps);
1136 session->s_nr_caps--;
Xiubo Li4f1d7562020-06-30 03:52:16 -04001137 atomic64_dec(&mdsc->metric.total_caps);
Sage Weil7c1332b2010-02-16 11:39:45 -08001138 cap->session = NULL;
Sage Weilf818a732010-05-11 20:56:31 -07001139 removed = 1;
Sage Weil7c1332b2010-02-16 11:39:45 -08001140 }
Sage Weilf818a732010-05-11 20:56:31 -07001141 /* protect backpointer with s_cap_lock: see iterate_session_caps */
1142 cap->ci = NULL;
Yan, Zheng745a8e32015-05-14 17:22:42 +08001143
1144 /*
1145 * s_cap_reconnect is protected by s_cap_lock. no one changes
1146 * s_cap_gen while session is in the reconnect state.
1147 */
1148 if (queue_release &&
Jeff Layton52d60f82021-06-04 12:03:09 -04001149 (!session->s_cap_reconnect ||
1150 cap->cap_gen == atomic_read(&session->s_cap_gen))) {
Yan, Zheng745a8e32015-05-14 17:22:42 +08001151 cap->queue_release = 1;
1152 if (removed) {
Yan, Zhenge3ec8d62019-01-14 17:21:19 +08001153 __ceph_queue_cap_release(session, cap);
Yan, Zheng745a8e32015-05-14 17:22:42 +08001154 removed = 0;
1155 }
1156 } else {
1157 cap->queue_release = 0;
1158 }
1159 cap->cap_ino = ci->i_vino.ino;
1160
Sage Weil7c1332b2010-02-16 11:39:45 -08001161 spin_unlock(&session->s_cap_lock);
1162
Sage Weilf818a732010-05-11 20:56:31 -07001163 if (removed)
Yehuda Sadeh37151662010-06-17 16:16:12 -07001164 ceph_put_cap(mdsc, cap);
Sage Weila8599bd2009-10-06 11:31:12 -07001165
Xiubo Libd84fbc2019-12-03 03:00:51 -05001166 if (!__ceph_is_any_real_caps(ci)) {
1167 /* when reconnect denied, we remove session caps forcibly,
1168 * i_wr_ref can be non-zero. If there are ongoing write,
1169 * keep i_snap_realm.
1170 */
1171 if (ci->i_wr_ref == 0 && ci->i_snap_realm)
Jeff Layton0ba92e12021-08-02 11:01:26 -04001172 ceph_change_snap_realm(&ci->vfs_inode, NULL);
Yan, Zhengdb40cc12015-03-23 20:12:20 +08001173
Sage Weila8599bd2009-10-06 11:31:12 -07001174 __cap_delay_cancel(mdsc, ci);
Xiubo Libd84fbc2019-12-03 03:00:51 -05001175 }
Sage Weila8599bd2009-10-06 11:31:12 -07001176}
1177
Xiubo Lia76d0a92021-08-25 21:45:45 +08001178void ceph_remove_cap(struct ceph_cap *cap, bool queue_release)
1179{
1180 struct ceph_inode_info *ci = cap->ci;
1181 struct ceph_fs_client *fsc;
1182
1183 /* 'ci' being NULL means the remove have already occurred */
1184 if (!ci) {
1185 dout("%s: cap inode is NULL\n", __func__);
1186 return;
1187 }
1188
1189 lockdep_assert_held(&ci->i_ceph_lock);
1190
Jeff Layton5d6451b2021-08-31 13:39:13 -04001191 fsc = ceph_inode_to_client(&ci->vfs_inode);
Xiubo Lia76d0a92021-08-25 21:45:45 +08001192 WARN_ON_ONCE(ci->i_auth_cap == cap &&
1193 !list_empty(&ci->i_dirty_item) &&
1194 !fsc->blocklisted &&
Jeff Layton5d6451b2021-08-31 13:39:13 -04001195 !ceph_inode_is_shutdown(&ci->vfs_inode));
Xiubo Lia76d0a92021-08-25 21:45:45 +08001196
1197 __ceph_remove_cap(cap, queue_release);
1198}
1199
Jeff Layton0ff8bfb2016-11-10 07:42:03 -05001200struct cap_msg_args {
1201 struct ceph_mds_session *session;
1202 u64 ino, cid, follows;
1203 u64 flush_tid, oldest_flush_tid, size, max_size;
1204 u64 xattr_version;
Jeff Layton176c77c2019-06-06 08:06:40 -04001205 u64 change_attr;
Jeff Layton0ff8bfb2016-11-10 07:42:03 -05001206 struct ceph_buffer *xattr_buf;
Jeff Layton0a454bd2020-03-17 08:47:31 -04001207 struct ceph_buffer *old_xattr_buf;
Jeff Laytonec62b892019-05-29 12:23:14 -04001208 struct timespec64 atime, mtime, ctime, btime;
Jeff Layton0ff8bfb2016-11-10 07:42:03 -05001209 int op, caps, wanted, dirty;
1210 u32 seq, issue_seq, mseq, time_warp_seq;
Jeff Layton1e4ef0c2016-11-10 07:42:06 -05001211 u32 flags;
Jeff Layton0ff8bfb2016-11-10 07:42:03 -05001212 kuid_t uid;
1213 kgid_t gid;
1214 umode_t mode;
1215 bool inline_data;
Jeff Layton0a454bd2020-03-17 08:47:31 -04001216 bool wake;
Jeff Layton0ff8bfb2016-11-10 07:42:03 -05001217};
1218
Sage Weila8599bd2009-10-06 11:31:12 -07001219/*
Jeff Layton16d68902020-03-30 07:20:27 -04001220 * cap struct size + flock buffer size + inline version + inline data size +
1221 * osd_epoch_barrier + oldest_flush_tid
Sage Weila8599bd2009-10-06 11:31:12 -07001222 */
Jeff Layton16d68902020-03-30 07:20:27 -04001223#define CAP_MSG_SIZE (sizeof(struct ceph_mds_caps) + \
1224 4 + 8 + 4 + 4 + 8 + 4 + 4 + 4 + 8 + 8 + 4)
1225
1226/* Marshal up the cap msg to the MDS */
1227static void encode_cap_msg(struct ceph_msg *msg, struct cap_msg_args *arg)
Sage Weila8599bd2009-10-06 11:31:12 -07001228{
1229 struct ceph_mds_caps *fc;
Yan, Zhenge20d2582014-11-14 22:39:13 +08001230 void *p;
Jeff Layton92475f02017-04-13 11:07:04 -04001231 struct ceph_osd_client *osdc = &arg->session->s_mdsc->fsc->client->osdc;
Sage Weila8599bd2009-10-06 11:31:12 -07001232
Jeff Layton16d68902020-03-30 07:20:27 -04001233 dout("%s %s %llx %llx caps %s wanted %s dirty %s seq %u/%u tid %llu/%llu mseq %u follows %lld size %llu/%llu xattr_ver %llu xattr_len %d\n",
1234 __func__, ceph_cap_op_name(arg->op), arg->cid, arg->ino,
1235 ceph_cap_string(arg->caps), ceph_cap_string(arg->wanted),
1236 ceph_cap_string(arg->dirty), arg->seq, arg->issue_seq,
1237 arg->flush_tid, arg->oldest_flush_tid, arg->mseq, arg->follows,
1238 arg->size, arg->max_size, arg->xattr_version,
Jeff Layton0ff8bfb2016-11-10 07:42:03 -05001239 arg->xattr_buf ? (int)arg->xattr_buf->vec.iov_len : 0);
Sage Weila8599bd2009-10-06 11:31:12 -07001240
Jeff Layton43b29672016-11-10 07:42:05 -05001241 msg->hdr.version = cpu_to_le16(10);
Jeff Layton0ff8bfb2016-11-10 07:42:03 -05001242 msg->hdr.tid = cpu_to_le64(arg->flush_tid);
Sage Weila8599bd2009-10-06 11:31:12 -07001243
Sage Weil6df058c2009-12-22 11:24:33 -08001244 fc = msg->front.iov_base;
Sage Weila8599bd2009-10-06 11:31:12 -07001245 memset(fc, 0, sizeof(*fc));
1246
Jeff Layton0ff8bfb2016-11-10 07:42:03 -05001247 fc->cap_id = cpu_to_le64(arg->cid);
1248 fc->op = cpu_to_le32(arg->op);
1249 fc->seq = cpu_to_le32(arg->seq);
1250 fc->issue_seq = cpu_to_le32(arg->issue_seq);
1251 fc->migrate_seq = cpu_to_le32(arg->mseq);
1252 fc->caps = cpu_to_le32(arg->caps);
1253 fc->wanted = cpu_to_le32(arg->wanted);
1254 fc->dirty = cpu_to_le32(arg->dirty);
1255 fc->ino = cpu_to_le64(arg->ino);
1256 fc->snap_follows = cpu_to_le64(arg->follows);
Sage Weila8599bd2009-10-06 11:31:12 -07001257
Jeff Layton0ff8bfb2016-11-10 07:42:03 -05001258 fc->size = cpu_to_le64(arg->size);
1259 fc->max_size = cpu_to_le64(arg->max_size);
Arnd Bergmann9bbeab42018-07-13 22:18:36 +02001260 ceph_encode_timespec64(&fc->mtime, &arg->mtime);
1261 ceph_encode_timespec64(&fc->atime, &arg->atime);
1262 ceph_encode_timespec64(&fc->ctime, &arg->ctime);
Jeff Layton0ff8bfb2016-11-10 07:42:03 -05001263 fc->time_warp_seq = cpu_to_le32(arg->time_warp_seq);
Sage Weila8599bd2009-10-06 11:31:12 -07001264
Jeff Layton0ff8bfb2016-11-10 07:42:03 -05001265 fc->uid = cpu_to_le32(from_kuid(&init_user_ns, arg->uid));
1266 fc->gid = cpu_to_le32(from_kgid(&init_user_ns, arg->gid));
1267 fc->mode = cpu_to_le32(arg->mode);
Sage Weila8599bd2009-10-06 11:31:12 -07001268
Jeff Layton0ff8bfb2016-11-10 07:42:03 -05001269 fc->xattr_version = cpu_to_le64(arg->xattr_version);
1270 if (arg->xattr_buf) {
1271 msg->middle = ceph_buffer_get(arg->xattr_buf);
1272 fc->xattr_len = cpu_to_le32(arg->xattr_buf->vec.iov_len);
1273 msg->hdr.middle_len = cpu_to_le32(arg->xattr_buf->vec.iov_len);
Jeff Layton96700792016-11-10 07:42:02 -05001274 }
1275
Yan, Zhenge20d2582014-11-14 22:39:13 +08001276 p = fc + 1;
Jeff Layton43b29672016-11-10 07:42:05 -05001277 /* flock buffer size (version 2) */
Yan, Zhenge20d2582014-11-14 22:39:13 +08001278 ceph_encode_32(&p, 0);
Jeff Layton43b29672016-11-10 07:42:05 -05001279 /* inline version (version 4) */
Jeff Layton0ff8bfb2016-11-10 07:42:03 -05001280 ceph_encode_64(&p, arg->inline_data ? 0 : CEPH_INLINE_NONE);
Yan, Zhenge20d2582014-11-14 22:39:13 +08001281 /* inline data size */
1282 ceph_encode_32(&p, 0);
Jeff Layton92475f02017-04-13 11:07:04 -04001283 /*
1284 * osd_epoch_barrier (version 5)
1285 * The epoch_barrier is protected osdc->lock, so READ_ONCE here in
1286 * case it was recently changed
1287 */
1288 ceph_encode_32(&p, READ_ONCE(osdc->epoch_barrier));
Jeff Layton43b29672016-11-10 07:42:05 -05001289 /* oldest_flush_tid (version 6) */
Jeff Layton0ff8bfb2016-11-10 07:42:03 -05001290 ceph_encode_64(&p, arg->oldest_flush_tid);
Yan, Zhenge20d2582014-11-14 22:39:13 +08001291
Jeff Layton43b29672016-11-10 07:42:05 -05001292 /*
1293 * caller_uid/caller_gid (version 7)
1294 *
1295 * Currently, we don't properly track which caller dirtied the caps
1296 * last, and force a flush of them when there is a conflict. For now,
1297 * just set this to 0:0, to emulate how the MDS has worked up to now.
1298 */
1299 ceph_encode_32(&p, 0);
1300 ceph_encode_32(&p, 0);
1301
1302 /* pool namespace (version 8) (mds always ignores this) */
1303 ceph_encode_32(&p, 0);
1304
Jeff Layton176c77c2019-06-06 08:06:40 -04001305 /* btime and change_attr (version 9) */
Jeff Laytonec62b892019-05-29 12:23:14 -04001306 ceph_encode_timespec64(p, &arg->btime);
Jeff Layton43b29672016-11-10 07:42:05 -05001307 p += sizeof(struct ceph_timespec);
Jeff Layton176c77c2019-06-06 08:06:40 -04001308 ceph_encode_64(&p, arg->change_attr);
Jeff Layton43b29672016-11-10 07:42:05 -05001309
1310 /* Advisory flags (version 10) */
Jeff Layton1e4ef0c2016-11-10 07:42:06 -05001311 ceph_encode_32(&p, arg->flags);
Sage Weila8599bd2009-10-06 11:31:12 -07001312}
1313
1314/*
Yan, Zhengd6e47812019-05-23 11:01:37 +08001315 * Queue cap releases when an inode is dropped from our cache.
Sage Weila8599bd2009-10-06 11:31:12 -07001316 */
Yan, Zhengd6e47812019-05-23 11:01:37 +08001317void __ceph_remove_caps(struct ceph_inode_info *ci)
Sage Weila8599bd2009-10-06 11:31:12 -07001318{
Sage Weila8599bd2009-10-06 11:31:12 -07001319 struct rb_node *p;
1320
Yan, Zhengd6e47812019-05-23 11:01:37 +08001321 /* lock i_ceph_lock, because ceph_d_revalidate(..., LOOKUP_RCU)
1322 * may call __ceph_caps_issued_mask() on a freeing inode. */
1323 spin_lock(&ci->i_ceph_lock);
Sage Weila8599bd2009-10-06 11:31:12 -07001324 p = rb_first(&ci->i_caps);
1325 while (p) {
1326 struct ceph_cap *cap = rb_entry(p, struct ceph_cap, ci_node);
Sage Weila8599bd2009-10-06 11:31:12 -07001327 p = rb_next(p);
Xiubo Lia76d0a92021-08-25 21:45:45 +08001328 ceph_remove_cap(cap, true);
Sage Weila8599bd2009-10-06 11:31:12 -07001329 }
Yan, Zhengd6e47812019-05-23 11:01:37 +08001330 spin_unlock(&ci->i_ceph_lock);
Sage Weila8599bd2009-10-06 11:31:12 -07001331}
1332
1333/*
Jeff Layton0a454bd2020-03-17 08:47:31 -04001334 * Prepare to send a cap message to an MDS. Update the cap state, and populate
1335 * the arg struct with the parameters that will need to be sent. This should
1336 * be done under the i_ceph_lock to guard against changes to cap state.
Sage Weila8599bd2009-10-06 11:31:12 -07001337 *
1338 * Make note of max_size reported/requested from mds, revoked caps
1339 * that have now been implemented.
Sage Weila8599bd2009-10-06 11:31:12 -07001340 */
Jeff Layton0a454bd2020-03-17 08:47:31 -04001341static void __prep_cap(struct cap_msg_args *arg, struct ceph_cap *cap,
1342 int op, int flags, int used, int want, int retain,
1343 int flushing, u64 flush_tid, u64 oldest_flush_tid)
Sage Weila8599bd2009-10-06 11:31:12 -07001344{
1345 struct ceph_inode_info *ci = cap->ci;
1346 struct inode *inode = &ci->vfs_inode;
Colin Ian Kingbb0581f2017-10-18 12:34:25 +01001347 int held, revoking;
Sage Weila8599bd2009-10-06 11:31:12 -07001348
Jeff Layton0a454bd2020-03-17 08:47:31 -04001349 lockdep_assert_held(&ci->i_ceph_lock);
Jeff Layton891f3f52020-01-14 15:06:40 -05001350
Sage Weil68c28322010-02-09 13:41:47 -08001351 held = cap->issued | cap->implemented;
1352 revoking = cap->implemented & ~cap->issued;
1353 retain &= ~revoking;
Sage Weil68c28322010-02-09 13:41:47 -08001354
Jeff Layton0a454bd2020-03-17 08:47:31 -04001355 dout("%s %p cap %p session %p %s -> %s (revoking %s)\n",
1356 __func__, inode, cap, cap->session,
Sage Weila8599bd2009-10-06 11:31:12 -07001357 ceph_cap_string(held), ceph_cap_string(held & retain),
1358 ceph_cap_string(revoking));
1359 BUG_ON((retain & CEPH_CAP_PIN) == 0);
1360
Yan, Zhenga0d93e32020-03-05 20:21:01 +08001361 ci->i_ceph_flags &= ~CEPH_I_FLUSH;
Sage Weila8599bd2009-10-06 11:31:12 -07001362
1363 cap->issued &= retain; /* drop bits we don't want */
Jeff Layton0a454bd2020-03-17 08:47:31 -04001364 /*
1365 * Wake up any waiters on wanted -> needed transition. This is due to
1366 * the weird transition from buffered to sync IO... we need to flush
1367 * dirty pages _before_ allowing sync writes to avoid reordering.
1368 */
1369 arg->wake = cap->implemented & ~cap->issued;
Sage Weila8599bd2009-10-06 11:31:12 -07001370 cap->implemented &= cap->issued | used;
1371 cap->mds_wanted = want;
1372
Jeff Layton0a454bd2020-03-17 08:47:31 -04001373 arg->session = cap->session;
1374 arg->ino = ceph_vino(inode).ino;
1375 arg->cid = cap->cap_id;
1376 arg->follows = flushing ? ci->i_head_snapc->seq : 0;
1377 arg->flush_tid = flush_tid;
1378 arg->oldest_flush_tid = oldest_flush_tid;
Sage Weila8599bd2009-10-06 11:31:12 -07001379
Jeff Layton2d6795f2021-04-09 15:58:35 -04001380 arg->size = i_size_read(inode);
Jeff Layton0a454bd2020-03-17 08:47:31 -04001381 ci->i_reported_size = arg->size;
1382 arg->max_size = ci->i_wanted_max_size;
Yan, Zheng6f05b302020-03-30 19:56:37 +08001383 if (cap == ci->i_auth_cap) {
1384 if (want & CEPH_CAP_ANY_FILE_WR)
1385 ci->i_requested_max_size = arg->max_size;
1386 else
1387 ci->i_requested_max_size = 0;
1388 }
Sage Weila8599bd2009-10-06 11:31:12 -07001389
Sage Weil082afec2010-08-22 15:16:41 -07001390 if (flushing & CEPH_CAP_XATTR_EXCL) {
Jeff Layton0a454bd2020-03-17 08:47:31 -04001391 arg->old_xattr_buf = __ceph_build_xattrs_blob(ci);
1392 arg->xattr_version = ci->i_xattrs.version;
1393 arg->xattr_buf = ci->i_xattrs.blob;
Jeff Layton0ff8bfb2016-11-10 07:42:03 -05001394 } else {
Jeff Layton0a454bd2020-03-17 08:47:31 -04001395 arg->xattr_buf = NULL;
1396 arg->old_xattr_buf = NULL;
Sage Weila8599bd2009-10-06 11:31:12 -07001397 }
1398
Jeff Layton0a454bd2020-03-17 08:47:31 -04001399 arg->mtime = inode->i_mtime;
1400 arg->atime = inode->i_atime;
1401 arg->ctime = inode->i_ctime;
1402 arg->btime = ci->i_btime;
1403 arg->change_attr = inode_peek_iversion_raw(inode);
Jeff Layton0ff8bfb2016-11-10 07:42:03 -05001404
Jeff Layton0a454bd2020-03-17 08:47:31 -04001405 arg->op = op;
1406 arg->caps = cap->implemented;
1407 arg->wanted = want;
1408 arg->dirty = flushing;
Jeff Layton0ff8bfb2016-11-10 07:42:03 -05001409
Jeff Layton0a454bd2020-03-17 08:47:31 -04001410 arg->seq = cap->seq;
1411 arg->issue_seq = cap->issue_seq;
1412 arg->mseq = cap->mseq;
1413 arg->time_warp_seq = ci->i_time_warp_seq;
Jeff Layton0ff8bfb2016-11-10 07:42:03 -05001414
Jeff Layton0a454bd2020-03-17 08:47:31 -04001415 arg->uid = inode->i_uid;
1416 arg->gid = inode->i_gid;
1417 arg->mode = inode->i_mode;
Jeff Layton0ff8bfb2016-11-10 07:42:03 -05001418
Jeff Layton0a454bd2020-03-17 08:47:31 -04001419 arg->inline_data = ci->i_inline_version != CEPH_INLINE_NONE;
Yan, Zheng49ada6e2019-06-20 12:09:08 +08001420 if (!(flags & CEPH_CLIENT_CAPS_PENDING_CAPSNAP) &&
1421 !list_empty(&ci->i_cap_snaps)) {
1422 struct ceph_cap_snap *capsnap;
1423 list_for_each_entry_reverse(capsnap, &ci->i_cap_snaps, ci_item) {
1424 if (capsnap->cap_flush.tid)
1425 break;
1426 if (capsnap->need_flush) {
1427 flags |= CEPH_CLIENT_CAPS_PENDING_CAPSNAP;
1428 break;
1429 }
1430 }
1431 }
Jeff Layton0a454bd2020-03-17 08:47:31 -04001432 arg->flags = flags;
1433}
Yan, Zhenge20d2582014-11-14 22:39:13 +08001434
Jeff Layton0a454bd2020-03-17 08:47:31 -04001435/*
1436 * Send a cap msg on the given inode.
1437 *
1438 * Caller should hold snap_rwsem (read), s_mutex.
1439 */
Jeff Layton52311982020-03-30 13:07:23 -04001440static void __send_cap(struct cap_msg_args *arg, struct ceph_inode_info *ci)
Jeff Layton0a454bd2020-03-17 08:47:31 -04001441{
Jeff Layton16d68902020-03-30 07:20:27 -04001442 struct ceph_msg *msg;
Jeff Layton0a454bd2020-03-17 08:47:31 -04001443 struct inode *inode = &ci->vfs_inode;
Sage Weila8599bd2009-10-06 11:31:12 -07001444
Jeff Layton16d68902020-03-30 07:20:27 -04001445 msg = ceph_msg_new(CEPH_MSG_CLIENT_CAPS, CAP_MSG_SIZE, GFP_NOFS, false);
1446 if (!msg) {
1447 pr_err("error allocating cap msg: ino (%llx.%llx) flushing %s tid %llu, requeuing cap.\n",
Jeff Layton0a454bd2020-03-17 08:47:31 -04001448 ceph_vinop(inode), ceph_cap_string(arg->dirty),
1449 arg->flush_tid);
Yan, Zhenga0d93e32020-03-05 20:21:01 +08001450 spin_lock(&ci->i_ceph_lock);
Jeff Layton52311982020-03-30 13:07:23 -04001451 __cap_delay_requeue(arg->session->s_mdsc, ci);
Yan, Zhenga0d93e32020-03-05 20:21:01 +08001452 spin_unlock(&ci->i_ceph_lock);
Jeff Layton16d68902020-03-30 07:20:27 -04001453 return;
Sage Weila8599bd2009-10-06 11:31:12 -07001454 }
1455
Jeff Layton16d68902020-03-30 07:20:27 -04001456 encode_cap_msg(msg, arg);
1457 ceph_con_send(&arg->session->s_con, msg);
Jeff Layton0a454bd2020-03-17 08:47:31 -04001458 ceph_buffer_put(arg->old_xattr_buf);
Jeff Layton0a454bd2020-03-17 08:47:31 -04001459 if (arg->wake)
1460 wake_up_all(&ci->i_cap_wq);
Sage Weila8599bd2009-10-06 11:31:12 -07001461}
1462
Yan, Zheng0e294382016-07-04 18:06:41 +08001463static inline int __send_flush_snap(struct inode *inode,
1464 struct ceph_mds_session *session,
1465 struct ceph_cap_snap *capsnap,
1466 u32 mseq, u64 oldest_flush_tid)
1467{
Jeff Layton0ff8bfb2016-11-10 07:42:03 -05001468 struct cap_msg_args arg;
Jeff Layton16d68902020-03-30 07:20:27 -04001469 struct ceph_msg *msg;
1470
1471 msg = ceph_msg_new(CEPH_MSG_CLIENT_CAPS, CAP_MSG_SIZE, GFP_NOFS, false);
1472 if (!msg)
1473 return -ENOMEM;
Jeff Layton0ff8bfb2016-11-10 07:42:03 -05001474
1475 arg.session = session;
1476 arg.ino = ceph_vino(inode).ino;
1477 arg.cid = 0;
1478 arg.follows = capsnap->follows;
1479 arg.flush_tid = capsnap->cap_flush.tid;
1480 arg.oldest_flush_tid = oldest_flush_tid;
1481
1482 arg.size = capsnap->size;
1483 arg.max_size = 0;
1484 arg.xattr_version = capsnap->xattr_version;
1485 arg.xattr_buf = capsnap->xattr_blob;
Jeff Layton0a454bd2020-03-17 08:47:31 -04001486 arg.old_xattr_buf = NULL;
Jeff Layton0ff8bfb2016-11-10 07:42:03 -05001487
1488 arg.atime = capsnap->atime;
1489 arg.mtime = capsnap->mtime;
1490 arg.ctime = capsnap->ctime;
Jeff Laytonec62b892019-05-29 12:23:14 -04001491 arg.btime = capsnap->btime;
Jeff Layton176c77c2019-06-06 08:06:40 -04001492 arg.change_attr = capsnap->change_attr;
Jeff Layton0ff8bfb2016-11-10 07:42:03 -05001493
1494 arg.op = CEPH_CAP_OP_FLUSHSNAP;
1495 arg.caps = capsnap->issued;
1496 arg.wanted = 0;
1497 arg.dirty = capsnap->dirty;
1498
1499 arg.seq = 0;
1500 arg.issue_seq = 0;
1501 arg.mseq = mseq;
1502 arg.time_warp_seq = capsnap->time_warp_seq;
1503
1504 arg.uid = capsnap->uid;
1505 arg.gid = capsnap->gid;
1506 arg.mode = capsnap->mode;
1507
1508 arg.inline_data = capsnap->inline_data;
Jeff Layton1e4ef0c2016-11-10 07:42:06 -05001509 arg.flags = 0;
Jeff Layton0a454bd2020-03-17 08:47:31 -04001510 arg.wake = false;
Jeff Layton0ff8bfb2016-11-10 07:42:03 -05001511
Jeff Layton16d68902020-03-30 07:20:27 -04001512 encode_cap_msg(msg, &arg);
1513 ceph_con_send(&arg.session->s_con, msg);
1514 return 0;
Yan, Zheng0e294382016-07-04 18:06:41 +08001515}
1516
Sage Weila8599bd2009-10-06 11:31:12 -07001517/*
1518 * When a snapshot is taken, clients accumulate dirty metadata on
1519 * inodes with capabilities in ceph_cap_snaps to describe the file
1520 * state at the time the snapshot was taken. This must be flushed
1521 * asynchronously back to the MDS once sync writes complete and dirty
1522 * data is written out.
1523 *
Jeff Layton7732fe12021-06-14 15:38:39 -04001524 * Called under i_ceph_lock.
Sage Weila8599bd2009-10-06 11:31:12 -07001525 */
Yan, Zhenged9b4302016-07-05 21:08:07 +08001526static void __ceph_flush_snaps(struct ceph_inode_info *ci,
1527 struct ceph_mds_session *session)
Sage Weilbe655592011-11-30 09:47:09 -08001528 __releases(ci->i_ceph_lock)
1529 __acquires(ci->i_ceph_lock)
Sage Weila8599bd2009-10-06 11:31:12 -07001530{
1531 struct inode *inode = &ci->vfs_inode;
Yan, Zhenged9b4302016-07-05 21:08:07 +08001532 struct ceph_mds_client *mdsc = session->s_mdsc;
Sage Weila8599bd2009-10-06 11:31:12 -07001533 struct ceph_cap_snap *capsnap;
Yan, Zhenged9b4302016-07-05 21:08:07 +08001534 u64 oldest_flush_tid = 0;
1535 u64 first_tid = 1, last_tid = 0;
Sage Weila8599bd2009-10-06 11:31:12 -07001536
Yan, Zhenged9b4302016-07-05 21:08:07 +08001537 dout("__flush_snaps %p session %p\n", inode, session);
Sage Weila8599bd2009-10-06 11:31:12 -07001538
Sage Weila8599bd2009-10-06 11:31:12 -07001539 list_for_each_entry(capsnap, &ci->i_cap_snaps, ci_item) {
Sage Weila8599bd2009-10-06 11:31:12 -07001540 /*
1541 * we need to wait for sync writes to complete and for dirty
1542 * pages to be written out.
1543 */
1544 if (capsnap->dirty_pages || capsnap->writing)
Sage Weilcfc0bf62010-09-14 15:50:59 -07001545 break;
Sage Weila8599bd2009-10-06 11:31:12 -07001546
Yan, Zheng86056092015-05-01 16:57:16 +08001547 /* should be removed by ceph_try_drop_cap_snap() */
1548 BUG_ON(!capsnap->need_flush);
Sage Weil819ccbf2010-04-01 09:33:46 -07001549
Sage Weile8351242010-09-17 08:03:08 -07001550 /* only flush each capsnap once */
Yan, Zheng0e294382016-07-04 18:06:41 +08001551 if (capsnap->cap_flush.tid > 0) {
Yan, Zhenged9b4302016-07-05 21:08:07 +08001552 dout(" already flushed %p, skipping\n", capsnap);
Sage Weile8351242010-09-17 08:03:08 -07001553 continue;
1554 }
1555
Yan, Zheng553adfd2015-06-09 15:48:57 +08001556 spin_lock(&mdsc->cap_dirty_lock);
Yan, Zheng0e294382016-07-04 18:06:41 +08001557 capsnap->cap_flush.tid = ++mdsc->last_cap_flush_tid;
1558 list_add_tail(&capsnap->cap_flush.g_list,
1559 &mdsc->cap_flush_list);
Yan, Zhenged9b4302016-07-05 21:08:07 +08001560 if (oldest_flush_tid == 0)
1561 oldest_flush_tid = __get_oldest_flush_tid(mdsc);
Yan, Zheng0e294382016-07-04 18:06:41 +08001562 if (list_empty(&ci->i_flushing_item)) {
1563 list_add_tail(&ci->i_flushing_item,
1564 &session->s_cap_flushing);
1565 }
Yan, Zheng553adfd2015-06-09 15:48:57 +08001566 spin_unlock(&mdsc->cap_dirty_lock);
1567
Yan, Zheng0e294382016-07-04 18:06:41 +08001568 list_add_tail(&capsnap->cap_flush.i_list,
1569 &ci->i_cap_flush_list);
1570
Yan, Zhenged9b4302016-07-05 21:08:07 +08001571 if (first_tid == 1)
1572 first_tid = capsnap->cap_flush.tid;
1573 last_tid = capsnap->cap_flush.tid;
1574 }
1575
1576 ci->i_ceph_flags &= ~CEPH_I_FLUSH_SNAPS;
1577
1578 while (first_tid <= last_tid) {
1579 struct ceph_cap *cap = ci->i_auth_cap;
1580 struct ceph_cap_flush *cf;
1581 int ret;
1582
1583 if (!(cap && cap->session == session)) {
1584 dout("__flush_snaps %p auth cap %p not mds%d, "
1585 "stop\n", inode, cap, session->s_mds);
1586 break;
1587 }
1588
1589 ret = -ENOENT;
1590 list_for_each_entry(cf, &ci->i_cap_flush_list, i_list) {
1591 if (cf->tid >= first_tid) {
1592 ret = 0;
1593 break;
1594 }
1595 }
1596 if (ret < 0)
1597 break;
1598
1599 first_tid = cf->tid + 1;
1600
1601 capsnap = container_of(cf, struct ceph_cap_snap, cap_flush);
Elena Reshetova805692d2017-03-03 11:15:07 +02001602 refcount_inc(&capsnap->nref);
Sage Weilbe655592011-11-30 09:47:09 -08001603 spin_unlock(&ci->i_ceph_lock);
Sage Weila8599bd2009-10-06 11:31:12 -07001604
Yan, Zhenged9b4302016-07-05 21:08:07 +08001605 dout("__flush_snaps %p capsnap %p tid %llu %s\n",
1606 inode, capsnap, cf->tid, ceph_cap_string(capsnap->dirty));
Sage Weila8599bd2009-10-06 11:31:12 -07001607
Yan, Zhenged9b4302016-07-05 21:08:07 +08001608 ret = __send_flush_snap(inode, session, capsnap, cap->mseq,
1609 oldest_flush_tid);
1610 if (ret < 0) {
1611 pr_err("__flush_snaps: error sending cap flushsnap, "
1612 "ino (%llx.%llx) tid %llu follows %llu\n",
1613 ceph_vinop(inode), cf->tid, capsnap->follows);
1614 }
1615
Sage Weila8599bd2009-10-06 11:31:12 -07001616 ceph_put_cap_snap(capsnap);
Sage Weilbe655592011-11-30 09:47:09 -08001617 spin_lock(&ci->i_ceph_lock);
Yan, Zhenged9b4302016-07-05 21:08:07 +08001618 }
1619}
1620
1621void ceph_flush_snaps(struct ceph_inode_info *ci,
1622 struct ceph_mds_session **psession)
1623{
1624 struct inode *inode = &ci->vfs_inode;
1625 struct ceph_mds_client *mdsc = ceph_inode_to_client(inode)->mdsc;
Yan, Zhenge4d2b162016-08-04 08:43:33 +08001626 struct ceph_mds_session *session = NULL;
Yan, Zhenged9b4302016-07-05 21:08:07 +08001627 int mds;
Yan, Zhenge4d2b162016-08-04 08:43:33 +08001628
Yan, Zhenged9b4302016-07-05 21:08:07 +08001629 dout("ceph_flush_snaps %p\n", inode);
Yan, Zhenge4d2b162016-08-04 08:43:33 +08001630 if (psession)
1631 session = *psession;
Yan, Zhenged9b4302016-07-05 21:08:07 +08001632retry:
1633 spin_lock(&ci->i_ceph_lock);
1634 if (!(ci->i_ceph_flags & CEPH_I_FLUSH_SNAPS)) {
1635 dout(" no capsnap needs flush, doing nothing\n");
1636 goto out;
1637 }
1638 if (!ci->i_auth_cap) {
1639 dout(" no auth cap (migrating?), doing nothing\n");
1640 goto out;
1641 }
1642
1643 mds = ci->i_auth_cap->session->s_mds;
1644 if (session && session->s_mds != mds) {
1645 dout(" oops, wrong session %p mutex\n", session);
Yan, Zhenged9b4302016-07-05 21:08:07 +08001646 ceph_put_mds_session(session);
1647 session = NULL;
1648 }
1649 if (!session) {
1650 spin_unlock(&ci->i_ceph_lock);
1651 mutex_lock(&mdsc->mutex);
1652 session = __ceph_lookup_mds_session(mdsc, mds);
1653 mutex_unlock(&mdsc->mutex);
Sage Weila8599bd2009-10-06 11:31:12 -07001654 goto retry;
1655 }
1656
Yan, Zheng24d063a2017-08-15 11:37:32 +08001657 // make sure flushsnap messages are sent in proper order.
Yan, Zheng054f8d42019-06-20 16:00:31 +08001658 if (ci->i_ceph_flags & CEPH_I_KICK_FLUSH)
Yan, Zheng24d063a2017-08-15 11:37:32 +08001659 __kick_flushing_caps(mdsc, session, ci, 0);
Yan, Zheng24d063a2017-08-15 11:37:32 +08001660
Yan, Zhenged9b4302016-07-05 21:08:07 +08001661 __ceph_flush_snaps(ci, session);
1662out:
1663 spin_unlock(&ci->i_ceph_lock);
1664
Jeff Layton7732fe12021-06-14 15:38:39 -04001665 if (psession)
Yan, Zhenged9b4302016-07-05 21:08:07 +08001666 *psession = session;
Jeff Layton7732fe12021-06-14 15:38:39 -04001667 else
Yan, Zhenged9b4302016-07-05 21:08:07 +08001668 ceph_put_mds_session(session);
Sage Weila8599bd2009-10-06 11:31:12 -07001669 /* we flushed them all; remove this inode from the queue */
1670 spin_lock(&mdsc->snap_flush_lock);
1671 list_del_init(&ci->i_snap_flush_item);
1672 spin_unlock(&mdsc->snap_flush_lock);
Sage Weila8599bd2009-10-06 11:31:12 -07001673}
1674
1675/*
Sage Weilfca65b42011-05-04 11:33:47 -07001676 * Mark caps dirty. If inode is newly dirty, return the dirty flags.
1677 * Caller is then responsible for calling __mark_inode_dirty with the
1678 * returned flags value.
Sage Weil76e3b392009-10-15 18:13:53 -07001679 */
Yan, Zhengf66fd9f2015-06-10 17:26:13 +08001680int __ceph_mark_dirty_caps(struct ceph_inode_info *ci, int mask,
1681 struct ceph_cap_flush **pcf)
Sage Weil76e3b392009-10-15 18:13:53 -07001682{
Cheng Renquan640ef792010-03-26 17:40:33 +08001683 struct ceph_mds_client *mdsc =
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -07001684 ceph_sb_to_client(ci->vfs_inode.i_sb)->mdsc;
Sage Weil76e3b392009-10-15 18:13:53 -07001685 struct inode *inode = &ci->vfs_inode;
1686 int was = ci->i_dirty_caps;
1687 int dirty = 0;
1688
Jeff Laytonc7e4f852020-02-25 11:08:33 -08001689 lockdep_assert_held(&ci->i_ceph_lock);
1690
Yan, Zheng571ade32015-03-24 11:36:08 +08001691 if (!ci->i_auth_cap) {
1692 pr_warn("__mark_dirty_caps %p %llx mask %s, "
1693 "but no auth cap (session was closed?)\n",
1694 inode, ceph_ino(inode), ceph_cap_string(mask));
1695 return 0;
1696 }
1697
Sage Weil76e3b392009-10-15 18:13:53 -07001698 dout("__mark_dirty_caps %p %s dirty %s -> %s\n", &ci->vfs_inode,
1699 ceph_cap_string(mask), ceph_cap_string(was),
1700 ceph_cap_string(was | mask));
1701 ci->i_dirty_caps |= mask;
1702 if (was == 0) {
Jeff Layton1cf03a62020-04-01 17:07:52 -04001703 struct ceph_mds_session *session = ci->i_auth_cap->session;
1704
Yan, Zhengf66fd9f2015-06-10 17:26:13 +08001705 WARN_ON_ONCE(ci->i_prealloc_cap_flush);
1706 swap(ci->i_prealloc_cap_flush, *pcf);
1707
Yan, Zheng604d1b02015-05-01 17:49:16 +08001708 if (!ci->i_head_snapc) {
1709 WARN_ON_ONCE(!rwsem_is_locked(&mdsc->snap_rwsem));
Sage Weil7d8cb262010-08-24 08:44:16 -07001710 ci->i_head_snapc = ceph_get_snap_context(
1711 ci->i_snap_realm->cached_context);
Yan, Zheng604d1b02015-05-01 17:49:16 +08001712 }
Yan, Zheng06852352012-11-19 10:49:07 +08001713 dout(" inode %p now dirty snapc %p auth cap %p\n",
1714 &ci->vfs_inode, ci->i_head_snapc, ci->i_auth_cap);
Sage Weil76e3b392009-10-15 18:13:53 -07001715 BUG_ON(!list_empty(&ci->i_dirty_item));
1716 spin_lock(&mdsc->cap_dirty_lock);
Jeff Layton1cf03a62020-04-01 17:07:52 -04001717 list_add(&ci->i_dirty_item, &session->s_cap_dirty);
Sage Weil76e3b392009-10-15 18:13:53 -07001718 spin_unlock(&mdsc->cap_dirty_lock);
1719 if (ci->i_flushing_caps == 0) {
Sage Weil3772d262011-05-03 09:28:08 -07001720 ihold(inode);
Sage Weil76e3b392009-10-15 18:13:53 -07001721 dirty |= I_DIRTY_SYNC;
1722 }
Yan, Zhengf66fd9f2015-06-10 17:26:13 +08001723 } else {
1724 WARN_ON_ONCE(!ci->i_prealloc_cap_flush);
Sage Weil76e3b392009-10-15 18:13:53 -07001725 }
1726 BUG_ON(list_empty(&ci->i_dirty_item));
1727 if (((was | ci->i_flushing_caps) & CEPH_CAP_FILE_BUFFER) &&
1728 (mask & CEPH_CAP_FILE_BUFFER))
1729 dirty |= I_DIRTY_DATASYNC;
Yan, Zhenga0d93e32020-03-05 20:21:01 +08001730 __cap_delay_requeue(mdsc, ci);
Sage Weilfca65b42011-05-04 11:33:47 -07001731 return dirty;
Sage Weil76e3b392009-10-15 18:13:53 -07001732}
1733
Yan, Zhengf66fd9f2015-06-10 17:26:13 +08001734struct ceph_cap_flush *ceph_alloc_cap_flush(void)
1735{
Xiubo Lib2f9fa12021-08-18 21:38:42 +08001736 struct ceph_cap_flush *cf;
1737
1738 cf = kmem_cache_alloc(ceph_cap_flush_cachep, GFP_KERNEL);
Colin Ian King05a444d2021-08-29 19:18:24 +01001739 if (!cf)
1740 return NULL;
1741
Xiubo Lib2f9fa12021-08-18 21:38:42 +08001742 cf->is_capsnap = false;
1743 return cf;
Yan, Zhengf66fd9f2015-06-10 17:26:13 +08001744}
1745
1746void ceph_free_cap_flush(struct ceph_cap_flush *cf)
1747{
1748 if (cf)
1749 kmem_cache_free(ceph_cap_flush_cachep, cf);
1750}
1751
Yan, Zhenga2971c82015-06-10 11:09:32 +08001752static u64 __get_oldest_flush_tid(struct ceph_mds_client *mdsc)
1753{
Yan, Zhenge4500b52016-07-06 11:12:56 +08001754 if (!list_empty(&mdsc->cap_flush_list)) {
Yan, Zhenga2971c82015-06-10 11:09:32 +08001755 struct ceph_cap_flush *cf =
Yan, Zhenge4500b52016-07-06 11:12:56 +08001756 list_first_entry(&mdsc->cap_flush_list,
1757 struct ceph_cap_flush, g_list);
Yan, Zhenga2971c82015-06-10 11:09:32 +08001758 return cf->tid;
1759 }
1760 return 0;
1761}
1762
Sage Weil76e3b392009-10-15 18:13:53 -07001763/*
Yan, Zhengc8799fc2016-07-07 15:22:38 +08001764 * Remove cap_flush from the mdsc's or inode's flushing cap list.
1765 * Return true if caller needs to wake up flush waiters.
1766 */
Jeff Layton681ac632020-03-18 15:29:34 -04001767static bool __detach_cap_flush_from_mdsc(struct ceph_mds_client *mdsc,
1768 struct ceph_cap_flush *cf)
Yan, Zhengc8799fc2016-07-07 15:22:38 +08001769{
1770 struct ceph_cap_flush *prev;
1771 bool wake = cf->wake;
Jeff Layton681ac632020-03-18 15:29:34 -04001772
1773 if (wake && cf->g_list.prev != &mdsc->cap_flush_list) {
1774 prev = list_prev_entry(cf, g_list);
1775 prev->wake = true;
1776 wake = false;
Yan, Zhengc8799fc2016-07-07 15:22:38 +08001777 }
Xiubo Lib2f9fa12021-08-18 21:38:42 +08001778 list_del_init(&cf->g_list);
Jeff Layton681ac632020-03-18 15:29:34 -04001779 return wake;
1780}
1781
1782static bool __detach_cap_flush_from_ci(struct ceph_inode_info *ci,
1783 struct ceph_cap_flush *cf)
1784{
1785 struct ceph_cap_flush *prev;
1786 bool wake = cf->wake;
1787
1788 if (wake && cf->i_list.prev != &ci->i_cap_flush_list) {
1789 prev = list_prev_entry(cf, i_list);
1790 prev->wake = true;
1791 wake = false;
1792 }
Xiubo Lib2f9fa12021-08-18 21:38:42 +08001793 list_del_init(&cf->i_list);
Yan, Zhengc8799fc2016-07-07 15:22:38 +08001794 return wake;
1795}
1796
1797/*
Sage Weila8599bd2009-10-06 11:31:12 -07001798 * Add dirty inode to the flushing list. Assigned a seq number so we
1799 * can wait for caps to flush without starving.
Sage Weilcdc35f92009-10-14 14:24:19 -07001800 *
Jeff Layton9f3345d2019-07-08 12:27:57 -04001801 * Called under i_ceph_lock. Returns the flush tid.
Sage Weila8599bd2009-10-06 11:31:12 -07001802 */
Jeff Layton9f3345d2019-07-08 12:27:57 -04001803static u64 __mark_caps_flushing(struct inode *inode,
Yan, Zhengc8799fc2016-07-07 15:22:38 +08001804 struct ceph_mds_session *session, bool wake,
Jeff Layton9f3345d2019-07-08 12:27:57 -04001805 u64 *oldest_flush_tid)
Sage Weila8599bd2009-10-06 11:31:12 -07001806{
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -07001807 struct ceph_mds_client *mdsc = ceph_sb_to_client(inode->i_sb)->mdsc;
Sage Weila8599bd2009-10-06 11:31:12 -07001808 struct ceph_inode_info *ci = ceph_inode(inode);
Yan, Zhengf66fd9f2015-06-10 17:26:13 +08001809 struct ceph_cap_flush *cf = NULL;
Sage Weilcdc35f92009-10-14 14:24:19 -07001810 int flushing;
Sage Weil50b885b2009-12-01 14:12:07 -08001811
Jeff Laytonc7e4f852020-02-25 11:08:33 -08001812 lockdep_assert_held(&ci->i_ceph_lock);
Sage Weilcdc35f92009-10-14 14:24:19 -07001813 BUG_ON(ci->i_dirty_caps == 0);
Sage Weila8599bd2009-10-06 11:31:12 -07001814 BUG_ON(list_empty(&ci->i_dirty_item));
Yan, Zhengf66fd9f2015-06-10 17:26:13 +08001815 BUG_ON(!ci->i_prealloc_cap_flush);
Sage Weilcdc35f92009-10-14 14:24:19 -07001816
1817 flushing = ci->i_dirty_caps;
1818 dout("__mark_caps_flushing flushing %s, flushing_caps %s -> %s\n",
1819 ceph_cap_string(flushing),
1820 ceph_cap_string(ci->i_flushing_caps),
1821 ceph_cap_string(ci->i_flushing_caps | flushing));
1822 ci->i_flushing_caps |= flushing;
1823 ci->i_dirty_caps = 0;
Sage Weilafcdaea2009-10-14 14:27:38 -07001824 dout(" inode %p now !dirty\n", inode);
Sage Weilcdc35f92009-10-14 14:24:19 -07001825
Yan, Zhengf66fd9f2015-06-10 17:26:13 +08001826 swap(cf, ci->i_prealloc_cap_flush);
Yan, Zheng553adfd2015-06-09 15:48:57 +08001827 cf->caps = flushing;
Yan, Zhengc8799fc2016-07-07 15:22:38 +08001828 cf->wake = wake;
Yan, Zheng553adfd2015-06-09 15:48:57 +08001829
Sage Weila8599bd2009-10-06 11:31:12 -07001830 spin_lock(&mdsc->cap_dirty_lock);
Sage Weilafcdaea2009-10-14 14:27:38 -07001831 list_del_init(&ci->i_dirty_item);
1832
Yan, Zheng553adfd2015-06-09 15:48:57 +08001833 cf->tid = ++mdsc->last_cap_flush_tid;
Yan, Zhenge4500b52016-07-06 11:12:56 +08001834 list_add_tail(&cf->g_list, &mdsc->cap_flush_list);
Yan, Zhenga2971c82015-06-10 11:09:32 +08001835 *oldest_flush_tid = __get_oldest_flush_tid(mdsc);
Yan, Zheng553adfd2015-06-09 15:48:57 +08001836
Sage Weila8599bd2009-10-06 11:31:12 -07001837 if (list_empty(&ci->i_flushing_item)) {
1838 list_add_tail(&ci->i_flushing_item, &session->s_cap_flushing);
1839 mdsc->num_cap_flushing++;
Sage Weila8599bd2009-10-06 11:31:12 -07001840 }
1841 spin_unlock(&mdsc->cap_dirty_lock);
Sage Weilcdc35f92009-10-14 14:24:19 -07001842
Yan, Zhenge4500b52016-07-06 11:12:56 +08001843 list_add_tail(&cf->i_list, &ci->i_cap_flush_list);
Yan, Zheng553adfd2015-06-09 15:48:57 +08001844
Jeff Layton9f3345d2019-07-08 12:27:57 -04001845 return cf->tid;
Sage Weila8599bd2009-10-06 11:31:12 -07001846}
1847
1848/*
Sage Weil5ecad6f2010-02-17 10:43:37 -08001849 * try to invalidate mapping pages without blocking.
1850 */
Sage Weil5ecad6f2010-02-17 10:43:37 -08001851static int try_nonblocking_invalidate(struct inode *inode)
Jeff Layton3eaf5aa2021-09-02 08:31:03 -04001852 __releases(ci->i_ceph_lock)
1853 __acquires(ci->i_ceph_lock)
Sage Weil5ecad6f2010-02-17 10:43:37 -08001854{
1855 struct ceph_inode_info *ci = ceph_inode(inode);
1856 u32 invalidating_gen = ci->i_rdcache_gen;
1857
Sage Weilbe655592011-11-30 09:47:09 -08001858 spin_unlock(&ci->i_ceph_lock);
Jeff Layton10a70522021-01-21 18:05:37 -05001859 ceph_fscache_invalidate(inode);
Sage Weil5ecad6f2010-02-17 10:43:37 -08001860 invalidate_mapping_pages(&inode->i_data, 0, -1);
Sage Weilbe655592011-11-30 09:47:09 -08001861 spin_lock(&ci->i_ceph_lock);
Sage Weil5ecad6f2010-02-17 10:43:37 -08001862
Sage Weil18a38192010-09-17 10:46:44 -07001863 if (inode->i_data.nrpages == 0 &&
Sage Weil5ecad6f2010-02-17 10:43:37 -08001864 invalidating_gen == ci->i_rdcache_gen) {
1865 /* success. */
1866 dout("try_nonblocking_invalidate %p success\n", inode);
Sage Weilcd045cb2010-11-04 11:05:05 -07001867 /* save any racing async invalidate some trouble */
1868 ci->i_rdcache_revoking = ci->i_rdcache_gen - 1;
Sage Weil5ecad6f2010-02-17 10:43:37 -08001869 return 0;
1870 }
1871 dout("try_nonblocking_invalidate %p failed\n", inode);
1872 return -1;
1873}
1874
Yan, Zhengefb0ca72017-05-22 12:03:32 +08001875bool __ceph_should_report_size(struct ceph_inode_info *ci)
1876{
Jeff Layton2d6795f2021-04-09 15:58:35 -04001877 loff_t size = i_size_read(&ci->vfs_inode);
Yan, Zhengefb0ca72017-05-22 12:03:32 +08001878 /* mds will adjust max size according to the reported size */
1879 if (ci->i_flushing_caps & CEPH_CAP_FILE_WR)
1880 return false;
1881 if (size >= ci->i_max_size)
1882 return true;
1883 /* half of previous max_size increment has been used */
1884 if (ci->i_max_size > ci->i_reported_size &&
1885 (size << 1) >= ci->i_max_size + ci->i_reported_size)
1886 return true;
1887 return false;
1888}
1889
Sage Weil5ecad6f2010-02-17 10:43:37 -08001890/*
Sage Weila8599bd2009-10-06 11:31:12 -07001891 * Swiss army knife function to examine currently used and wanted
1892 * versus held caps. Release, flush, ack revoked caps to mds as
1893 * appropriate.
1894 *
Sage Weila8599bd2009-10-06 11:31:12 -07001895 * CHECK_CAPS_AUTHONLY - we should only check the auth cap
1896 * CHECK_CAPS_FLUSH - we should flush any dirty caps immediately, without
1897 * further delay.
1898 */
1899void ceph_check_caps(struct ceph_inode_info *ci, int flags,
1900 struct ceph_mds_session *session)
1901{
Sage Weila8599bd2009-10-06 11:31:12 -07001902 struct inode *inode = &ci->vfs_inode;
Xiubo Li2678da82020-09-03 09:01:39 -04001903 struct ceph_mds_client *mdsc = ceph_sb_to_mdsc(inode->i_sb);
Sage Weila8599bd2009-10-06 11:31:12 -07001904 struct ceph_cap *cap;
Yan, Zhenga2971c82015-06-10 11:09:32 +08001905 u64 flush_tid, oldest_flush_tid;
Yan, Zheng395c3122013-01-04 14:37:57 +08001906 int file_wanted, used, cap_used;
Sage Weilcbd03632010-02-09 13:41:18 -08001907 int issued, implemented, want, retain, revoking, flushing = 0;
Sage Weila8599bd2009-10-06 11:31:12 -07001908 int mds = -1; /* keep track of how far we've gone through i_caps list
1909 to avoid an infinite loop on retry */
1910 struct rb_node *p;
Yan, Zheng36094042016-07-06 15:37:42 +08001911 bool queue_invalidate = false;
Yan, Zheng36094042016-07-06 15:37:42 +08001912 bool tried_invalidate = false;
Sage Weila8599bd2009-10-06 11:31:12 -07001913
Jeff Layton6a92b082021-06-04 11:01:25 -04001914 if (session)
1915 ceph_get_mds_session(session);
1916
Sage Weilbe655592011-11-30 09:47:09 -08001917 spin_lock(&ci->i_ceph_lock);
Sage Weila8599bd2009-10-06 11:31:12 -07001918 if (ci->i_ceph_flags & CEPH_I_FLUSH)
1919 flags |= CHECK_CAPS_FLUSH;
Sage Weila8599bd2009-10-06 11:31:12 -07001920retry:
Jeff Laytonc74d79a2020-10-06 12:24:19 -04001921 /* Caps wanted by virtue of active open files. */
Sage Weila8599bd2009-10-06 11:31:12 -07001922 file_wanted = __ceph_caps_file_wanted(ci);
Jeff Laytonc74d79a2020-10-06 12:24:19 -04001923
1924 /* Caps which have active references against them */
Sage Weila8599bd2009-10-06 11:31:12 -07001925 used = __ceph_caps_used(ci);
Jeff Laytonc74d79a2020-10-06 12:24:19 -04001926
1927 /*
1928 * "issued" represents the current caps that the MDS wants us to have.
1929 * "implemented" is the set that we have been granted, and includes the
1930 * ones that have not yet been returned to the MDS (the "revoking" set,
1931 * usually because they have outstanding references).
1932 */
Sage Weilcbd03632010-02-09 13:41:18 -08001933 issued = __ceph_caps_issued(ci, &implemented);
1934 revoking = implemented & ~issued;
Sage Weila8599bd2009-10-06 11:31:12 -07001935
Yan, Zheng41445992015-05-25 17:36:42 +08001936 want = file_wanted;
Jeff Laytonc74d79a2020-10-06 12:24:19 -04001937
1938 /* The ones we currently want to retain (may be adjusted below) */
Yan, Zheng41445992015-05-25 17:36:42 +08001939 retain = file_wanted | used | CEPH_CAP_PIN;
Sage Weila8599bd2009-10-06 11:31:12 -07001940 if (!mdsc->stopping && inode->i_nlink > 0) {
Yan, Zheng41445992015-05-25 17:36:42 +08001941 if (file_wanted) {
Sage Weila8599bd2009-10-06 11:31:12 -07001942 retain |= CEPH_CAP_ANY; /* be greedy */
Yan, Zheng32ec4392015-03-26 19:06:00 +08001943 } else if (S_ISDIR(inode->i_mode) &&
1944 (issued & CEPH_CAP_FILE_SHARED) &&
Yan, Zheng8a2ac3a2018-12-05 11:29:35 +08001945 __ceph_dir_is_complete(ci)) {
Yan, Zheng32ec4392015-03-26 19:06:00 +08001946 /*
1947 * If a directory is complete, we want to keep
1948 * the exclusive cap. So that MDS does not end up
1949 * revoking the shared cap on every create/unlink
1950 * operation.
1951 */
Jeff Laytona25949b2020-02-18 14:12:45 -05001952 if (IS_RDONLY(inode)) {
Yan, Zheng8a2ac3a2018-12-05 11:29:35 +08001953 want = CEPH_CAP_ANY_SHARED;
Jeff Laytona25949b2020-02-18 14:12:45 -05001954 } else {
Yan, Zheng719a2512020-03-05 20:21:00 +08001955 want |= CEPH_CAP_ANY_SHARED | CEPH_CAP_FILE_EXCL;
Jeff Laytona25949b2020-02-18 14:12:45 -05001956 }
Yan, Zheng32ec4392015-03-26 19:06:00 +08001957 retain |= want;
Sage Weila8599bd2009-10-06 11:31:12 -07001958 } else {
Yan, Zheng32ec4392015-03-26 19:06:00 +08001959
Sage Weila8599bd2009-10-06 11:31:12 -07001960 retain |= CEPH_CAP_ANY_SHARED;
1961 /*
1962 * keep RD only if we didn't have the file open RW,
1963 * because then the mds would revoke it anyway to
1964 * journal max_size=0.
1965 */
1966 if (ci->i_max_size == 0)
1967 retain |= CEPH_CAP_ANY_RD;
1968 }
1969 }
1970
Jeff Layton6407fbb2021-09-02 09:12:35 -04001971 dout("check_caps %llx.%llx file_want %s used %s dirty %s flushing %s"
1972 " issued %s revoking %s retain %s %s%s\n", ceph_vinop(inode),
Sage Weila8599bd2009-10-06 11:31:12 -07001973 ceph_cap_string(file_wanted),
1974 ceph_cap_string(used), ceph_cap_string(ci->i_dirty_caps),
1975 ceph_cap_string(ci->i_flushing_caps),
Sage Weilcbd03632010-02-09 13:41:18 -08001976 ceph_cap_string(issued), ceph_cap_string(revoking),
Sage Weila8599bd2009-10-06 11:31:12 -07001977 ceph_cap_string(retain),
1978 (flags & CHECK_CAPS_AUTHONLY) ? " AUTHONLY" : "",
Sage Weila8599bd2009-10-06 11:31:12 -07001979 (flags & CHECK_CAPS_FLUSH) ? " FLUSH" : "");
1980
1981 /*
1982 * If we no longer need to hold onto old our caps, and we may
1983 * have cached pages, but don't want them, then try to invalidate.
1984 * If we fail, it's because pages are locked.... try again later.
1985 */
Yan, Zhenga0d93e32020-03-05 20:21:01 +08001986 if ((!(flags & CHECK_CAPS_NOINVAL) || mdsc->stopping) &&
Yan, Zheng525d15e2019-05-11 17:27:59 +08001987 S_ISREG(inode->i_mode) &&
Yan, Zheng9abd4db2016-05-18 20:58:26 +08001988 !(ci->i_wb_ref || ci->i_wrbuffer_ref) && /* no dirty pages... */
Yan, Zhengfdd4e152015-06-16 20:48:56 +08001989 inode->i_data.nrpages && /* have cached pages */
Yan, Zheng5e804ac2015-10-26 16:08:43 +08001990 (revoking & (CEPH_CAP_FILE_CACHE|
1991 CEPH_CAP_FILE_LAZYIO)) && /* or revoking cache */
Sage Weila8599bd2009-10-06 11:31:12 -07001992 !tried_invalidate) {
Jeff Layton6407fbb2021-09-02 09:12:35 -04001993 dout("check_caps trying to invalidate on %llx.%llx\n",
1994 ceph_vinop(inode));
Sage Weil5ecad6f2010-02-17 10:43:37 -08001995 if (try_nonblocking_invalidate(inode) < 0) {
Yan, Zhengee612d92018-01-08 14:36:25 +08001996 dout("check_caps queuing invalidate\n");
1997 queue_invalidate = true;
1998 ci->i_rdcache_revoking = ci->i_rdcache_gen;
Sage Weila8599bd2009-10-06 11:31:12 -07001999 }
Yan, Zheng36094042016-07-06 15:37:42 +08002000 tried_invalidate = true;
Jeff Layton6a92b082021-06-04 11:01:25 -04002001 goto retry;
Sage Weila8599bd2009-10-06 11:31:12 -07002002 }
2003
Sage Weila8599bd2009-10-06 11:31:12 -07002004 for (p = rb_first(&ci->i_caps); p; p = rb_next(p)) {
Jeff Laytond67c72e2020-04-01 18:27:25 -04002005 int mflags = 0;
Jeff Layton0a454bd2020-03-17 08:47:31 -04002006 struct cap_msg_args arg;
2007
Sage Weila8599bd2009-10-06 11:31:12 -07002008 cap = rb_entry(p, struct ceph_cap, ci_node);
Sage Weila8599bd2009-10-06 11:31:12 -07002009
2010 /* avoid looping forever */
2011 if (mds >= cap->mds ||
2012 ((flags & CHECK_CAPS_AUTHONLY) && cap != ci->i_auth_cap))
2013 continue;
2014
Jeff Laytonc74d79a2020-10-06 12:24:19 -04002015 /*
2016 * If we have an auth cap, we don't need to consider any
2017 * overlapping caps as used.
2018 */
Yan, Zheng395c3122013-01-04 14:37:57 +08002019 cap_used = used;
2020 if (ci->i_auth_cap && cap != ci->i_auth_cap)
2021 cap_used &= ~ci->i_auth_cap->issued;
2022
Sage Weila8599bd2009-10-06 11:31:12 -07002023 revoking = cap->implemented & ~cap->issued;
Yan, Zheng395c3122013-01-04 14:37:57 +08002024 dout(" mds%d cap %p used %s issued %s implemented %s revoking %s\n",
Yan, Zheng9abd4db2016-05-18 20:58:26 +08002025 cap->mds, cap, ceph_cap_string(cap_used),
2026 ceph_cap_string(cap->issued),
Sage Weil088b3f52011-01-18 08:56:01 -08002027 ceph_cap_string(cap->implemented),
2028 ceph_cap_string(revoking));
Sage Weila8599bd2009-10-06 11:31:12 -07002029
2030 if (cap == ci->i_auth_cap &&
2031 (cap->issued & CEPH_CAP_FILE_WR)) {
2032 /* request larger max_size from MDS? */
2033 if (ci->i_wanted_max_size > ci->i_max_size &&
2034 ci->i_wanted_max_size > ci->i_requested_max_size) {
2035 dout("requesting new max_size\n");
2036 goto ack;
2037 }
2038
2039 /* approaching file_max? */
Yan, Zhengefb0ca72017-05-22 12:03:32 +08002040 if (__ceph_should_report_size(ci)) {
Sage Weila8599bd2009-10-06 11:31:12 -07002041 dout("i_size approaching max_size\n");
2042 goto ack;
2043 }
2044 }
2045 /* flush anything dirty? */
Yan, Zheng7bc00fd2016-07-07 18:34:45 +08002046 if (cap == ci->i_auth_cap) {
2047 if ((flags & CHECK_CAPS_FLUSH) && ci->i_dirty_caps) {
2048 dout("flushing dirty caps\n");
2049 goto ack;
2050 }
2051 if (ci->i_ceph_flags & CEPH_I_FLUSH_SNAPS) {
2052 dout("flushing snap caps\n");
2053 goto ack;
2054 }
Sage Weila8599bd2009-10-06 11:31:12 -07002055 }
2056
2057 /* completed revocation? going down and there are no caps? */
Yan, Zheng395c3122013-01-04 14:37:57 +08002058 if (revoking && (revoking & cap_used) == 0) {
Sage Weila8599bd2009-10-06 11:31:12 -07002059 dout("completed revocation of %s\n",
2060 ceph_cap_string(cap->implemented & ~cap->issued));
2061 goto ack;
2062 }
2063
2064 /* want more caps from mds? */
Yan, Zheng0aa971b2020-03-10 19:34:20 +08002065 if (want & ~cap->mds_wanted) {
2066 if (want & ~(cap->mds_wanted | cap->issued))
2067 goto ack;
2068 if (!__cap_is_valid(cap))
2069 goto ack;
2070 }
Sage Weila8599bd2009-10-06 11:31:12 -07002071
2072 /* things we might delay */
Yan, Zhengfdac94f2018-11-22 15:26:01 +08002073 if ((cap->issued & ~retain) == 0)
Sage Weila8599bd2009-10-06 11:31:12 -07002074 continue; /* nope, all good */
2075
Sage Weila8599bd2009-10-06 11:31:12 -07002076ack:
Jeff Layton6a92b082021-06-04 11:01:25 -04002077 ceph_put_mds_session(session);
2078 session = ceph_get_mds_session(cap->session);
Yan, Zheng7bc00fd2016-07-07 18:34:45 +08002079
2080 /* kick flushing and flush snaps before sending normal
2081 * cap message */
2082 if (cap == ci->i_auth_cap &&
2083 (ci->i_ceph_flags &
2084 (CEPH_I_KICK_FLUSH | CEPH_I_FLUSH_SNAPS))) {
Yan, Zheng054f8d42019-06-20 16:00:31 +08002085 if (ci->i_ceph_flags & CEPH_I_KICK_FLUSH)
Yan, Zheng24d063a2017-08-15 11:37:32 +08002086 __kick_flushing_caps(mdsc, session, ci, 0);
Yan, Zhenged9b4302016-07-05 21:08:07 +08002087 if (ci->i_ceph_flags & CEPH_I_FLUSH_SNAPS)
2088 __ceph_flush_snaps(ci, session);
2089
Jeff Layton6a92b082021-06-04 11:01:25 -04002090 goto retry;
Sage Weila8599bd2009-10-06 11:31:12 -07002091 }
2092
Yan, Zheng553adfd2015-06-09 15:48:57 +08002093 if (cap == ci->i_auth_cap && ci->i_dirty_caps) {
Jeff Layton9f3345d2019-07-08 12:27:57 -04002094 flushing = ci->i_dirty_caps;
2095 flush_tid = __mark_caps_flushing(inode, session, false,
2096 &oldest_flush_tid);
Jeff Laytond67c72e2020-04-01 18:27:25 -04002097 if (flags & CHECK_CAPS_FLUSH &&
2098 list_empty(&session->s_cap_dirty))
2099 mflags |= CEPH_CLIENT_CAPS_SYNC;
Yan, Zheng553adfd2015-06-09 15:48:57 +08002100 } else {
Sage Weil24be0c42011-01-18 08:48:06 -08002101 flushing = 0;
Yan, Zheng553adfd2015-06-09 15:48:57 +08002102 flush_tid = 0;
Yan, Zhenga2971c82015-06-10 11:09:32 +08002103 spin_lock(&mdsc->cap_dirty_lock);
2104 oldest_flush_tid = __get_oldest_flush_tid(mdsc);
2105 spin_unlock(&mdsc->cap_dirty_lock);
Yan, Zheng553adfd2015-06-09 15:48:57 +08002106 }
Sage Weila8599bd2009-10-06 11:31:12 -07002107
2108 mds = cap->mds; /* remember mds, so we don't repeat */
Sage Weila8599bd2009-10-06 11:31:12 -07002109
Jeff Laytond67c72e2020-04-01 18:27:25 -04002110 __prep_cap(&arg, cap, CEPH_CAP_OP_UPDATE, mflags, cap_used,
2111 want, retain, flushing, flush_tid, oldest_flush_tid);
Jeff Layton0a454bd2020-03-17 08:47:31 -04002112
Jeff Layton6a92b082021-06-04 11:01:25 -04002113 spin_unlock(&ci->i_ceph_lock);
Jeff Layton52311982020-03-30 13:07:23 -04002114 __send_cap(&arg, ci);
Jeff Layton6a92b082021-06-04 11:01:25 -04002115 spin_lock(&ci->i_ceph_lock);
Jeff Layton0a454bd2020-03-17 08:47:31 -04002116
Sage Weilbe655592011-11-30 09:47:09 -08002117 goto retry; /* retake i_ceph_lock and restart our cap scan. */
Sage Weila8599bd2009-10-06 11:31:12 -07002118 }
2119
Yan, Zhenga0d93e32020-03-05 20:21:01 +08002120 /* periodically re-calculate caps wanted by open files */
2121 if (__ceph_is_any_real_caps(ci) &&
2122 list_empty(&ci->i_cap_delay_list) &&
2123 (file_wanted & ~CEPH_CAP_PIN) &&
2124 !(used & (CEPH_CAP_FILE_RD | CEPH_CAP_ANY_FILE_WR))) {
2125 __cap_delay_requeue(mdsc, ci);
Yan, Zheng719a2512020-03-05 20:21:00 +08002126 }
Sage Weila8599bd2009-10-06 11:31:12 -07002127
Sage Weilbe655592011-11-30 09:47:09 -08002128 spin_unlock(&ci->i_ceph_lock);
Sage Weila8599bd2009-10-06 11:31:12 -07002129
Jeff Layton6a92b082021-06-04 11:01:25 -04002130 ceph_put_mds_session(session);
Sage Weilcbd03632010-02-09 13:41:18 -08002131 if (queue_invalidate)
Sage Weil3c6f6b72010-02-09 15:24:44 -08002132 ceph_queue_invalidate(inode);
Sage Weila8599bd2009-10-06 11:31:12 -07002133}
2134
2135/*
Sage Weila8599bd2009-10-06 11:31:12 -07002136 * Try to flush dirty caps back to the auth mds.
2137 */
Yan, Zheng553adfd2015-06-09 15:48:57 +08002138static int try_flush_caps(struct inode *inode, u64 *ptid)
Sage Weila8599bd2009-10-06 11:31:12 -07002139{
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -07002140 struct ceph_mds_client *mdsc = ceph_sb_to_client(inode->i_sb)->mdsc;
Sage Weila8599bd2009-10-06 11:31:12 -07002141 struct ceph_inode_info *ci = ceph_inode(inode);
Yan, Zheng89b52fe2015-05-27 09:59:48 +08002142 int flushing = 0;
Yan, Zhenga2971c82015-06-10 11:09:32 +08002143 u64 flush_tid = 0, oldest_flush_tid = 0;
Sage Weila8599bd2009-10-06 11:31:12 -07002144
Sage Weilbe655592011-11-30 09:47:09 -08002145 spin_lock(&ci->i_ceph_lock);
Yan, Zhengd6cee9d2019-06-20 16:09:37 +08002146retry_locked:
Sage Weila8599bd2009-10-06 11:31:12 -07002147 if (ci->i_dirty_caps && ci->i_auth_cap) {
2148 struct ceph_cap *cap = ci->i_auth_cap;
Jeff Layton0a454bd2020-03-17 08:47:31 -04002149 struct cap_msg_args arg;
Jeff Layton0449a352021-06-09 14:01:52 -04002150 struct ceph_mds_session *session = cap->session;
Sage Weila8599bd2009-10-06 11:31:12 -07002151
Jeff Layton0449a352021-06-09 14:01:52 -04002152 if (session->s_state < CEPH_MDS_SESSION_OPEN) {
Jeff Layton6c2838f2017-10-19 08:52:58 -04002153 spin_unlock(&ci->i_ceph_lock);
Sage Weila8599bd2009-10-06 11:31:12 -07002154 goto out;
Jeff Layton6c2838f2017-10-19 08:52:58 -04002155 }
Sage Weila8599bd2009-10-06 11:31:12 -07002156
Yan, Zhengd6cee9d2019-06-20 16:09:37 +08002157 if (ci->i_ceph_flags &
2158 (CEPH_I_KICK_FLUSH | CEPH_I_FLUSH_SNAPS)) {
2159 if (ci->i_ceph_flags & CEPH_I_KICK_FLUSH)
2160 __kick_flushing_caps(mdsc, session, ci, 0);
2161 if (ci->i_ceph_flags & CEPH_I_FLUSH_SNAPS)
2162 __ceph_flush_snaps(ci, session);
2163 goto retry_locked;
2164 }
2165
Jeff Layton9f3345d2019-07-08 12:27:57 -04002166 flushing = ci->i_dirty_caps;
2167 flush_tid = __mark_caps_flushing(inode, session, true,
2168 &oldest_flush_tid);
Sage Weila8599bd2009-10-06 11:31:12 -07002169
Jeff Layton0a454bd2020-03-17 08:47:31 -04002170 __prep_cap(&arg, cap, CEPH_CAP_OP_FLUSH, CEPH_CLIENT_CAPS_SYNC,
Yan, Zhenga0d93e32020-03-05 20:21:01 +08002171 __ceph_caps_used(ci), __ceph_caps_wanted(ci),
2172 (cap->issued | cap->implemented),
2173 flushing, flush_tid, oldest_flush_tid);
Jeff Layton0a454bd2020-03-17 08:47:31 -04002174 spin_unlock(&ci->i_ceph_lock);
2175
Jeff Layton52311982020-03-30 13:07:23 -04002176 __send_cap(&arg, ci);
Yan, Zheng553adfd2015-06-09 15:48:57 +08002177 } else {
Yan, Zhenge4500b52016-07-06 11:12:56 +08002178 if (!list_empty(&ci->i_cap_flush_list)) {
Yan, Zheng553adfd2015-06-09 15:48:57 +08002179 struct ceph_cap_flush *cf =
Yan, Zhenge4500b52016-07-06 11:12:56 +08002180 list_last_entry(&ci->i_cap_flush_list,
Yan, Zhengc8799fc2016-07-07 15:22:38 +08002181 struct ceph_cap_flush, i_list);
2182 cf->wake = true;
Yan, Zheng553adfd2015-06-09 15:48:57 +08002183 flush_tid = cf->tid;
2184 }
2185 flushing = ci->i_flushing_caps;
2186 spin_unlock(&ci->i_ceph_lock);
Sage Weila8599bd2009-10-06 11:31:12 -07002187 }
2188out:
Yan, Zheng553adfd2015-06-09 15:48:57 +08002189 *ptid = flush_tid;
Sage Weila8599bd2009-10-06 11:31:12 -07002190 return flushing;
2191}
2192
2193/*
2194 * Return true if we've flushed caps through the given flush_tid.
2195 */
Yan, Zheng553adfd2015-06-09 15:48:57 +08002196static int caps_are_flushed(struct inode *inode, u64 flush_tid)
Sage Weila8599bd2009-10-06 11:31:12 -07002197{
2198 struct ceph_inode_info *ci = ceph_inode(inode);
Yan, Zheng553adfd2015-06-09 15:48:57 +08002199 int ret = 1;
Sage Weila8599bd2009-10-06 11:31:12 -07002200
Sage Weilbe655592011-11-30 09:47:09 -08002201 spin_lock(&ci->i_ceph_lock);
Yan, Zhenge4500b52016-07-06 11:12:56 +08002202 if (!list_empty(&ci->i_cap_flush_list)) {
2203 struct ceph_cap_flush * cf =
2204 list_first_entry(&ci->i_cap_flush_list,
2205 struct ceph_cap_flush, i_list);
Yan, Zheng553adfd2015-06-09 15:48:57 +08002206 if (cf->tid <= flush_tid)
Sage Weila8599bd2009-10-06 11:31:12 -07002207 ret = 0;
Yan, Zheng89b52fe2015-05-27 09:59:48 +08002208 }
Sage Weilbe655592011-11-30 09:47:09 -08002209 spin_unlock(&ci->i_ceph_lock);
Sage Weila8599bd2009-10-06 11:31:12 -07002210 return ret;
2211}
2212
2213/*
Yan, Zheng68cd5b42015-10-27 18:36:06 +08002214 * wait for any unsafe requests to complete.
Yan, Zhengda819c82015-05-27 11:19:34 +08002215 */
Yan, Zheng68cd5b42015-10-27 18:36:06 +08002216static int unsafe_request_wait(struct inode *inode)
Yan, Zhengda819c82015-05-27 11:19:34 +08002217{
Xiubo Lie1a45412021-07-05 09:22:57 +08002218 struct ceph_mds_client *mdsc = ceph_sb_to_client(inode->i_sb)->mdsc;
Yan, Zhengda819c82015-05-27 11:19:34 +08002219 struct ceph_inode_info *ci = ceph_inode(inode);
Yan, Zheng68cd5b42015-10-27 18:36:06 +08002220 struct ceph_mds_request *req1 = NULL, *req2 = NULL;
2221 int ret, err = 0;
Yan, Zhengda819c82015-05-27 11:19:34 +08002222
2223 spin_lock(&ci->i_unsafe_lock);
Yan, Zheng68cd5b42015-10-27 18:36:06 +08002224 if (S_ISDIR(inode->i_mode) && !list_empty(&ci->i_unsafe_dirops)) {
2225 req1 = list_last_entry(&ci->i_unsafe_dirops,
2226 struct ceph_mds_request,
2227 r_unsafe_dir_item);
2228 ceph_mdsc_get_request(req1);
2229 }
2230 if (!list_empty(&ci->i_unsafe_iops)) {
2231 req2 = list_last_entry(&ci->i_unsafe_iops,
2232 struct ceph_mds_request,
2233 r_unsafe_target_item);
2234 ceph_mdsc_get_request(req2);
2235 }
Yan, Zhengda819c82015-05-27 11:19:34 +08002236 spin_unlock(&ci->i_unsafe_lock);
Yan, Zheng68cd5b42015-10-27 18:36:06 +08002237
Xiubo Lie1a45412021-07-05 09:22:57 +08002238 /*
2239 * Trigger to flush the journal logs in all the relevant MDSes
2240 * manually, or in the worst case we must wait at most 5 seconds
2241 * to wait the journal logs to be flushed by the MDSes periodically.
2242 */
2243 if (req1 || req2) {
2244 struct ceph_mds_session **sessions = NULL;
2245 struct ceph_mds_session *s;
2246 struct ceph_mds_request *req;
2247 unsigned int max;
2248 int i;
2249
2250 /*
2251 * The mdsc->max_sessions is unlikely to be changed
2252 * mostly, here we will retry it by reallocating the
2253 * sessions arrary memory to get rid of the mdsc->mutex
2254 * lock.
2255 */
2256retry:
2257 max = mdsc->max_sessions;
2258 sessions = krealloc(sessions, max * sizeof(s), __GFP_ZERO);
2259 if (!sessions)
2260 return -ENOMEM;
2261
2262 spin_lock(&ci->i_unsafe_lock);
2263 if (req1) {
2264 list_for_each_entry(req, &ci->i_unsafe_dirops,
2265 r_unsafe_dir_item) {
2266 s = req->r_session;
Dan Carpenter708c8712021-09-06 12:43:01 +03002267 if (unlikely(s->s_mds >= max)) {
Xiubo Lie1a45412021-07-05 09:22:57 +08002268 spin_unlock(&ci->i_unsafe_lock);
2269 goto retry;
2270 }
2271 if (!sessions[s->s_mds]) {
2272 s = ceph_get_mds_session(s);
2273 sessions[s->s_mds] = s;
2274 }
2275 }
2276 }
2277 if (req2) {
2278 list_for_each_entry(req, &ci->i_unsafe_iops,
2279 r_unsafe_target_item) {
2280 s = req->r_session;
Dan Carpenter708c8712021-09-06 12:43:01 +03002281 if (unlikely(s->s_mds >= max)) {
Xiubo Lie1a45412021-07-05 09:22:57 +08002282 spin_unlock(&ci->i_unsafe_lock);
2283 goto retry;
2284 }
2285 if (!sessions[s->s_mds]) {
2286 s = ceph_get_mds_session(s);
2287 sessions[s->s_mds] = s;
2288 }
2289 }
2290 }
2291 spin_unlock(&ci->i_unsafe_lock);
2292
2293 /* the auth MDS */
2294 spin_lock(&ci->i_ceph_lock);
2295 if (ci->i_auth_cap) {
2296 s = ci->i_auth_cap->session;
2297 if (!sessions[s->s_mds])
2298 sessions[s->s_mds] = ceph_get_mds_session(s);
2299 }
2300 spin_unlock(&ci->i_ceph_lock);
2301
2302 /* send flush mdlog request to MDSes */
2303 for (i = 0; i < max; i++) {
2304 s = sessions[i];
2305 if (s) {
2306 send_flush_mdlog(s);
2307 ceph_put_mds_session(s);
2308 }
2309 }
2310 kfree(sessions);
2311 }
2312
Jeff Layton4945a082016-11-16 09:45:22 -05002313 dout("unsafe_request_wait %p wait on tid %llu %llu\n",
Yan, Zheng68cd5b42015-10-27 18:36:06 +08002314 inode, req1 ? req1->r_tid : 0ULL, req2 ? req2->r_tid : 0ULL);
2315 if (req1) {
2316 ret = !wait_for_completion_timeout(&req1->r_safe_completion,
2317 ceph_timeout_jiffies(req1->r_timeout));
2318 if (ret)
2319 err = -EIO;
2320 ceph_mdsc_put_request(req1);
2321 }
2322 if (req2) {
2323 ret = !wait_for_completion_timeout(&req2->r_safe_completion,
2324 ceph_timeout_jiffies(req2->r_timeout));
2325 if (ret)
2326 err = -EIO;
2327 ceph_mdsc_put_request(req2);
2328 }
2329 return err;
Yan, Zhengda819c82015-05-27 11:19:34 +08002330}
2331
Josef Bacik02c24a82011-07-16 20:44:56 -04002332int ceph_fsync(struct file *file, loff_t start, loff_t end, int datasync)
Sage Weila8599bd2009-10-06 11:31:12 -07002333{
Christoph Hellwig7ea80852010-05-26 17:53:25 +02002334 struct inode *inode = file->f_mapping->host;
Sage Weila8599bd2009-10-06 11:31:12 -07002335 struct ceph_inode_info *ci = ceph_inode(inode);
Yan, Zheng553adfd2015-06-09 15:48:57 +08002336 u64 flush_tid;
Yan, Zhengf4b97862019-07-25 20:16:42 +08002337 int ret, err;
Sage Weila8599bd2009-10-06 11:31:12 -07002338 int dirty;
2339
2340 dout("fsync %p%s\n", inode, datasync ? " datasync" : "");
Yan, Zheng9a5530c2016-06-15 16:29:18 +08002341
Jeff Laytonb74fcea2017-07-25 10:50:41 -04002342 ret = file_write_and_wait_range(file, start, end);
Yan, Zhengda819c82015-05-27 11:19:34 +08002343 if (datasync)
2344 goto out;
2345
Jeff Layton891f3f52020-01-14 15:06:40 -05002346 ret = ceph_wait_on_async_create(inode);
2347 if (ret)
2348 goto out;
2349
Yan, Zheng553adfd2015-06-09 15:48:57 +08002350 dirty = try_flush_caps(inode, &flush_tid);
Sage Weila8599bd2009-10-06 11:31:12 -07002351 dout("fsync dirty caps are %s\n", ceph_cap_string(dirty));
2352
Yan, Zhengf4b97862019-07-25 20:16:42 +08002353 err = unsafe_request_wait(inode);
Yan, Zhengda819c82015-05-27 11:19:34 +08002354
Sage Weila8599bd2009-10-06 11:31:12 -07002355 /*
2356 * only wait on non-file metadata writeback (the mds
2357 * can recover size and mtime, so we don't need to
2358 * wait for that)
2359 */
Yan, Zhengf4b97862019-07-25 20:16:42 +08002360 if (!err && (dirty & ~CEPH_CAP_ANY_FILE_WR)) {
2361 err = wait_event_interruptible(ci->i_cap_wq,
Yan, Zhengda819c82015-05-27 11:19:34 +08002362 caps_are_flushed(inode, flush_tid));
Sage Weila8599bd2009-10-06 11:31:12 -07002363 }
Yan, Zhengf4b97862019-07-25 20:16:42 +08002364
2365 if (err < 0)
2366 ret = err;
2367
Jeff Layton1bd85aa2021-10-07 14:19:49 -04002368 err = file_check_and_advance_wb_err(file);
2369 if (err < 0)
2370 ret = err;
Yan, Zhengda819c82015-05-27 11:19:34 +08002371out:
2372 dout("fsync %p%s result=%d\n", inode, datasync ? " datasync" : "", ret);
Sage Weila8599bd2009-10-06 11:31:12 -07002373 return ret;
2374}
2375
2376/*
2377 * Flush any dirty caps back to the mds. If we aren't asked to wait,
2378 * queue inode for flush but don't do so immediately, because we can
2379 * get by with fewer MDS messages if we wait for data writeback to
2380 * complete first.
2381 */
Stephen Rothwellf1a3d572010-01-18 11:53:08 +11002382int ceph_write_inode(struct inode *inode, struct writeback_control *wbc)
Sage Weila8599bd2009-10-06 11:31:12 -07002383{
2384 struct ceph_inode_info *ci = ceph_inode(inode);
Yan, Zheng553adfd2015-06-09 15:48:57 +08002385 u64 flush_tid;
Sage Weila8599bd2009-10-06 11:31:12 -07002386 int err = 0;
2387 int dirty;
Chengguang Xu16515a62018-01-30 10:02:30 +08002388 int wait = (wbc->sync_mode == WB_SYNC_ALL && !wbc->for_sync);
Sage Weila8599bd2009-10-06 11:31:12 -07002389
2390 dout("write_inode %p wait=%d\n", inode, wait);
2391 if (wait) {
Yan, Zheng553adfd2015-06-09 15:48:57 +08002392 dirty = try_flush_caps(inode, &flush_tid);
Sage Weila8599bd2009-10-06 11:31:12 -07002393 if (dirty)
2394 err = wait_event_interruptible(ci->i_cap_wq,
2395 caps_are_flushed(inode, flush_tid));
2396 } else {
Cheng Renquan640ef792010-03-26 17:40:33 +08002397 struct ceph_mds_client *mdsc =
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -07002398 ceph_sb_to_client(inode->i_sb)->mdsc;
Sage Weila8599bd2009-10-06 11:31:12 -07002399
Sage Weilbe655592011-11-30 09:47:09 -08002400 spin_lock(&ci->i_ceph_lock);
Sage Weila8599bd2009-10-06 11:31:12 -07002401 if (__ceph_caps_dirty(ci))
2402 __cap_delay_requeue_front(mdsc, ci);
Sage Weilbe655592011-11-30 09:47:09 -08002403 spin_unlock(&ci->i_ceph_lock);
Sage Weila8599bd2009-10-06 11:31:12 -07002404 }
2405 return err;
2406}
2407
Yan, Zheng0e294382016-07-04 18:06:41 +08002408static void __kick_flushing_caps(struct ceph_mds_client *mdsc,
2409 struct ceph_mds_session *session,
2410 struct ceph_inode_info *ci,
2411 u64 oldest_flush_tid)
2412 __releases(ci->i_ceph_lock)
2413 __acquires(ci->i_ceph_lock)
Yan, Zheng553adfd2015-06-09 15:48:57 +08002414{
2415 struct inode *inode = &ci->vfs_inode;
2416 struct ceph_cap *cap;
2417 struct ceph_cap_flush *cf;
Yan, Zheng0e294382016-07-04 18:06:41 +08002418 int ret;
Yan, Zheng553adfd2015-06-09 15:48:57 +08002419 u64 first_tid = 0;
Yan, Zheng49ada6e2019-06-20 12:09:08 +08002420 u64 last_snap_flush = 0;
Yan, Zhenga2971c82015-06-10 11:09:32 +08002421
Yan, Zheng054f8d42019-06-20 16:00:31 +08002422 ci->i_ceph_flags &= ~CEPH_I_KICK_FLUSH;
2423
Yan, Zheng49ada6e2019-06-20 12:09:08 +08002424 list_for_each_entry_reverse(cf, &ci->i_cap_flush_list, i_list) {
Xiubo Lib2f9fa12021-08-18 21:38:42 +08002425 if (cf->is_capsnap) {
Yan, Zheng49ada6e2019-06-20 12:09:08 +08002426 last_snap_flush = cf->tid;
2427 break;
2428 }
2429 }
2430
Yan, Zhenge4500b52016-07-06 11:12:56 +08002431 list_for_each_entry(cf, &ci->i_cap_flush_list, i_list) {
2432 if (cf->tid < first_tid)
2433 continue;
2434
Yan, Zheng553adfd2015-06-09 15:48:57 +08002435 cap = ci->i_auth_cap;
2436 if (!(cap && cap->session == session)) {
Yan, Zheng0e294382016-07-04 18:06:41 +08002437 pr_err("%p auth cap %p not mds%d ???\n",
2438 inode, cap, session->s_mds);
Yan, Zheng553adfd2015-06-09 15:48:57 +08002439 break;
2440 }
2441
Yan, Zheng553adfd2015-06-09 15:48:57 +08002442 first_tid = cf->tid + 1;
2443
Xiubo Lib2f9fa12021-08-18 21:38:42 +08002444 if (!cf->is_capsnap) {
Jeff Layton0a454bd2020-03-17 08:47:31 -04002445 struct cap_msg_args arg;
2446
Yan, Zheng0e294382016-07-04 18:06:41 +08002447 dout("kick_flushing_caps %p cap %p tid %llu %s\n",
2448 inode, cap, cf->tid, ceph_cap_string(cf->caps));
Jeff Layton0a454bd2020-03-17 08:47:31 -04002449 __prep_cap(&arg, cap, CEPH_CAP_OP_FLUSH,
Yan, Zheng49ada6e2019-06-20 12:09:08 +08002450 (cf->tid < last_snap_flush ?
2451 CEPH_CLIENT_CAPS_PENDING_CAPSNAP : 0),
2452 __ceph_caps_used(ci),
Yan, Zheng0e294382016-07-04 18:06:41 +08002453 __ceph_caps_wanted(ci),
Yan, Zheng49ada6e2019-06-20 12:09:08 +08002454 (cap->issued | cap->implemented),
Yan, Zheng0e294382016-07-04 18:06:41 +08002455 cf->caps, cf->tid, oldest_flush_tid);
Jeff Layton0a454bd2020-03-17 08:47:31 -04002456 spin_unlock(&ci->i_ceph_lock);
Jeff Layton52311982020-03-30 13:07:23 -04002457 __send_cap(&arg, ci);
Yan, Zheng0e294382016-07-04 18:06:41 +08002458 } else {
2459 struct ceph_cap_snap *capsnap =
2460 container_of(cf, struct ceph_cap_snap,
2461 cap_flush);
2462 dout("kick_flushing_caps %p capsnap %p tid %llu %s\n",
2463 inode, capsnap, cf->tid,
2464 ceph_cap_string(capsnap->dirty));
2465
Elena Reshetova805692d2017-03-03 11:15:07 +02002466 refcount_inc(&capsnap->nref);
Yan, Zheng0e294382016-07-04 18:06:41 +08002467 spin_unlock(&ci->i_ceph_lock);
2468
2469 ret = __send_flush_snap(inode, session, capsnap, cap->mseq,
2470 oldest_flush_tid);
2471 if (ret < 0) {
2472 pr_err("kick_flushing_caps: error sending "
2473 "cap flushsnap, ino (%llx.%llx) "
2474 "tid %llu follows %llu\n",
2475 ceph_vinop(inode), cf->tid,
2476 capsnap->follows);
2477 }
2478
2479 ceph_put_cap_snap(capsnap);
2480 }
Yan, Zhenge4500b52016-07-06 11:12:56 +08002481
2482 spin_lock(&ci->i_ceph_lock);
Yan, Zheng553adfd2015-06-09 15:48:57 +08002483 }
Yan, Zheng553adfd2015-06-09 15:48:57 +08002484}
2485
Yan, Zhenge548e9b2015-06-10 15:17:56 +08002486void ceph_early_kick_flushing_caps(struct ceph_mds_client *mdsc,
2487 struct ceph_mds_session *session)
2488{
2489 struct ceph_inode_info *ci;
2490 struct ceph_cap *cap;
Yan, Zheng0e294382016-07-04 18:06:41 +08002491 u64 oldest_flush_tid;
Yan, Zhenge548e9b2015-06-10 15:17:56 +08002492
2493 dout("early_kick_flushing_caps mds%d\n", session->s_mds);
Yan, Zheng0e294382016-07-04 18:06:41 +08002494
2495 spin_lock(&mdsc->cap_dirty_lock);
2496 oldest_flush_tid = __get_oldest_flush_tid(mdsc);
2497 spin_unlock(&mdsc->cap_dirty_lock);
2498
Yan, Zhenge548e9b2015-06-10 15:17:56 +08002499 list_for_each_entry(ci, &session->s_cap_flushing, i_flushing_item) {
2500 spin_lock(&ci->i_ceph_lock);
2501 cap = ci->i_auth_cap;
2502 if (!(cap && cap->session == session)) {
2503 pr_err("%p auth cap %p not mds%d ???\n",
2504 &ci->vfs_inode, cap, session->s_mds);
2505 spin_unlock(&ci->i_ceph_lock);
2506 continue;
2507 }
2508
2509
2510 /*
2511 * if flushing caps were revoked, we re-send the cap flush
2512 * in client reconnect stage. This guarantees MDS * processes
2513 * the cap flush message before issuing the flushing caps to
2514 * other client.
2515 */
2516 if ((cap->issued & ci->i_flushing_caps) !=
2517 ci->i_flushing_caps) {
Yan, Zheng81c5a142019-01-01 16:28:33 +08002518 /* encode_caps_cb() also will reset these sequence
2519 * numbers. make sure sequence numbers in cap flush
2520 * message match later reconnect message */
2521 cap->seq = 0;
2522 cap->issue_seq = 0;
2523 cap->mseq = 0;
Yan, Zheng0e294382016-07-04 18:06:41 +08002524 __kick_flushing_caps(mdsc, session, ci,
2525 oldest_flush_tid);
Yan, Zheng13c2b572016-07-05 16:45:21 +08002526 } else {
2527 ci->i_ceph_flags |= CEPH_I_KICK_FLUSH;
Yan, Zhenge548e9b2015-06-10 15:17:56 +08002528 }
2529
Yan, Zhenge548e9b2015-06-10 15:17:56 +08002530 spin_unlock(&ci->i_ceph_lock);
2531 }
2532}
2533
Sage Weila8599bd2009-10-06 11:31:12 -07002534void ceph_kick_flushing_caps(struct ceph_mds_client *mdsc,
2535 struct ceph_mds_session *session)
2536{
2537 struct ceph_inode_info *ci;
Yan, Zheng13c2b572016-07-05 16:45:21 +08002538 struct ceph_cap *cap;
Yan, Zheng0e294382016-07-04 18:06:41 +08002539 u64 oldest_flush_tid;
Sage Weila8599bd2009-10-06 11:31:12 -07002540
Jeff Layton829ad4d2020-04-03 13:09:07 -04002541 lockdep_assert_held(&session->s_mutex);
2542
Sage Weila8599bd2009-10-06 11:31:12 -07002543 dout("kick_flushing_caps mds%d\n", session->s_mds);
Yan, Zheng0e294382016-07-04 18:06:41 +08002544
2545 spin_lock(&mdsc->cap_dirty_lock);
2546 oldest_flush_tid = __get_oldest_flush_tid(mdsc);
2547 spin_unlock(&mdsc->cap_dirty_lock);
2548
Sage Weila8599bd2009-10-06 11:31:12 -07002549 list_for_each_entry(ci, &session->s_cap_flushing, i_flushing_item) {
Yan, Zheng0e294382016-07-04 18:06:41 +08002550 spin_lock(&ci->i_ceph_lock);
Yan, Zheng13c2b572016-07-05 16:45:21 +08002551 cap = ci->i_auth_cap;
2552 if (!(cap && cap->session == session)) {
2553 pr_err("%p auth cap %p not mds%d ???\n",
2554 &ci->vfs_inode, cap, session->s_mds);
2555 spin_unlock(&ci->i_ceph_lock);
2556 continue;
2557 }
2558 if (ci->i_ceph_flags & CEPH_I_KICK_FLUSH) {
Yan, Zheng13c2b572016-07-05 16:45:21 +08002559 __kick_flushing_caps(mdsc, session, ci,
2560 oldest_flush_tid);
2561 }
Yan, Zheng0e294382016-07-04 18:06:41 +08002562 spin_unlock(&ci->i_ceph_lock);
Sage Weila8599bd2009-10-06 11:31:12 -07002563 }
2564}
2565
Jeff Laytone8a4d262020-02-25 11:49:53 -08002566void ceph_kick_flushing_inode_caps(struct ceph_mds_session *session,
2567 struct ceph_inode_info *ci)
Sage Weil088b3f52011-01-18 08:56:01 -08002568{
Jeff Laytone8a4d262020-02-25 11:49:53 -08002569 struct ceph_mds_client *mdsc = session->s_mdsc;
2570 struct ceph_cap *cap = ci->i_auth_cap;
Sage Weil088b3f52011-01-18 08:56:01 -08002571
Jeff Laytone8a4d262020-02-25 11:49:53 -08002572 lockdep_assert_held(&ci->i_ceph_lock);
2573
2574 dout("%s %p flushing %s\n", __func__, &ci->vfs_inode,
Yan, Zheng8310b082015-06-09 17:20:12 +08002575 ceph_cap_string(ci->i_flushing_caps));
Yan, Zheng005c4692013-05-31 16:40:24 +08002576
Yan, Zheng0e294382016-07-04 18:06:41 +08002577 if (!list_empty(&ci->i_cap_flush_list)) {
2578 u64 oldest_flush_tid;
Yan, Zheng005c4692013-05-31 16:40:24 +08002579 spin_lock(&mdsc->cap_dirty_lock);
2580 list_move_tail(&ci->i_flushing_item,
2581 &cap->session->s_cap_flushing);
Yan, Zheng0e294382016-07-04 18:06:41 +08002582 oldest_flush_tid = __get_oldest_flush_tid(mdsc);
Yan, Zheng005c4692013-05-31 16:40:24 +08002583 spin_unlock(&mdsc->cap_dirty_lock);
2584
Yan, Zheng0e294382016-07-04 18:06:41 +08002585 __kick_flushing_caps(mdsc, session, ci, oldest_flush_tid);
Sage Weil088b3f52011-01-18 08:56:01 -08002586 }
2587}
2588
Sage Weila8599bd2009-10-06 11:31:12 -07002589
2590/*
2591 * Take references to capabilities we hold, so that we don't release
2592 * them to the MDS prematurely.
Sage Weila8599bd2009-10-06 11:31:12 -07002593 */
Jeff Layton40dcf752020-01-14 09:23:49 -05002594void ceph_take_cap_refs(struct ceph_inode_info *ci, int got,
Yan, Zheng5dda377c2015-04-30 14:40:54 +08002595 bool snap_rwsem_locked)
Sage Weila8599bd2009-10-06 11:31:12 -07002596{
Jeff Layton40dcf752020-01-14 09:23:49 -05002597 lockdep_assert_held(&ci->i_ceph_lock);
2598
Sage Weila8599bd2009-10-06 11:31:12 -07002599 if (got & CEPH_CAP_PIN)
2600 ci->i_pin_ref++;
2601 if (got & CEPH_CAP_FILE_RD)
2602 ci->i_rd_ref++;
2603 if (got & CEPH_CAP_FILE_CACHE)
2604 ci->i_rdcache_ref++;
Jeff Laytonf85122a2019-04-02 08:04:30 -04002605 if (got & CEPH_CAP_FILE_EXCL)
2606 ci->i_fx_ref++;
Yan, Zheng5dda377c2015-04-30 14:40:54 +08002607 if (got & CEPH_CAP_FILE_WR) {
2608 if (ci->i_wr_ref == 0 && !ci->i_head_snapc) {
2609 BUG_ON(!snap_rwsem_locked);
2610 ci->i_head_snapc = ceph_get_snap_context(
2611 ci->i_snap_realm->cached_context);
2612 }
Sage Weila8599bd2009-10-06 11:31:12 -07002613 ci->i_wr_ref++;
Yan, Zheng5dda377c2015-04-30 14:40:54 +08002614 }
Sage Weila8599bd2009-10-06 11:31:12 -07002615 if (got & CEPH_CAP_FILE_BUFFER) {
Henry C Changd3d07202011-05-11 10:29:54 +00002616 if (ci->i_wb_ref == 0)
Sage Weil3772d262011-05-03 09:28:08 -07002617 ihold(&ci->vfs_inode);
Henry C Changd3d07202011-05-11 10:29:54 +00002618 ci->i_wb_ref++;
Jeff Layton40dcf752020-01-14 09:23:49 -05002619 dout("%s %p wb %d -> %d (?)\n", __func__,
Henry C Changd3d07202011-05-11 10:29:54 +00002620 &ci->vfs_inode, ci->i_wb_ref-1, ci->i_wb_ref);
Sage Weila8599bd2009-10-06 11:31:12 -07002621 }
2622}
2623
2624/*
2625 * Try to grab cap references. Specify those refs we @want, and the
2626 * minimal set we @need. Also include the larger offset we are writing
2627 * to (when applicable), and check against max_size here as well.
2628 * Note that caller is responsible for ensuring max_size increases are
2629 * requested from the MDS.
Jeff Layton1199d7d2019-04-02 15:58:05 -04002630 *
Yan, Zheng546d4022020-03-10 19:34:18 +08002631 * Returns 0 if caps were not able to be acquired (yet), 1 if succeed,
2632 * or a negative error code. There are 3 speical error codes:
Jeff Layton8006daf2021-09-07 13:54:34 -04002633 * -EAGAIN: need to sleep but non-blocking is specified
2634 * -EFBIG: ask caller to call check_max_size() and try again.
2635 * -EUCLEAN: ask caller to call ceph_renew_caps() and try again.
Sage Weila8599bd2009-10-06 11:31:12 -07002636 */
Yan, Zhengff5d9132019-07-25 20:16:45 +08002637enum {
Yan, Zheng719a2512020-03-05 20:21:00 +08002638 /* first 8 bits are reserved for CEPH_FILE_MODE_FOO */
2639 NON_BLOCKING = (1 << 8),
2640 CHECK_FILELOCK = (1 << 9),
Yan, Zhengff5d9132019-07-25 20:16:45 +08002641};
2642
Yan, Zheng5e3ded12019-07-25 20:16:43 +08002643static int try_get_cap_refs(struct inode *inode, int need, int want,
Yan, Zhengff5d9132019-07-25 20:16:45 +08002644 loff_t endoff, int flags, int *got)
Sage Weila8599bd2009-10-06 11:31:12 -07002645{
Yan, Zheng5e3ded12019-07-25 20:16:43 +08002646 struct ceph_inode_info *ci = ceph_inode(inode);
Yan, Zheng5dda377c2015-04-30 14:40:54 +08002647 struct ceph_mds_client *mdsc = ceph_inode_to_client(inode)->mdsc;
Sage Weila8599bd2009-10-06 11:31:12 -07002648 int ret = 0;
Yan, Zhengc4d4a582015-01-09 15:56:18 +08002649 int have, implemented;
Yan, Zheng5dda377c2015-04-30 14:40:54 +08002650 bool snap_rwsem_locked = false;
Sage Weila8599bd2009-10-06 11:31:12 -07002651
2652 dout("get_cap_refs %p need %s want %s\n", inode,
2653 ceph_cap_string(need), ceph_cap_string(want));
Yan, Zhengc4d4a582015-01-09 15:56:18 +08002654
Yan, Zheng5dda377c2015-04-30 14:40:54 +08002655again:
Sage Weilbe655592011-11-30 09:47:09 -08002656 spin_lock(&ci->i_ceph_lock);
Sage Weila8599bd2009-10-06 11:31:12 -07002657
Yan, Zhengff5d9132019-07-25 20:16:45 +08002658 if ((flags & CHECK_FILELOCK) &&
2659 (ci->i_ceph_flags & CEPH_I_ERROR_FILELOCK)) {
2660 dout("try_get_cap_refs %p error filelock\n", inode);
2661 ret = -EIO;
2662 goto out_unlock;
2663 }
2664
Yan, Zheng37505d52013-04-12 16:11:10 +08002665 /* finish pending truncate */
2666 while (ci->i_truncate_pending) {
2667 spin_unlock(&ci->i_ceph_lock);
Yan, Zheng5dda377c2015-04-30 14:40:54 +08002668 if (snap_rwsem_locked) {
2669 up_read(&mdsc->snap_rwsem);
2670 snap_rwsem_locked = false;
2671 }
Yan, Zhengb415bf42013-07-02 12:40:19 +08002672 __ceph_do_pending_vmtruncate(inode);
Yan, Zheng37505d52013-04-12 16:11:10 +08002673 spin_lock(&ci->i_ceph_lock);
2674 }
2675
Yan, Zheng3871cbb2013-08-05 14:10:29 +08002676 have = __ceph_caps_issued(ci, &implemented);
2677
2678 if (have & need & CEPH_CAP_FILE_WR) {
Sage Weila8599bd2009-10-06 11:31:12 -07002679 if (endoff >= 0 && endoff > (loff_t)ci->i_max_size) {
2680 dout("get_cap_refs %p endoff %llu > maxsize %llu\n",
2681 inode, endoff, ci->i_max_size);
Jeff Layton1199d7d2019-04-02 15:58:05 -04002682 if (endoff > ci->i_requested_max_size)
Jeff Layton8006daf2021-09-07 13:54:34 -04002683 ret = ci->i_auth_cap ? -EFBIG : -EUCLEAN;
Yan, Zheng3738daa2014-11-14 22:10:07 +08002684 goto out_unlock;
Sage Weila8599bd2009-10-06 11:31:12 -07002685 }
2686 /*
2687 * If a sync write is in progress, we must wait, so that we
2688 * can get a final snapshot value for size+mtime.
2689 */
2690 if (__ceph_have_pending_cap_snap(ci)) {
2691 dout("get_cap_refs %p cap_snap_pending\n", inode);
Yan, Zheng3738daa2014-11-14 22:10:07 +08002692 goto out_unlock;
Sage Weila8599bd2009-10-06 11:31:12 -07002693 }
2694 }
Sage Weila8599bd2009-10-06 11:31:12 -07002695
Sage Weila8599bd2009-10-06 11:31:12 -07002696 if ((have & need) == need) {
2697 /*
2698 * Look at (implemented & ~have & not) so that we keep waiting
2699 * on transition from wanted -> needed caps. This is needed
2700 * for WRBUFFER|WR -> WR to avoid a new WR sync write from
2701 * going before a prior buffered writeback happens.
2702 */
2703 int not = want & ~(have & need);
2704 int revoking = implemented & ~have;
2705 dout("get_cap_refs %p have %s but not %s (revoking %s)\n",
2706 inode, ceph_cap_string(have), ceph_cap_string(not),
2707 ceph_cap_string(revoking));
2708 if ((revoking & not) == 0) {
Yan, Zheng5dda377c2015-04-30 14:40:54 +08002709 if (!snap_rwsem_locked &&
2710 !ci->i_head_snapc &&
2711 (need & CEPH_CAP_FILE_WR)) {
2712 if (!down_read_trylock(&mdsc->snap_rwsem)) {
2713 /*
2714 * we can not call down_read() when
2715 * task isn't in TASK_RUNNING state
2716 */
Yan, Zhengff5d9132019-07-25 20:16:45 +08002717 if (flags & NON_BLOCKING) {
Jeff Layton1199d7d2019-04-02 15:58:05 -04002718 ret = -EAGAIN;
Yan, Zheng5dda377c2015-04-30 14:40:54 +08002719 goto out_unlock;
2720 }
2721
2722 spin_unlock(&ci->i_ceph_lock);
2723 down_read(&mdsc->snap_rwsem);
2724 snap_rwsem_locked = true;
2725 goto again;
2726 }
2727 snap_rwsem_locked = true;
2728 }
Yan, Zheng173e70e2020-02-18 08:17:08 -05002729 if ((have & want) == want)
2730 *got = need | want;
2731 else
2732 *got = need;
Jeff Layton40dcf752020-01-14 09:23:49 -05002733 ceph_take_cap_refs(ci, *got, true);
Sage Weila8599bd2009-10-06 11:31:12 -07002734 ret = 1;
2735 }
2736 } else {
Yan, Zheng03f4fcb2015-01-05 11:04:04 +08002737 int session_readonly = false;
Yan, Zhengc0e385b2020-03-05 20:20:59 +08002738 int mds_wanted;
Yan, Zheng525d15e2019-05-11 17:27:59 +08002739 if (ci->i_auth_cap &&
2740 (need & (CEPH_CAP_FILE_WR | CEPH_CAP_FILE_EXCL))) {
Yan, Zheng03f4fcb2015-01-05 11:04:04 +08002741 struct ceph_mds_session *s = ci->i_auth_cap->session;
2742 spin_lock(&s->s_cap_lock);
2743 session_readonly = s->s_readonly;
2744 spin_unlock(&s->s_cap_lock);
2745 }
2746 if (session_readonly) {
Yan, Zhengc0e385b2020-03-05 20:20:59 +08002747 dout("get_cap_refs %p need %s but mds%d readonly\n",
Yan, Zheng03f4fcb2015-01-05 11:04:04 +08002748 inode, ceph_cap_string(need), ci->i_auth_cap->mds);
Jeff Layton1199d7d2019-04-02 15:58:05 -04002749 ret = -EROFS;
Yan, Zheng03f4fcb2015-01-05 11:04:04 +08002750 goto out_unlock;
2751 }
2752
Jeff Layton5d6451b2021-08-31 13:39:13 -04002753 if (ceph_inode_is_shutdown(inode)) {
2754 dout("get_cap_refs %p inode is shutdown\n", inode);
2755 ret = -ESTALE;
Yan, Zhengc0e385b2020-03-05 20:20:59 +08002756 goto out_unlock;
2757 }
2758 mds_wanted = __ceph_caps_mds_wanted(ci, false);
2759 if (need & ~mds_wanted) {
2760 dout("get_cap_refs %p need %s > mds_wanted %s\n",
2761 inode, ceph_cap_string(need),
2762 ceph_cap_string(mds_wanted));
Jeff Layton8006daf2021-09-07 13:54:34 -04002763 ret = -EUCLEAN;
Yan, Zhengc0e385b2020-03-05 20:20:59 +08002764 goto out_unlock;
Yan, Zheng48fec5d2015-07-01 16:27:46 +08002765 }
2766
Yan, Zhengc0e385b2020-03-05 20:20:59 +08002767 dout("get_cap_refs %p have %s need %s\n", inode,
Sage Weila8599bd2009-10-06 11:31:12 -07002768 ceph_cap_string(have), ceph_cap_string(need));
2769 }
Yan, Zheng3738daa2014-11-14 22:10:07 +08002770out_unlock:
Yan, Zheng719a2512020-03-05 20:21:00 +08002771
2772 __ceph_touch_fmode(ci, mdsc, flags);
2773
Sage Weilbe655592011-11-30 09:47:09 -08002774 spin_unlock(&ci->i_ceph_lock);
Yan, Zheng5dda377c2015-04-30 14:40:54 +08002775 if (snap_rwsem_locked)
2776 up_read(&mdsc->snap_rwsem);
Yan, Zheng3738daa2014-11-14 22:10:07 +08002777
Xiubo Li1af16d52020-03-19 23:45:00 -04002778 if (!ret)
2779 ceph_update_cap_mis(&mdsc->metric);
2780 else if (ret == 1)
2781 ceph_update_cap_hit(&mdsc->metric);
2782
Sage Weila8599bd2009-10-06 11:31:12 -07002783 dout("get_cap_refs %p ret %d got %s\n", inode,
Yan, Zhengc4d4a582015-01-09 15:56:18 +08002784 ret, ceph_cap_string(*got));
Sage Weila8599bd2009-10-06 11:31:12 -07002785 return ret;
2786}
2787
2788/*
2789 * Check the offset we are writing up to against our current
2790 * max_size. If necessary, tell the MDS we want to write to
2791 * a larger offset.
2792 */
2793static void check_max_size(struct inode *inode, loff_t endoff)
2794{
2795 struct ceph_inode_info *ci = ceph_inode(inode);
2796 int check = 0;
2797
2798 /* do we need to explicitly request a larger max_size? */
Sage Weilbe655592011-11-30 09:47:09 -08002799 spin_lock(&ci->i_ceph_lock);
Yan, Zheng3871cbb2013-08-05 14:10:29 +08002800 if (endoff >= ci->i_max_size && endoff > ci->i_wanted_max_size) {
Sage Weila8599bd2009-10-06 11:31:12 -07002801 dout("write %p at large endoff %llu, req max_size\n",
2802 inode, endoff);
2803 ci->i_wanted_max_size = endoff;
Sage Weila8599bd2009-10-06 11:31:12 -07002804 }
Yan, Zheng3871cbb2013-08-05 14:10:29 +08002805 /* duplicate ceph_check_caps()'s logic */
2806 if (ci->i_auth_cap &&
2807 (ci->i_auth_cap->issued & CEPH_CAP_FILE_WR) &&
2808 ci->i_wanted_max_size > ci->i_max_size &&
2809 ci->i_wanted_max_size > ci->i_requested_max_size)
2810 check = 1;
Sage Weilbe655592011-11-30 09:47:09 -08002811 spin_unlock(&ci->i_ceph_lock);
Sage Weila8599bd2009-10-06 11:31:12 -07002812 if (check)
2813 ceph_check_caps(ci, CHECK_CAPS_AUTHONLY, NULL);
2814}
2815
Yan, Zheng719a2512020-03-05 20:21:00 +08002816static inline int get_used_fmode(int caps)
2817{
2818 int fmode = 0;
2819 if (caps & CEPH_CAP_FILE_RD)
2820 fmode |= CEPH_FILE_MODE_RD;
2821 if (caps & CEPH_CAP_FILE_WR)
2822 fmode |= CEPH_FILE_MODE_WR;
2823 return fmode;
2824}
2825
Yan, Zheng5e3ded12019-07-25 20:16:43 +08002826int ceph_try_get_caps(struct inode *inode, int need, int want,
Luis Henriques2ee9dd92018-10-15 16:45:57 +01002827 bool nonblock, int *got)
Yan, Zheng2b1ac852016-10-25 10:51:55 +08002828{
Yan, Zheng719a2512020-03-05 20:21:00 +08002829 int ret, flags;
Yan, Zheng2b1ac852016-10-25 10:51:55 +08002830
2831 BUG_ON(need & ~CEPH_CAP_FILE_RD);
Jeff Laytona25949b2020-02-18 14:12:45 -05002832 BUG_ON(want & ~(CEPH_CAP_FILE_CACHE | CEPH_CAP_FILE_LAZYIO |
2833 CEPH_CAP_FILE_SHARED | CEPH_CAP_FILE_EXCL |
2834 CEPH_CAP_ANY_DIR_OPS));
2835 if (need) {
2836 ret = ceph_pool_perm_check(inode, need);
2837 if (ret < 0)
2838 return ret;
2839 }
Yan, Zheng2b1ac852016-10-25 10:51:55 +08002840
Yan, Zheng719a2512020-03-05 20:21:00 +08002841 flags = get_used_fmode(need | want);
2842 if (nonblock)
2843 flags |= NON_BLOCKING;
2844
2845 ret = try_get_cap_refs(inode, need, want, 0, flags, got);
Yan, Zheng546d4022020-03-10 19:34:18 +08002846 /* three special error codes */
Jeff Layton8006daf2021-09-07 13:54:34 -04002847 if (ret == -EAGAIN || ret == -EFBIG || ret == -EUCLEAN)
Yan, Zheng546d4022020-03-10 19:34:18 +08002848 ret = 0;
2849 return ret;
Yan, Zheng2b1ac852016-10-25 10:51:55 +08002850}
2851
Sage Weila8599bd2009-10-06 11:31:12 -07002852/*
2853 * Wait for caps, and take cap references. If we can't get a WR cap
2854 * due to a small max_size, make sure we check_max_size (and possibly
2855 * ask the mds) so we don't get hung up indefinitely.
2856 */
Jeff Laytone72968e2021-04-05 12:19:35 -04002857int ceph_get_caps(struct file *filp, int need, int want, loff_t endoff, int *got)
Sage Weila8599bd2009-10-06 11:31:12 -07002858{
Yan, Zhengff5d9132019-07-25 20:16:45 +08002859 struct ceph_file_info *fi = filp->private_data;
Yan, Zheng5e3ded12019-07-25 20:16:43 +08002860 struct inode *inode = file_inode(filp);
2861 struct ceph_inode_info *ci = ceph_inode(inode);
Yan, Zheng81f148a2019-07-25 20:16:46 +08002862 struct ceph_fs_client *fsc = ceph_inode_to_client(inode);
Yan, Zhengff5d9132019-07-25 20:16:45 +08002863 int ret, _got, flags;
Sage Weila8599bd2009-10-06 11:31:12 -07002864
Yan, Zheng5e3ded12019-07-25 20:16:43 +08002865 ret = ceph_pool_perm_check(inode, need);
Yan, Zheng10183a62015-04-27 15:33:28 +08002866 if (ret < 0)
2867 return ret;
2868
Yan, Zheng81f148a2019-07-25 20:16:46 +08002869 if ((fi->fmode & CEPH_FILE_MODE_WR) &&
2870 fi->filp_gen != READ_ONCE(fsc->filp_gen))
2871 return -EBADF;
2872
Yan, Zheng719a2512020-03-05 20:21:00 +08002873 flags = get_used_fmode(need | want);
2874
Yan, Zheng5dda377c2015-04-30 14:40:54 +08002875 while (true) {
Yan, Zheng719a2512020-03-05 20:21:00 +08002876 flags &= CEPH_FILE_MODE_MASK;
2877 if (atomic_read(&fi->num_locks))
2878 flags |= CHECK_FILELOCK;
Yan, Zhengc4d4a582015-01-09 15:56:18 +08002879 _got = 0;
Yan, Zheng5e3ded12019-07-25 20:16:43 +08002880 ret = try_get_cap_refs(inode, need, want, endoff,
Yan, Zhengff5d9132019-07-25 20:16:45 +08002881 flags, &_got);
Yan, Zheng546d4022020-03-10 19:34:18 +08002882 WARN_ON_ONCE(ret == -EAGAIN);
Yan, Zheng7b2f9362019-05-20 09:50:09 +08002883 if (!ret) {
Jeff Layton3a3430a2019-11-20 12:00:59 -05002884 struct ceph_mds_client *mdsc = fsc->mdsc;
2885 struct cap_wait cw;
Nikolay Borisov5c341ee32016-10-11 12:04:09 +03002886 DEFINE_WAIT_FUNC(wait, woken_wake_function);
Jeff Layton3a3430a2019-11-20 12:00:59 -05002887
Jeff Laytonebce3eb2020-08-18 08:03:48 -04002888 cw.ino = ceph_ino(inode);
Jeff Layton3a3430a2019-11-20 12:00:59 -05002889 cw.tgid = current->tgid;
2890 cw.need = need;
2891 cw.want = want;
2892
2893 spin_lock(&mdsc->caps_list_lock);
2894 list_add(&cw.list, &mdsc->cap_wait_list);
2895 spin_unlock(&mdsc->caps_list_lock);
2896
Yan, Zheng719a2512020-03-05 20:21:00 +08002897 /* make sure used fmode not timeout */
2898 ceph_get_fmode(ci, flags, FMODE_WAIT_BIAS);
Nikolay Borisov5c341ee32016-10-11 12:04:09 +03002899 add_wait_queue(&ci->i_cap_wq, &wait);
2900
Yan, Zhengff5d9132019-07-25 20:16:45 +08002901 flags |= NON_BLOCKING;
Yan, Zheng5e3ded12019-07-25 20:16:43 +08002902 while (!(ret = try_get_cap_refs(inode, need, want,
Yan, Zhengff5d9132019-07-25 20:16:45 +08002903 endoff, flags, &_got))) {
Yan, Zheng6e09d0f2016-12-22 16:05:43 +08002904 if (signal_pending(current)) {
2905 ret = -ERESTARTSYS;
2906 break;
2907 }
Nikolay Borisov5c341ee32016-10-11 12:04:09 +03002908 wait_woken(&wait, TASK_INTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT);
Yan, Zheng6e09d0f2016-12-22 16:05:43 +08002909 }
Nikolay Borisov5c341ee32016-10-11 12:04:09 +03002910
2911 remove_wait_queue(&ci->i_cap_wq, &wait);
Yan, Zheng719a2512020-03-05 20:21:00 +08002912 ceph_put_fmode(ci, flags, FMODE_WAIT_BIAS);
Jeff Layton3a3430a2019-11-20 12:00:59 -05002913
2914 spin_lock(&mdsc->caps_list_lock);
2915 list_del(&cw.list);
2916 spin_unlock(&mdsc->caps_list_lock);
2917
Yan, Zheng7b2f9362019-05-20 09:50:09 +08002918 if (ret == -EAGAIN)
Yan, Zheng5dda377c2015-04-30 14:40:54 +08002919 continue;
Yan, Zheng77310322016-04-08 15:27:16 +08002920 }
Yan, Zheng81f148a2019-07-25 20:16:46 +08002921
2922 if ((fi->fmode & CEPH_FILE_MODE_WR) &&
2923 fi->filp_gen != READ_ONCE(fsc->filp_gen)) {
2924 if (ret >= 0 && _got)
2925 ceph_put_cap_refs(ci, _got);
2926 return -EBADF;
2927 }
2928
Yan, Zheng7b2f9362019-05-20 09:50:09 +08002929 if (ret < 0) {
Jeff Layton8006daf2021-09-07 13:54:34 -04002930 if (ret == -EFBIG || ret == -EUCLEAN) {
Yan, Zheng9bccb762020-03-10 19:34:21 +08002931 int ret2 = ceph_wait_on_async_create(inode);
2932 if (ret2 < 0)
2933 return ret2;
2934 }
Yan, Zheng546d4022020-03-10 19:34:18 +08002935 if (ret == -EFBIG) {
2936 check_max_size(inode, endoff);
2937 continue;
2938 }
Jeff Layton8006daf2021-09-07 13:54:34 -04002939 if (ret == -EUCLEAN) {
Yan, Zheng7b2f9362019-05-20 09:50:09 +08002940 /* session was killed, try renew caps */
Yan, Zheng719a2512020-03-05 20:21:00 +08002941 ret = ceph_renew_caps(inode, flags);
Yan, Zheng7b2f9362019-05-20 09:50:09 +08002942 if (ret == 0)
2943 continue;
2944 }
Yan, Zheng77310322016-04-08 15:27:16 +08002945 return ret;
Yan, Zheng5dda377c2015-04-30 14:40:54 +08002946 }
Yan, Zhengc4d4a582015-01-09 15:56:18 +08002947
Yan, Zheng525d15e2019-05-11 17:27:59 +08002948 if (S_ISREG(ci->vfs_inode.i_mode) &&
2949 ci->i_inline_version != CEPH_INLINE_NONE &&
Yan, Zheng5dda377c2015-04-30 14:40:54 +08002950 (_got & (CEPH_CAP_FILE_CACHE|CEPH_CAP_FILE_LAZYIO)) &&
Yan, Zheng5e3ded12019-07-25 20:16:43 +08002951 i_size_read(inode) > 0) {
Yan, Zheng5dda377c2015-04-30 14:40:54 +08002952 struct page *page =
Yan, Zheng5e3ded12019-07-25 20:16:43 +08002953 find_get_page(inode->i_mapping, 0);
Yan, Zheng5dda377c2015-04-30 14:40:54 +08002954 if (page) {
Jeff Laytone72968e2021-04-05 12:19:35 -04002955 bool uptodate = PageUptodate(page);
2956
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03002957 put_page(page);
Jeff Laytone72968e2021-04-05 12:19:35 -04002958 if (uptodate)
2959 break;
Yan, Zheng5dda377c2015-04-30 14:40:54 +08002960 }
2961 /*
2962 * drop cap refs first because getattr while
2963 * holding * caps refs can cause deadlock.
2964 */
2965 ceph_put_cap_refs(ci, _got);
2966 _got = 0;
2967
2968 /*
2969 * getattr request will bring inline data into
2970 * page cache
2971 */
Yan, Zheng5e3ded12019-07-25 20:16:43 +08002972 ret = __ceph_do_getattr(inode, NULL,
Yan, Zheng5dda377c2015-04-30 14:40:54 +08002973 CEPH_STAT_CAP_INLINE_DATA,
2974 true);
2975 if (ret < 0)
2976 return ret;
2977 continue;
2978 }
2979 break;
Yan, Zhengc4d4a582015-01-09 15:56:18 +08002980 }
Yan, Zhengc4d4a582015-01-09 15:56:18 +08002981 *got = _got;
2982 return 0;
Sage Weila8599bd2009-10-06 11:31:12 -07002983}
2984
2985/*
2986 * Take cap refs. Caller must already know we hold at least one ref
2987 * on the caps in question or we don't know this is safe.
2988 */
2989void ceph_get_cap_refs(struct ceph_inode_info *ci, int caps)
2990{
Sage Weilbe655592011-11-30 09:47:09 -08002991 spin_lock(&ci->i_ceph_lock);
Jeff Layton40dcf752020-01-14 09:23:49 -05002992 ceph_take_cap_refs(ci, caps, false);
Sage Weilbe655592011-11-30 09:47:09 -08002993 spin_unlock(&ci->i_ceph_lock);
Sage Weila8599bd2009-10-06 11:31:12 -07002994}
2995
Yan, Zheng86056092015-05-01 16:57:16 +08002996
2997/*
2998 * drop cap_snap that is not associated with any snapshot.
2999 * we don't need to send FLUSHSNAP message for it.
3000 */
Yan, Zheng70220ac2016-07-06 16:21:30 +08003001static int ceph_try_drop_cap_snap(struct ceph_inode_info *ci,
3002 struct ceph_cap_snap *capsnap)
Yan, Zheng86056092015-05-01 16:57:16 +08003003{
3004 if (!capsnap->need_flush &&
3005 !capsnap->writing && !capsnap->dirty_pages) {
Yan, Zheng86056092015-05-01 16:57:16 +08003006 dout("dropping cap_snap %p follows %llu\n",
3007 capsnap, capsnap->follows);
Yan, Zheng0e294382016-07-04 18:06:41 +08003008 BUG_ON(capsnap->cap_flush.tid > 0);
Yan, Zheng86056092015-05-01 16:57:16 +08003009 ceph_put_snap_context(capsnap->context);
Yan, Zheng70220ac2016-07-06 16:21:30 +08003010 if (!list_is_last(&capsnap->ci_item, &ci->i_cap_snaps))
3011 ci->i_ceph_flags |= CEPH_I_FLUSH_SNAPS;
3012
Yan, Zheng86056092015-05-01 16:57:16 +08003013 list_del(&capsnap->ci_item);
Yan, Zheng86056092015-05-01 16:57:16 +08003014 ceph_put_cap_snap(capsnap);
3015 return 1;
3016 }
3017 return 0;
3018}
3019
Jeff Laytona8810cd2020-12-10 14:39:26 -05003020enum put_cap_refs_mode {
3021 PUT_CAP_REFS_SYNC = 0,
3022 PUT_CAP_REFS_NO_CHECK,
3023 PUT_CAP_REFS_ASYNC,
3024};
3025
Sage Weila8599bd2009-10-06 11:31:12 -07003026/*
3027 * Release cap refs.
3028 *
3029 * If we released the last ref on any given cap, call ceph_check_caps
3030 * to release (or schedule a release).
3031 *
3032 * If we are releasing a WR cap (from a sync write), finalize any affected
3033 * cap_snap, and wake up any waiters.
3034 */
Xiubo Lie64f44a2020-05-27 09:09:27 -04003035static void __ceph_put_cap_refs(struct ceph_inode_info *ci, int had,
Jeff Laytona8810cd2020-12-10 14:39:26 -05003036 enum put_cap_refs_mode mode)
Sage Weila8599bd2009-10-06 11:31:12 -07003037{
3038 struct inode *inode = &ci->vfs_inode;
3039 int last = 0, put = 0, flushsnaps = 0, wake = 0;
Xiubo Li558b4512021-02-02 14:54:53 +08003040 bool check_flushsnaps = false;
Sage Weila8599bd2009-10-06 11:31:12 -07003041
Sage Weilbe655592011-11-30 09:47:09 -08003042 spin_lock(&ci->i_ceph_lock);
Sage Weila8599bd2009-10-06 11:31:12 -07003043 if (had & CEPH_CAP_PIN)
3044 --ci->i_pin_ref;
3045 if (had & CEPH_CAP_FILE_RD)
3046 if (--ci->i_rd_ref == 0)
3047 last++;
3048 if (had & CEPH_CAP_FILE_CACHE)
3049 if (--ci->i_rdcache_ref == 0)
3050 last++;
Jeff Laytonf85122a2019-04-02 08:04:30 -04003051 if (had & CEPH_CAP_FILE_EXCL)
3052 if (--ci->i_fx_ref == 0)
3053 last++;
Sage Weila8599bd2009-10-06 11:31:12 -07003054 if (had & CEPH_CAP_FILE_BUFFER) {
Henry C Changd3d07202011-05-11 10:29:54 +00003055 if (--ci->i_wb_ref == 0) {
Sage Weila8599bd2009-10-06 11:31:12 -07003056 last++;
Xiubo Li558b4512021-02-02 14:54:53 +08003057 /* put the ref held by ceph_take_cap_refs() */
Sage Weila8599bd2009-10-06 11:31:12 -07003058 put++;
Xiubo Li558b4512021-02-02 14:54:53 +08003059 check_flushsnaps = true;
Sage Weila8599bd2009-10-06 11:31:12 -07003060 }
Henry C Changd3d07202011-05-11 10:29:54 +00003061 dout("put_cap_refs %p wb %d -> %d (?)\n",
3062 inode, ci->i_wb_ref+1, ci->i_wb_ref);
Sage Weila8599bd2009-10-06 11:31:12 -07003063 }
Xiubo Li558b4512021-02-02 14:54:53 +08003064 if (had & CEPH_CAP_FILE_WR) {
Sage Weila8599bd2009-10-06 11:31:12 -07003065 if (--ci->i_wr_ref == 0) {
3066 last++;
Xiubo Li558b4512021-02-02 14:54:53 +08003067 check_flushsnaps = true;
Yan, Zheng5dda377c2015-04-30 14:40:54 +08003068 if (ci->i_wrbuffer_ref_head == 0 &&
3069 ci->i_dirty_caps == 0 &&
3070 ci->i_flushing_caps == 0) {
3071 BUG_ON(!ci->i_head_snapc);
3072 ceph_put_snap_context(ci->i_head_snapc);
3073 ci->i_head_snapc = NULL;
3074 }
Yan, Zhengdb40cc12015-03-23 20:12:20 +08003075 /* see comment in __ceph_remove_cap() */
Xiubo Libd84fbc2019-12-03 03:00:51 -05003076 if (!__ceph_is_any_real_caps(ci) && ci->i_snap_realm)
Jeff Layton0ba92e12021-08-02 11:01:26 -04003077 ceph_change_snap_realm(inode, NULL);
Sage Weila8599bd2009-10-06 11:31:12 -07003078 }
Xiubo Li558b4512021-02-02 14:54:53 +08003079 }
3080 if (check_flushsnaps && __ceph_have_pending_cap_snap(ci)) {
3081 struct ceph_cap_snap *capsnap =
3082 list_last_entry(&ci->i_cap_snaps,
3083 struct ceph_cap_snap,
3084 ci_item);
3085
3086 capsnap->writing = 0;
3087 if (ceph_try_drop_cap_snap(ci, capsnap))
3088 /* put the ref held by ceph_queue_cap_snap() */
3089 put++;
3090 else if (__ceph_finish_cap_snap(ci, capsnap))
3091 flushsnaps = 1;
3092 wake = 1;
3093 }
Sage Weilbe655592011-11-30 09:47:09 -08003094 spin_unlock(&ci->i_ceph_lock);
Sage Weila8599bd2009-10-06 11:31:12 -07003095
Sage Weil819ccbf2010-04-01 09:33:46 -07003096 dout("put_cap_refs %p had %s%s%s\n", inode, ceph_cap_string(had),
3097 last ? " last" : "", put ? " put" : "");
Sage Weila8599bd2009-10-06 11:31:12 -07003098
Jeff Laytona8810cd2020-12-10 14:39:26 -05003099 switch (mode) {
3100 case PUT_CAP_REFS_SYNC:
Jeff Layton64f36da2020-12-10 13:35:46 -05003101 if (last)
3102 ceph_check_caps(ci, 0, NULL);
3103 else if (flushsnaps)
3104 ceph_flush_snaps(ci, NULL);
Jeff Laytona8810cd2020-12-10 14:39:26 -05003105 break;
3106 case PUT_CAP_REFS_ASYNC:
3107 if (last)
3108 ceph_queue_check_caps(inode);
3109 else if (flushsnaps)
3110 ceph_queue_flush_snaps(inode);
3111 break;
3112 default:
3113 break;
Jeff Layton64f36da2020-12-10 13:35:46 -05003114 }
Sage Weila8599bd2009-10-06 11:31:12 -07003115 if (wake)
Yehuda Sadeh03066f22010-07-27 13:11:08 -07003116 wake_up_all(&ci->i_cap_wq);
Yan, Zheng86056092015-05-01 16:57:16 +08003117 while (put-- > 0)
Sage Weila8599bd2009-10-06 11:31:12 -07003118 iput(inode);
3119}
3120
Xiubo Lie64f44a2020-05-27 09:09:27 -04003121void ceph_put_cap_refs(struct ceph_inode_info *ci, int had)
3122{
Jeff Laytona8810cd2020-12-10 14:39:26 -05003123 __ceph_put_cap_refs(ci, had, PUT_CAP_REFS_SYNC);
3124}
3125
3126void ceph_put_cap_refs_async(struct ceph_inode_info *ci, int had)
3127{
3128 __ceph_put_cap_refs(ci, had, PUT_CAP_REFS_ASYNC);
Xiubo Lie64f44a2020-05-27 09:09:27 -04003129}
3130
3131void ceph_put_cap_refs_no_check_caps(struct ceph_inode_info *ci, int had)
3132{
Jeff Laytona8810cd2020-12-10 14:39:26 -05003133 __ceph_put_cap_refs(ci, had, PUT_CAP_REFS_NO_CHECK);
Xiubo Lie64f44a2020-05-27 09:09:27 -04003134}
3135
Sage Weila8599bd2009-10-06 11:31:12 -07003136/*
3137 * Release @nr WRBUFFER refs on dirty pages for the given @snapc snap
3138 * context. Adjust per-snap dirty page accounting as appropriate.
3139 * Once all dirty data for a cap_snap is flushed, flush snapped file
3140 * metadata back to the MDS. If we dropped the last ref, call
3141 * ceph_check_caps.
3142 */
3143void ceph_put_wrbuffer_cap_refs(struct ceph_inode_info *ci, int nr,
3144 struct ceph_snap_context *snapc)
3145{
3146 struct inode *inode = &ci->vfs_inode;
Sage Weila8599bd2009-10-06 11:31:12 -07003147 struct ceph_cap_snap *capsnap = NULL;
Yan, Zheng70220ac2016-07-06 16:21:30 +08003148 int put = 0;
3149 bool last = false;
3150 bool found = false;
3151 bool flush_snaps = false;
3152 bool complete_capsnap = false;
Sage Weila8599bd2009-10-06 11:31:12 -07003153
Sage Weilbe655592011-11-30 09:47:09 -08003154 spin_lock(&ci->i_ceph_lock);
Sage Weila8599bd2009-10-06 11:31:12 -07003155 ci->i_wrbuffer_ref -= nr;
Yan, Zheng70220ac2016-07-06 16:21:30 +08003156 if (ci->i_wrbuffer_ref == 0) {
3157 last = true;
3158 put++;
3159 }
Sage Weila8599bd2009-10-06 11:31:12 -07003160
3161 if (ci->i_head_snapc == snapc) {
3162 ci->i_wrbuffer_ref_head -= nr;
Sage Weil7d8cb262010-08-24 08:44:16 -07003163 if (ci->i_wrbuffer_ref_head == 0 &&
Yan, Zheng5dda377c2015-04-30 14:40:54 +08003164 ci->i_wr_ref == 0 &&
3165 ci->i_dirty_caps == 0 &&
3166 ci->i_flushing_caps == 0) {
Sage Weil7d8cb262010-08-24 08:44:16 -07003167 BUG_ON(!ci->i_head_snapc);
Sage Weila8599bd2009-10-06 11:31:12 -07003168 ceph_put_snap_context(ci->i_head_snapc);
3169 ci->i_head_snapc = NULL;
3170 }
3171 dout("put_wrbuffer_cap_refs on %p head %d/%d -> %d/%d %s\n",
3172 inode,
3173 ci->i_wrbuffer_ref+nr, ci->i_wrbuffer_ref_head+nr,
3174 ci->i_wrbuffer_ref, ci->i_wrbuffer_ref_head,
3175 last ? " LAST" : "");
3176 } else {
3177 list_for_each_entry(capsnap, &ci->i_cap_snaps, ci_item) {
3178 if (capsnap->context == snapc) {
Yan, Zheng70220ac2016-07-06 16:21:30 +08003179 found = true;
Sage Weila8599bd2009-10-06 11:31:12 -07003180 break;
3181 }
3182 }
Xiubo Lia6d37cc2021-08-25 21:45:43 +08003183
3184 if (!found) {
3185 /*
3186 * The capsnap should already be removed when removing
3187 * auth cap in the case of a forced unmount.
3188 */
3189 WARN_ON_ONCE(ci->i_auth_cap);
3190 goto unlock;
3191 }
3192
Sage Weil819ccbf2010-04-01 09:33:46 -07003193 capsnap->dirty_pages -= nr;
3194 if (capsnap->dirty_pages == 0) {
Yan, Zheng70220ac2016-07-06 16:21:30 +08003195 complete_capsnap = true;
3196 if (!capsnap->writing) {
3197 if (ceph_try_drop_cap_snap(ci, capsnap)) {
3198 put++;
3199 } else {
3200 ci->i_ceph_flags |= CEPH_I_FLUSH_SNAPS;
3201 flush_snaps = true;
3202 }
3203 }
Sage Weil819ccbf2010-04-01 09:33:46 -07003204 }
Sage Weila8599bd2009-10-06 11:31:12 -07003205 dout("put_wrbuffer_cap_refs on %p cap_snap %p "
Yan, Zheng86056092015-05-01 16:57:16 +08003206 " snap %lld %d/%d -> %d/%d %s%s\n",
Sage Weila8599bd2009-10-06 11:31:12 -07003207 inode, capsnap, capsnap->context->seq,
3208 ci->i_wrbuffer_ref+nr, capsnap->dirty_pages + nr,
3209 ci->i_wrbuffer_ref, capsnap->dirty_pages,
3210 last ? " (wrbuffer last)" : "",
Yan, Zheng86056092015-05-01 16:57:16 +08003211 complete_capsnap ? " (complete capsnap)" : "");
Sage Weila8599bd2009-10-06 11:31:12 -07003212 }
3213
Xiubo Lia6d37cc2021-08-25 21:45:43 +08003214unlock:
Sage Weilbe655592011-11-30 09:47:09 -08003215 spin_unlock(&ci->i_ceph_lock);
Sage Weila8599bd2009-10-06 11:31:12 -07003216
3217 if (last) {
Yan, Zhengbf73c622020-03-05 20:21:04 +08003218 ceph_check_caps(ci, 0, NULL);
Yan, Zheng70220ac2016-07-06 16:21:30 +08003219 } else if (flush_snaps) {
Yan, Zhenged9b4302016-07-05 21:08:07 +08003220 ceph_flush_snaps(ci, NULL);
Sage Weila8599bd2009-10-06 11:31:12 -07003221 }
Yan, Zheng70220ac2016-07-06 16:21:30 +08003222 if (complete_capsnap)
3223 wake_up_all(&ci->i_cap_wq);
Yan, Zheng3e1d0452019-05-18 20:39:55 +08003224 while (put-- > 0) {
Jeff Layton23c2c762021-06-04 12:03:09 -04003225 iput(inode);
Yan, Zheng3e1d0452019-05-18 20:39:55 +08003226 }
Sage Weila8599bd2009-10-06 11:31:12 -07003227}
3228
3229/*
Yan, Zhengca20c992013-07-21 10:07:51 +08003230 * Invalidate unlinked inode's aliases, so we can drop the inode ASAP.
3231 */
3232static void invalidate_aliases(struct inode *inode)
3233{
3234 struct dentry *dn, *prev = NULL;
3235
3236 dout("invalidate_aliases inode %p\n", inode);
3237 d_prune_aliases(inode);
3238 /*
3239 * For non-directory inode, d_find_alias() only returns
J. Bruce Fieldsfc12c802014-01-16 17:42:53 -05003240 * hashed dentry. After calling d_invalidate(), the
3241 * dentry becomes unhashed.
Yan, Zhengca20c992013-07-21 10:07:51 +08003242 *
Yan, Zhenga8d436f2013-09-02 15:19:54 +08003243 * For directory inode, d_find_alias() can return
J. Bruce Fieldsfc12c802014-01-16 17:42:53 -05003244 * unhashed dentry. But directory inode should have
Yan, Zhengca20c992013-07-21 10:07:51 +08003245 * one alias at most.
3246 */
3247 while ((dn = d_find_alias(inode))) {
3248 if (dn == prev) {
3249 dput(dn);
3250 break;
3251 }
Yan, Zhenga8d436f2013-09-02 15:19:54 +08003252 d_invalidate(dn);
Yan, Zhengca20c992013-07-21 10:07:51 +08003253 if (prev)
3254 dput(prev);
3255 prev = dn;
3256 }
3257 if (prev)
3258 dput(prev);
3259}
3260
Yan, Zhenga1c6b832018-04-27 10:29:44 +08003261struct cap_extra_info {
3262 struct ceph_string *pool_ns;
3263 /* inline data */
3264 u64 inline_version;
3265 void *inline_data;
3266 u32 inline_len;
Yan, Zheng4985d6f2018-04-27 11:11:31 +08003267 /* dirstat */
3268 bool dirstat_valid;
3269 u64 nfiles;
3270 u64 nsubdirs;
Jeff Layton176c77c2019-06-06 08:06:40 -04003271 u64 change_attr;
Yan, Zhenga1c6b832018-04-27 10:29:44 +08003272 /* currently issued */
3273 int issued;
Jeff Laytonec62b892019-05-29 12:23:14 -04003274 struct timespec64 btime;
Yan, Zhenga1c6b832018-04-27 10:29:44 +08003275};
3276
Yan, Zhengca20c992013-07-21 10:07:51 +08003277/*
Sage Weila8599bd2009-10-06 11:31:12 -07003278 * Handle a cap GRANT message from the MDS. (Note that a GRANT may
3279 * actually be a revocation if it specifies a smaller cap set.)
3280 *
Sage Weilbe655592011-11-30 09:47:09 -08003281 * caller holds s_mutex and i_ceph_lock, we drop both.
Sage Weila8599bd2009-10-06 11:31:12 -07003282 */
Yan, Zhenga1c6b832018-04-27 10:29:44 +08003283static void handle_cap_grant(struct inode *inode,
Sage Weil15637c82010-03-16 13:42:00 -07003284 struct ceph_mds_session *session,
Yan, Zhenga1c6b832018-04-27 10:29:44 +08003285 struct ceph_cap *cap,
3286 struct ceph_mds_caps *grant,
3287 struct ceph_buffer *xattr_buf,
3288 struct cap_extra_info *extra_info)
Yan, Zheng2cd698b2014-04-18 13:20:27 +08003289 __releases(ci->i_ceph_lock)
Yan, Zhenga1c6b832018-04-27 10:29:44 +08003290 __releases(session->s_mdsc->snap_rwsem)
Sage Weila8599bd2009-10-06 11:31:12 -07003291{
3292 struct ceph_inode_info *ci = ceph_inode(inode);
Sage Weil2f56f562010-10-27 20:59:49 -07003293 int seq = le32_to_cpu(grant->seq);
Sage Weila8599bd2009-10-06 11:31:12 -07003294 int newcaps = le32_to_cpu(grant->caps);
Yan, Zheng2cd698b2014-04-18 13:20:27 +08003295 int used, wanted, dirty;
Sage Weila8599bd2009-10-06 11:31:12 -07003296 u64 size = le64_to_cpu(grant->size);
3297 u64 max_size = le64_to_cpu(grant->max_size);
Yan, Zhengfdac94f2018-11-22 15:26:01 +08003298 unsigned char check_caps = 0;
Jeff Layton52d60f82021-06-04 12:03:09 -04003299 bool was_stale = cap->cap_gen < atomic_read(&session->s_cap_gen);
Fabian Frederickab6c2c32014-10-09 23:16:35 +02003300 bool wake = false;
3301 bool writeback = false;
3302 bool queue_trunc = false;
3303 bool queue_invalidate = false;
Fabian Frederickab6c2c32014-10-09 23:16:35 +02003304 bool deleted_inode = false;
Yan, Zheng31c542a2014-11-14 21:41:55 +08003305 bool fill_inline = false;
Sage Weila8599bd2009-10-06 11:31:12 -07003306
Sage Weil2f56f562010-10-27 20:59:49 -07003307 dout("handle_cap_grant inode %p cap %p mds%d seq %d %s\n",
Yan, Zhenga1c6b832018-04-27 10:29:44 +08003308 inode, cap, session->s_mds, seq, ceph_cap_string(newcaps));
Sage Weila8599bd2009-10-06 11:31:12 -07003309 dout(" size %llu max_size %llu, i_size %llu\n", size, max_size,
Jeff Layton2d6795f2021-04-09 15:58:35 -04003310 i_size_read(inode));
Sage Weila8599bd2009-10-06 11:31:12 -07003311
Yan, Zheng11df2df2013-11-24 14:44:38 +08003312
3313 /*
Sage Weila8599bd2009-10-06 11:31:12 -07003314 * If CACHE is being revoked, and we have no dirty buffers,
3315 * try to invalidate (once). (If there are dirty buffers, we
3316 * will invalidate _after_ writeback.)
3317 */
Yan, Zheng525d15e2019-05-11 17:27:59 +08003318 if (S_ISREG(inode->i_mode) && /* don't invalidate readdir cache */
Yan, Zhengfdd4e152015-06-16 20:48:56 +08003319 ((cap->issued & ~newcaps) & CEPH_CAP_FILE_CACHE) &&
Sage Weil3b454c42010-06-10 13:20:33 -07003320 (newcaps & CEPH_CAP_FILE_LAZYIO) == 0 &&
Yan, Zheng9abd4db2016-05-18 20:58:26 +08003321 !(ci->i_wrbuffer_ref || ci->i_wb_ref)) {
Li Wange9075742013-08-15 22:00:25 -07003322 if (try_nonblocking_invalidate(inode)) {
Sage Weila8599bd2009-10-06 11:31:12 -07003323 /* there were locked pages.. invalidate later
3324 in a separate thread. */
3325 if (ci->i_rdcache_revoking != ci->i_rdcache_gen) {
Fabian Frederickab6c2c32014-10-09 23:16:35 +02003326 queue_invalidate = true;
Sage Weila8599bd2009-10-06 11:31:12 -07003327 ci->i_rdcache_revoking = ci->i_rdcache_gen;
3328 }
Sage Weila8599bd2009-10-06 11:31:12 -07003329 }
Sage Weila8599bd2009-10-06 11:31:12 -07003330 }
3331
Yan, Zhengd2f8bb22018-12-10 16:35:09 +08003332 if (was_stale)
3333 cap->issued = cap->implemented = CEPH_CAP_PIN;
3334
3335 /*
3336 * auth mds of the inode changed. we received the cap export message,
3337 * but still haven't received the cap import message. handle_cap_export
3338 * updated the new auth MDS' cap.
3339 *
3340 * "ceph_seq_cmp(seq, cap->seq) <= 0" means we are processing a message
3341 * that was sent before the cap import message. So don't remove caps.
3342 */
3343 if (ceph_seq_cmp(seq, cap->seq) <= 0) {
3344 WARN_ON(cap != ci->i_auth_cap);
3345 WARN_ON(cap->cap_id != le64_to_cpu(grant->cap_id));
3346 seq = cap->seq;
3347 newcaps |= cap->issued;
3348 }
3349
Sage Weila8599bd2009-10-06 11:31:12 -07003350 /* side effects now are allowed */
Jeff Layton52d60f82021-06-04 12:03:09 -04003351 cap->cap_gen = atomic_read(&session->s_cap_gen);
Yan, Zheng11df2df2013-11-24 14:44:38 +08003352 cap->seq = seq;
Sage Weila8599bd2009-10-06 11:31:12 -07003353
3354 __check_cap_issue(ci, cap, newcaps);
3355
Jeff Layton176c77c2019-06-06 08:06:40 -04003356 inode_set_max_iversion_raw(inode, extra_info->change_attr);
3357
Yan, Zhengf98a1282014-04-17 08:55:50 +08003358 if ((newcaps & CEPH_CAP_AUTH_SHARED) &&
Yan, Zhenga1c6b832018-04-27 10:29:44 +08003359 (extra_info->issued & CEPH_CAP_AUTH_EXCL) == 0) {
Jeff Laytoned94f872021-02-25 15:04:16 -05003360 umode_t mode = le32_to_cpu(grant->mode);
3361
3362 if (inode_wrong_type(inode, mode))
3363 pr_warn_once("inode type changed! (ino %llx.%llx is 0%o, mds says 0%o)\n",
3364 ceph_vinop(inode), inode->i_mode, mode);
3365 else
3366 inode->i_mode = mode;
Eric W. Biederman05cb11c2013-01-31 02:56:19 -08003367 inode->i_uid = make_kuid(&init_user_ns, le32_to_cpu(grant->uid));
3368 inode->i_gid = make_kgid(&init_user_ns, le32_to_cpu(grant->gid));
Jeff Laytonec62b892019-05-29 12:23:14 -04003369 ci->i_btime = extra_info->btime;
Sage Weila8599bd2009-10-06 11:31:12 -07003370 dout("%p mode 0%o uid.gid %d.%d\n", inode, inode->i_mode,
Eric W. Biedermanbd2bae62013-01-31 04:05:39 -08003371 from_kuid(&init_user_ns, inode->i_uid),
3372 from_kgid(&init_user_ns, inode->i_gid));
Sage Weila8599bd2009-10-06 11:31:12 -07003373 }
3374
Yan, Zhengfa466742018-05-25 11:22:56 +08003375 if ((newcaps & CEPH_CAP_LINK_SHARED) &&
Yan, Zhenga1c6b832018-04-27 10:29:44 +08003376 (extra_info->issued & CEPH_CAP_LINK_EXCL) == 0) {
Miklos Szeredibfe86842011-10-28 14:13:29 +02003377 set_nlink(inode, le32_to_cpu(grant->nlink));
Yan, Zhengca20c992013-07-21 10:07:51 +08003378 if (inode->i_nlink == 0 &&
3379 (newcaps & (CEPH_CAP_LINK_SHARED | CEPH_CAP_LINK_EXCL)))
Fabian Frederickab6c2c32014-10-09 23:16:35 +02003380 deleted_inode = true;
Yan, Zhengca20c992013-07-21 10:07:51 +08003381 }
Sage Weila8599bd2009-10-06 11:31:12 -07003382
Yan, Zhenga1c6b832018-04-27 10:29:44 +08003383 if ((extra_info->issued & CEPH_CAP_XATTR_EXCL) == 0 &&
3384 grant->xattr_len) {
Sage Weila8599bd2009-10-06 11:31:12 -07003385 int len = le32_to_cpu(grant->xattr_len);
3386 u64 version = le64_to_cpu(grant->xattr_version);
3387
3388 if (version > ci->i_xattrs.version) {
3389 dout(" got new xattrs v%llu on %p len %d\n",
3390 version, inode, len);
3391 if (ci->i_xattrs.blob)
3392 ceph_buffer_put(ci->i_xattrs.blob);
3393 ci->i_xattrs.blob = ceph_buffer_get(xattr_buf);
3394 ci->i_xattrs.version = version;
Guangliang Zhao7221fe42013-11-11 15:18:03 +08003395 ceph_forget_all_cached_acls(inode);
Yan, Zhengac6713c2019-05-26 16:27:56 +08003396 ceph_security_invalidate_secctx(inode);
Sage Weila8599bd2009-10-06 11:31:12 -07003397 }
3398 }
3399
Yan, Zhengf98a1282014-04-17 08:55:50 +08003400 if (newcaps & CEPH_CAP_ANY_RD) {
Arnd Bergmann9bbeab42018-07-13 22:18:36 +02003401 struct timespec64 mtime, atime, ctime;
Yan, Zhengf98a1282014-04-17 08:55:50 +08003402 /* ctime/mtime/atime? */
Arnd Bergmann9bbeab42018-07-13 22:18:36 +02003403 ceph_decode_timespec64(&mtime, &grant->mtime);
3404 ceph_decode_timespec64(&atime, &grant->atime);
3405 ceph_decode_timespec64(&ctime, &grant->ctime);
Yan, Zhenga1c6b832018-04-27 10:29:44 +08003406 ceph_fill_file_time(inode, extra_info->issued,
Yan, Zhengf98a1282014-04-17 08:55:50 +08003407 le32_to_cpu(grant->time_warp_seq),
3408 &ctime, &mtime, &atime);
3409 }
Sage Weila8599bd2009-10-06 11:31:12 -07003410
Yan, Zheng4985d6f2018-04-27 11:11:31 +08003411 if ((newcaps & CEPH_CAP_FILE_SHARED) && extra_info->dirstat_valid) {
3412 ci->i_files = extra_info->nfiles;
3413 ci->i_subdirs = extra_info->nsubdirs;
3414 }
3415
Yan, Zhengf98a1282014-04-17 08:55:50 +08003416 if (newcaps & (CEPH_CAP_ANY_FILE_RD | CEPH_CAP_ANY_FILE_WR)) {
3417 /* file layout may have changed */
Yan, Zheng76271512016-02-03 21:24:49 +08003418 s64 old_pool = ci->i_layout.pool_id;
Yan, Zheng779fe0f2016-03-07 09:35:06 +08003419 struct ceph_string *old_ns;
3420
Yan, Zheng76271512016-02-03 21:24:49 +08003421 ceph_file_layout_from_legacy(&ci->i_layout, &grant->layout);
Yan, Zheng779fe0f2016-03-07 09:35:06 +08003422 old_ns = rcu_dereference_protected(ci->i_layout.pool_ns,
3423 lockdep_is_held(&ci->i_ceph_lock));
Yan, Zhenga1c6b832018-04-27 10:29:44 +08003424 rcu_assign_pointer(ci->i_layout.pool_ns, extra_info->pool_ns);
Yan, Zheng779fe0f2016-03-07 09:35:06 +08003425
Yan, Zhenga1c6b832018-04-27 10:29:44 +08003426 if (ci->i_layout.pool_id != old_pool ||
3427 extra_info->pool_ns != old_ns)
Yan, Zheng76271512016-02-03 21:24:49 +08003428 ci->i_ceph_flags &= ~CEPH_I_POOL_PERM;
Yan, Zheng5ea5c5e2016-02-14 18:06:41 +08003429
Yan, Zhenga1c6b832018-04-27 10:29:44 +08003430 extra_info->pool_ns = old_ns;
Yan, Zheng779fe0f2016-03-07 09:35:06 +08003431
Yan, Zhengf98a1282014-04-17 08:55:50 +08003432 /* size/truncate_seq? */
Yan, Zhenga1c6b832018-04-27 10:29:44 +08003433 queue_trunc = ceph_fill_file_size(inode, extra_info->issued,
Yan, Zhengf98a1282014-04-17 08:55:50 +08003434 le32_to_cpu(grant->truncate_seq),
3435 le64_to_cpu(grant->truncate_size),
3436 size);
Yan, Zheng84eea8c2017-05-16 08:55:34 +08003437 }
3438
3439 if (ci->i_auth_cap == cap && (newcaps & CEPH_CAP_ANY_FILE_WR)) {
3440 if (max_size != ci->i_max_size) {
Yan, Zhengf98a1282014-04-17 08:55:50 +08003441 dout("max_size %lld -> %llu\n",
3442 ci->i_max_size, max_size);
3443 ci->i_max_size = max_size;
3444 if (max_size >= ci->i_wanted_max_size) {
3445 ci->i_wanted_max_size = 0; /* reset */
3446 ci->i_requested_max_size = 0;
3447 }
Fabian Frederickab6c2c32014-10-09 23:16:35 +02003448 wake = true;
Sage Weila8599bd2009-10-06 11:31:12 -07003449 }
Sage Weila8599bd2009-10-06 11:31:12 -07003450 }
3451
3452 /* check cap bits */
3453 wanted = __ceph_caps_wanted(ci);
3454 used = __ceph_caps_used(ci);
3455 dirty = __ceph_caps_dirty(ci);
3456 dout(" my wanted = %s, used = %s, dirty %s\n",
3457 ceph_cap_string(wanted),
3458 ceph_cap_string(used),
3459 ceph_cap_string(dirty));
Yan, Zhengfdac94f2018-11-22 15:26:01 +08003460
3461 if ((was_stale || le32_to_cpu(grant->op) == CEPH_CAP_OP_IMPORT) &&
3462 (wanted & ~(cap->mds_wanted | newcaps))) {
3463 /*
3464 * If mds is importing cap, prior cap messages that update
3465 * 'wanted' may get dropped by mds (migrate seq mismatch).
3466 *
3467 * We don't send cap message to update 'wanted' if what we
3468 * want are already issued. If mds revokes caps, cap message
3469 * that releases caps also tells mds what we want. But if
3470 * caps got revoked by mds forcedly (session stale). We may
3471 * haven't told mds what we want.
3472 */
3473 check_caps = 1;
Sage Weila8599bd2009-10-06 11:31:12 -07003474 }
3475
Sage Weila8599bd2009-10-06 11:31:12 -07003476 /* revocation, grant, or no-op? */
3477 if (cap->issued & ~newcaps) {
Sage Weil3b454c42010-06-10 13:20:33 -07003478 int revoking = cap->issued & ~newcaps;
3479
3480 dout("revocation: %s -> %s (revoking %s)\n",
3481 ceph_cap_string(cap->issued),
3482 ceph_cap_string(newcaps),
3483 ceph_cap_string(revoking));
Yan, Zheng525d15e2019-05-11 17:27:59 +08003484 if (S_ISREG(inode->i_mode) &&
3485 (revoking & used & CEPH_CAP_FILE_BUFFER))
Fabian Frederickab6c2c32014-10-09 23:16:35 +02003486 writeback = true; /* initiate writeback; will delay ack */
Yan, Zheng525d15e2019-05-11 17:27:59 +08003487 else if (queue_invalidate &&
3488 revoking == CEPH_CAP_FILE_CACHE &&
3489 (newcaps & CEPH_CAP_FILE_LAZYIO) == 0)
Sage Weil3b454c42010-06-10 13:20:33 -07003490 ; /* do nothing yet, invalidation will be queued */
3491 else if (cap == ci->i_auth_cap)
3492 check_caps = 1; /* check auth cap only */
3493 else
3494 check_caps = 2; /* check all caps */
Sage Weila8599bd2009-10-06 11:31:12 -07003495 cap->issued = newcaps;
Sage Weil978097c2010-03-08 15:27:53 -08003496 cap->implemented |= newcaps;
Sage Weila8599bd2009-10-06 11:31:12 -07003497 } else if (cap->issued == newcaps) {
3498 dout("caps unchanged: %s -> %s\n",
3499 ceph_cap_string(cap->issued), ceph_cap_string(newcaps));
3500 } else {
3501 dout("grant: %s -> %s\n", ceph_cap_string(cap->issued),
3502 ceph_cap_string(newcaps));
Yan, Zheng6ee6b9532013-07-02 12:40:21 +08003503 /* non-auth MDS is revoking the newly grant caps ? */
3504 if (cap == ci->i_auth_cap &&
3505 __ceph_caps_revoking_other(ci, cap, newcaps))
3506 check_caps = 2;
3507
Sage Weila8599bd2009-10-06 11:31:12 -07003508 cap->issued = newcaps;
3509 cap->implemented |= newcaps; /* add bits only, to
3510 * avoid stepping on a
3511 * pending revocation */
Fabian Frederickab6c2c32014-10-09 23:16:35 +02003512 wake = true;
Sage Weila8599bd2009-10-06 11:31:12 -07003513 }
Sage Weil978097c2010-03-08 15:27:53 -08003514 BUG_ON(cap->issued & ~cap->implemented);
Sage Weila8599bd2009-10-06 11:31:12 -07003515
Yan, Zhenga1c6b832018-04-27 10:29:44 +08003516 if (extra_info->inline_version > 0 &&
3517 extra_info->inline_version >= ci->i_inline_version) {
3518 ci->i_inline_version = extra_info->inline_version;
Yan, Zheng31c542a2014-11-14 21:41:55 +08003519 if (ci->i_inline_version != CEPH_INLINE_NONE &&
3520 (newcaps & (CEPH_CAP_FILE_CACHE|CEPH_CAP_FILE_LAZYIO)))
3521 fill_inline = true;
3522 }
3523
Yan, Zheng6f05b302020-03-30 19:56:37 +08003524 if (ci->i_auth_cap == cap &&
3525 le32_to_cpu(grant->op) == CEPH_CAP_OP_IMPORT) {
Yan, Zhenga1c6b832018-04-27 10:29:44 +08003526 if (newcaps & ~extra_info->issued)
Fabian Frederickab6c2c32014-10-09 23:16:35 +02003527 wake = true;
Yan, Zheng6f05b302020-03-30 19:56:37 +08003528
3529 if (ci->i_requested_max_size > max_size ||
3530 !(le32_to_cpu(grant->wanted) & CEPH_CAP_ANY_FILE_WR)) {
3531 /* re-request max_size if necessary */
3532 ci->i_requested_max_size = 0;
3533 wake = true;
3534 }
3535
Jeff Laytone8a4d262020-02-25 11:49:53 -08003536 ceph_kick_flushing_inode_caps(session, ci);
3537 spin_unlock(&ci->i_ceph_lock);
Yan, Zhenga1c6b832018-04-27 10:29:44 +08003538 up_read(&session->s_mdsc->snap_rwsem);
Yan, Zheng0e294382016-07-04 18:06:41 +08003539 } else {
3540 spin_unlock(&ci->i_ceph_lock);
Yan, Zheng2cd698b2014-04-18 13:20:27 +08003541 }
3542
Yan, Zheng31c542a2014-11-14 21:41:55 +08003543 if (fill_inline)
Yan, Zhenga1c6b832018-04-27 10:29:44 +08003544 ceph_fill_inline_data(inode, NULL, extra_info->inline_data,
3545 extra_info->inline_len);
Yan, Zheng31c542a2014-11-14 21:41:55 +08003546
Yan, Zheng14649752016-05-20 15:41:20 +08003547 if (queue_trunc)
Yan, Zhengc6bcda62014-04-11 10:18:07 +08003548 ceph_queue_vmtruncate(inode);
Yan, Zhengc6bcda62014-04-11 10:18:07 +08003549
Sage Weil3c6f6b72010-02-09 15:24:44 -08003550 if (writeback)
Sage Weila8599bd2009-10-06 11:31:12 -07003551 /*
3552 * queue inode for writeback: we can't actually call
3553 * filemap_write_and_wait, etc. from message handler
3554 * context.
3555 */
Sage Weil3c6f6b72010-02-09 15:24:44 -08003556 ceph_queue_writeback(inode);
3557 if (queue_invalidate)
3558 ceph_queue_invalidate(inode);
Yan, Zhengca20c992013-07-21 10:07:51 +08003559 if (deleted_inode)
3560 invalidate_aliases(inode);
Sage Weila8599bd2009-10-06 11:31:12 -07003561 if (wake)
Yehuda Sadeh03066f22010-07-27 13:11:08 -07003562 wake_up_all(&ci->i_cap_wq);
Sage Weil15637c82010-03-16 13:42:00 -07003563
Jeff Layton6a92b082021-06-04 11:01:25 -04003564 mutex_unlock(&session->s_mutex);
Sage Weil15637c82010-03-16 13:42:00 -07003565 if (check_caps == 1)
Yan, Zhenga0d93e32020-03-05 20:21:01 +08003566 ceph_check_caps(ci, CHECK_CAPS_AUTHONLY | CHECK_CAPS_NOINVAL,
Sage Weil15637c82010-03-16 13:42:00 -07003567 session);
3568 else if (check_caps == 2)
Yan, Zhenga0d93e32020-03-05 20:21:01 +08003569 ceph_check_caps(ci, CHECK_CAPS_NOINVAL, session);
Sage Weila8599bd2009-10-06 11:31:12 -07003570}
3571
3572/*
3573 * Handle FLUSH_ACK from MDS, indicating that metadata we sent to the
3574 * MDS has been safely committed.
3575 */
Sage Weil6df058c2009-12-22 11:24:33 -08003576static void handle_cap_flush_ack(struct inode *inode, u64 flush_tid,
Sage Weila8599bd2009-10-06 11:31:12 -07003577 struct ceph_mds_caps *m,
3578 struct ceph_mds_session *session,
3579 struct ceph_cap *cap)
Sage Weilbe655592011-11-30 09:47:09 -08003580 __releases(ci->i_ceph_lock)
Sage Weila8599bd2009-10-06 11:31:12 -07003581{
3582 struct ceph_inode_info *ci = ceph_inode(inode);
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -07003583 struct ceph_mds_client *mdsc = ceph_sb_to_client(inode->i_sb)->mdsc;
Yan, Zhenge4500b52016-07-06 11:12:56 +08003584 struct ceph_cap_flush *cf, *tmp_cf;
Yan, Zheng553adfd2015-06-09 15:48:57 +08003585 LIST_HEAD(to_remove);
Sage Weila8599bd2009-10-06 11:31:12 -07003586 unsigned seq = le32_to_cpu(m->seq);
3587 int dirty = le32_to_cpu(m->dirty);
3588 int cleaned = 0;
Yan, Zhengc8799fc2016-07-07 15:22:38 +08003589 bool drop = false;
Thomas Meyer7271efa2017-10-07 16:02:21 +02003590 bool wake_ci = false;
3591 bool wake_mdsc = false;
Sage Weila8599bd2009-10-06 11:31:12 -07003592
Yan, Zhenge4500b52016-07-06 11:12:56 +08003593 list_for_each_entry_safe(cf, tmp_cf, &ci->i_cap_flush_list, i_list) {
Jeff Laytond7dbfb42020-03-18 15:34:20 -04003594 /* Is this the one that was flushed? */
Yan, Zheng553adfd2015-06-09 15:48:57 +08003595 if (cf->tid == flush_tid)
3596 cleaned = cf->caps;
Jeff Laytond7dbfb42020-03-18 15:34:20 -04003597
3598 /* Is this a capsnap? */
Xiubo Lib2f9fa12021-08-18 21:38:42 +08003599 if (cf->is_capsnap)
Yan, Zheng0e294382016-07-04 18:06:41 +08003600 continue;
Jeff Laytond7dbfb42020-03-18 15:34:20 -04003601
Yan, Zheng553adfd2015-06-09 15:48:57 +08003602 if (cf->tid <= flush_tid) {
Jeff Laytond7dbfb42020-03-18 15:34:20 -04003603 /*
3604 * An earlier or current tid. The FLUSH_ACK should
3605 * represent a superset of this flush's caps.
3606 */
Jeff Layton681ac632020-03-18 15:29:34 -04003607 wake_ci |= __detach_cap_flush_from_ci(ci, cf);
Yan, Zhenge4500b52016-07-06 11:12:56 +08003608 list_add_tail(&cf->i_list, &to_remove);
Yan, Zheng553adfd2015-06-09 15:48:57 +08003609 } else {
Jeff Laytond7dbfb42020-03-18 15:34:20 -04003610 /*
3611 * This is a later one. Any caps in it are still dirty
3612 * so don't count them as cleaned.
3613 */
Yan, Zheng553adfd2015-06-09 15:48:57 +08003614 cleaned &= ~cf->caps;
3615 if (!cleaned)
3616 break;
3617 }
3618 }
Sage Weila8599bd2009-10-06 11:31:12 -07003619
3620 dout("handle_cap_flush_ack inode %p mds%d seq %d on %s cleaned %s,"
3621 " flushing %s -> %s\n",
3622 inode, session->s_mds, seq, ceph_cap_string(dirty),
3623 ceph_cap_string(cleaned), ceph_cap_string(ci->i_flushing_caps),
3624 ceph_cap_string(ci->i_flushing_caps & ~cleaned));
3625
Yan, Zheng8310b082015-06-09 17:20:12 +08003626 if (list_empty(&to_remove) && !cleaned)
Sage Weila8599bd2009-10-06 11:31:12 -07003627 goto out;
3628
Sage Weila8599bd2009-10-06 11:31:12 -07003629 ci->i_flushing_caps &= ~cleaned;
Sage Weila8599bd2009-10-06 11:31:12 -07003630
3631 spin_lock(&mdsc->cap_dirty_lock);
Yan, Zheng8310b082015-06-09 17:20:12 +08003632
Jeff Layton681ac632020-03-18 15:29:34 -04003633 list_for_each_entry(cf, &to_remove, i_list)
3634 wake_mdsc |= __detach_cap_flush_from_mdsc(mdsc, cf);
Yan, Zheng8310b082015-06-09 17:20:12 +08003635
Sage Weila8599bd2009-10-06 11:31:12 -07003636 if (ci->i_flushing_caps == 0) {
Yan, Zheng0e294382016-07-04 18:06:41 +08003637 if (list_empty(&ci->i_cap_flush_list)) {
3638 list_del_init(&ci->i_flushing_item);
3639 if (!list_empty(&session->s_cap_flushing)) {
3640 dout(" mds%d still flushing cap on %p\n",
3641 session->s_mds,
3642 &list_first_entry(&session->s_cap_flushing,
3643 struct ceph_inode_info,
3644 i_flushing_item)->vfs_inode);
3645 }
3646 }
Sage Weila8599bd2009-10-06 11:31:12 -07003647 mdsc->num_cap_flushing--;
Sage Weila8599bd2009-10-06 11:31:12 -07003648 dout(" inode %p now !flushing\n", inode);
Sage Weilafcdaea2009-10-14 14:27:38 -07003649
3650 if (ci->i_dirty_caps == 0) {
3651 dout(" inode %p now clean\n", inode);
3652 BUG_ON(!list_empty(&ci->i_dirty_item));
Yan, Zhengc8799fc2016-07-07 15:22:38 +08003653 drop = true;
Yan, Zheng5dda377c2015-04-30 14:40:54 +08003654 if (ci->i_wr_ref == 0 &&
3655 ci->i_wrbuffer_ref_head == 0) {
Sage Weil7d8cb262010-08-24 08:44:16 -07003656 BUG_ON(!ci->i_head_snapc);
3657 ceph_put_snap_context(ci->i_head_snapc);
3658 ci->i_head_snapc = NULL;
3659 }
Sage Weil76e3b392009-10-15 18:13:53 -07003660 } else {
3661 BUG_ON(list_empty(&ci->i_dirty_item));
Sage Weilafcdaea2009-10-14 14:27:38 -07003662 }
Sage Weila8599bd2009-10-06 11:31:12 -07003663 }
3664 spin_unlock(&mdsc->cap_dirty_lock);
Sage Weila8599bd2009-10-06 11:31:12 -07003665
3666out:
Sage Weilbe655592011-11-30 09:47:09 -08003667 spin_unlock(&ci->i_ceph_lock);
Yan, Zheng553adfd2015-06-09 15:48:57 +08003668
3669 while (!list_empty(&to_remove)) {
3670 cf = list_first_entry(&to_remove,
Yan, Zhenge4500b52016-07-06 11:12:56 +08003671 struct ceph_cap_flush, i_list);
Xiubo Lib2f9fa12021-08-18 21:38:42 +08003672 list_del_init(&cf->i_list);
3673 if (!cf->is_capsnap)
3674 ceph_free_cap_flush(cf);
Yan, Zheng553adfd2015-06-09 15:48:57 +08003675 }
Yan, Zhengc8799fc2016-07-07 15:22:38 +08003676
3677 if (wake_ci)
3678 wake_up_all(&ci->i_cap_wq);
3679 if (wake_mdsc)
3680 wake_up_all(&mdsc->cap_flushing_wq);
Sage Weilafcdaea2009-10-14 14:27:38 -07003681 if (drop)
Sage Weila8599bd2009-10-06 11:31:12 -07003682 iput(inode);
3683}
3684
Xiubo Lia6d37cc2021-08-25 21:45:43 +08003685void __ceph_remove_capsnap(struct inode *inode, struct ceph_cap_snap *capsnap,
3686 bool *wake_ci, bool *wake_mdsc)
3687{
3688 struct ceph_inode_info *ci = ceph_inode(inode);
3689 struct ceph_mds_client *mdsc = ceph_sb_to_client(inode->i_sb)->mdsc;
3690 bool ret;
3691
3692 lockdep_assert_held(&ci->i_ceph_lock);
3693
3694 dout("removing capsnap %p, inode %p ci %p\n", capsnap, inode, ci);
3695
3696 list_del_init(&capsnap->ci_item);
3697 ret = __detach_cap_flush_from_ci(ci, &capsnap->cap_flush);
3698 if (wake_ci)
3699 *wake_ci = ret;
3700
3701 spin_lock(&mdsc->cap_dirty_lock);
3702 if (list_empty(&ci->i_cap_flush_list))
3703 list_del_init(&ci->i_flushing_item);
3704
3705 ret = __detach_cap_flush_from_mdsc(mdsc, &capsnap->cap_flush);
3706 if (wake_mdsc)
3707 *wake_mdsc = ret;
3708 spin_unlock(&mdsc->cap_dirty_lock);
3709}
3710
3711void ceph_remove_capsnap(struct inode *inode, struct ceph_cap_snap *capsnap,
3712 bool *wake_ci, bool *wake_mdsc)
3713{
3714 struct ceph_inode_info *ci = ceph_inode(inode);
3715
3716 lockdep_assert_held(&ci->i_ceph_lock);
3717
3718 WARN_ON_ONCE(capsnap->dirty_pages || capsnap->writing);
3719 __ceph_remove_capsnap(inode, capsnap, wake_ci, wake_mdsc);
3720}
3721
Sage Weila8599bd2009-10-06 11:31:12 -07003722/*
3723 * Handle FLUSHSNAP_ACK. MDS has flushed snap data to disk and we can
3724 * throw away our cap_snap.
3725 *
3726 * Caller hold s_mutex.
3727 */
Sage Weil6df058c2009-12-22 11:24:33 -08003728static void handle_cap_flushsnap_ack(struct inode *inode, u64 flush_tid,
Sage Weila8599bd2009-10-06 11:31:12 -07003729 struct ceph_mds_caps *m,
3730 struct ceph_mds_session *session)
3731{
3732 struct ceph_inode_info *ci = ceph_inode(inode);
Yan, Zhengaffbc192015-05-05 21:22:13 +08003733 struct ceph_mds_client *mdsc = ceph_sb_to_client(inode->i_sb)->mdsc;
Sage Weila8599bd2009-10-06 11:31:12 -07003734 u64 follows = le64_to_cpu(m->snap_follows);
Sage Weila8599bd2009-10-06 11:31:12 -07003735 struct ceph_cap_snap *capsnap;
Yan, Zhengc8799fc2016-07-07 15:22:38 +08003736 bool flushed = false;
3737 bool wake_ci = false;
3738 bool wake_mdsc = false;
Sage Weila8599bd2009-10-06 11:31:12 -07003739
3740 dout("handle_cap_flushsnap_ack inode %p ci %p mds%d follows %lld\n",
3741 inode, ci, session->s_mds, follows);
3742
Sage Weilbe655592011-11-30 09:47:09 -08003743 spin_lock(&ci->i_ceph_lock);
Sage Weila8599bd2009-10-06 11:31:12 -07003744 list_for_each_entry(capsnap, &ci->i_cap_snaps, ci_item) {
3745 if (capsnap->follows == follows) {
Yan, Zheng0e294382016-07-04 18:06:41 +08003746 if (capsnap->cap_flush.tid != flush_tid) {
Sage Weila8599bd2009-10-06 11:31:12 -07003747 dout(" cap_snap %p follows %lld tid %lld !="
3748 " %lld\n", capsnap, follows,
Yan, Zheng0e294382016-07-04 18:06:41 +08003749 flush_tid, capsnap->cap_flush.tid);
Sage Weila8599bd2009-10-06 11:31:12 -07003750 break;
3751 }
Yan, Zhengc8799fc2016-07-07 15:22:38 +08003752 flushed = true;
Sage Weila8599bd2009-10-06 11:31:12 -07003753 break;
3754 } else {
3755 dout(" skipping cap_snap %p follows %lld\n",
3756 capsnap, capsnap->follows);
3757 }
3758 }
Xiubo Lia6d37cc2021-08-25 21:45:43 +08003759 if (flushed)
3760 ceph_remove_capsnap(inode, capsnap, &wake_ci, &wake_mdsc);
Sage Weilbe655592011-11-30 09:47:09 -08003761 spin_unlock(&ci->i_ceph_lock);
Xiubo Lia6d37cc2021-08-25 21:45:43 +08003762
Yan, Zheng0e294382016-07-04 18:06:41 +08003763 if (flushed) {
3764 ceph_put_snap_context(capsnap->context);
3765 ceph_put_cap_snap(capsnap);
Yan, Zhengc8799fc2016-07-07 15:22:38 +08003766 if (wake_ci)
3767 wake_up_all(&ci->i_cap_wq);
3768 if (wake_mdsc)
3769 wake_up_all(&mdsc->cap_flushing_wq);
Sage Weila8599bd2009-10-06 11:31:12 -07003770 iput(inode);
Yan, Zheng0e294382016-07-04 18:06:41 +08003771 }
Sage Weila8599bd2009-10-06 11:31:12 -07003772}
3773
3774/*
3775 * Handle TRUNC from MDS, indicating file truncation.
3776 *
3777 * caller hold s_mutex.
3778 */
Jeff Layton7391fba2020-03-18 16:43:30 -04003779static bool handle_cap_trunc(struct inode *inode,
Sage Weila8599bd2009-10-06 11:31:12 -07003780 struct ceph_mds_caps *trunc,
3781 struct ceph_mds_session *session)
Sage Weila8599bd2009-10-06 11:31:12 -07003782{
3783 struct ceph_inode_info *ci = ceph_inode(inode);
3784 int mds = session->s_mds;
3785 int seq = le32_to_cpu(trunc->seq);
3786 u32 truncate_seq = le32_to_cpu(trunc->truncate_seq);
3787 u64 truncate_size = le64_to_cpu(trunc->truncate_size);
3788 u64 size = le64_to_cpu(trunc->size);
3789 int implemented = 0;
3790 int dirty = __ceph_caps_dirty(ci);
3791 int issued = __ceph_caps_issued(ceph_inode(inode), &implemented);
Jeff Layton7391fba2020-03-18 16:43:30 -04003792 bool queue_trunc = false;
3793
3794 lockdep_assert_held(&ci->i_ceph_lock);
Sage Weila8599bd2009-10-06 11:31:12 -07003795
3796 issued |= implemented | dirty;
3797
3798 dout("handle_cap_trunc inode %p mds%d seq %d to %lld seq %d\n",
3799 inode, mds, seq, truncate_size, truncate_seq);
3800 queue_trunc = ceph_fill_file_size(inode, issued,
3801 truncate_seq, truncate_size, size);
Jeff Layton7391fba2020-03-18 16:43:30 -04003802 return queue_trunc;
Sage Weila8599bd2009-10-06 11:31:12 -07003803}
3804
3805/*
3806 * Handle EXPORT from MDS. Cap is being migrated _from_ this mds to a
3807 * different one. If we are the most recent migration we've seen (as
3808 * indicated by mseq), make note of the migrating cap bits for the
3809 * duration (until we see the corresponding IMPORT).
3810 *
3811 * caller holds s_mutex
3812 */
3813static void handle_cap_export(struct inode *inode, struct ceph_mds_caps *ex,
Yan, Zheng11df2df2013-11-24 14:44:38 +08003814 struct ceph_mds_cap_peer *ph,
3815 struct ceph_mds_session *session)
Sage Weila8599bd2009-10-06 11:31:12 -07003816{
Sage Weildb354052011-05-24 11:46:31 -07003817 struct ceph_mds_client *mdsc = ceph_inode_to_client(inode)->mdsc;
Yan, Zheng11df2df2013-11-24 14:44:38 +08003818 struct ceph_mds_session *tsession = NULL;
Yan, Zhengd9df2782014-04-18 09:57:11 +08003819 struct ceph_cap *cap, *tcap, *new_cap = NULL;
Sage Weila8599bd2009-10-06 11:31:12 -07003820 struct ceph_inode_info *ci = ceph_inode(inode);
Yan, Zheng11df2df2013-11-24 14:44:38 +08003821 u64 t_cap_id;
Sage Weila8599bd2009-10-06 11:31:12 -07003822 unsigned mseq = le32_to_cpu(ex->migrate_seq);
Yan, Zheng11df2df2013-11-24 14:44:38 +08003823 unsigned t_seq, t_mseq;
3824 int target, issued;
3825 int mds = session->s_mds;
Sage Weila8599bd2009-10-06 11:31:12 -07003826
Yan, Zheng11df2df2013-11-24 14:44:38 +08003827 if (ph) {
3828 t_cap_id = le64_to_cpu(ph->cap_id);
3829 t_seq = le32_to_cpu(ph->seq);
3830 t_mseq = le32_to_cpu(ph->mseq);
3831 target = le32_to_cpu(ph->mds);
3832 } else {
3833 t_cap_id = t_seq = t_mseq = 0;
3834 target = -1;
Sage Weila8599bd2009-10-06 11:31:12 -07003835 }
3836
Yan, Zheng11df2df2013-11-24 14:44:38 +08003837 dout("handle_cap_export inode %p ci %p mds%d mseq %d target %d\n",
3838 inode, ci, mds, mseq, target);
3839retry:
3840 spin_lock(&ci->i_ceph_lock);
3841 cap = __get_cap_for_mds(ci, mds);
Yan, Zhengca665e02014-04-21 15:46:37 +08003842 if (!cap || cap->cap_id != le64_to_cpu(ex->cap_id))
Yan, Zheng11df2df2013-11-24 14:44:38 +08003843 goto out_unlock;
Sage Weil154f42c2010-06-21 13:45:04 -07003844
Yan, Zheng11df2df2013-11-24 14:44:38 +08003845 if (target < 0) {
Xiubo Lia76d0a92021-08-25 21:45:45 +08003846 ceph_remove_cap(cap, false);
Yan, Zheng11df2df2013-11-24 14:44:38 +08003847 goto out_unlock;
3848 }
Sage Weildb354052011-05-24 11:46:31 -07003849
Yan, Zheng11df2df2013-11-24 14:44:38 +08003850 /*
3851 * now we know we haven't received the cap import message yet
3852 * because the exported cap still exist.
3853 */
3854
3855 issued = cap->issued;
Yan, Zhengd84b37f2018-01-03 11:16:27 +08003856 if (issued != cap->implemented)
3857 pr_err_ratelimited("handle_cap_export: issued != implemented: "
3858 "ino (%llx.%llx) mds%d seq %d mseq %d "
3859 "issued %s implemented %s\n",
3860 ceph_vinop(inode), mds, cap->seq, cap->mseq,
3861 ceph_cap_string(issued),
3862 ceph_cap_string(cap->implemented));
3863
Yan, Zheng11df2df2013-11-24 14:44:38 +08003864
3865 tcap = __get_cap_for_mds(ci, target);
3866 if (tcap) {
3867 /* already have caps from the target */
Yan, Zhengfa0aa3b2017-08-28 15:07:42 +08003868 if (tcap->cap_id == t_cap_id &&
Yan, Zheng11df2df2013-11-24 14:44:38 +08003869 ceph_seq_cmp(tcap->seq, t_seq) < 0) {
3870 dout(" updating import cap %p mds%d\n", tcap, target);
3871 tcap->cap_id = t_cap_id;
3872 tcap->seq = t_seq - 1;
3873 tcap->issue_seq = t_seq - 1;
Yan, Zheng11df2df2013-11-24 14:44:38 +08003874 tcap->issued |= issued;
3875 tcap->implemented |= issued;
Jeff Layton1cf03a62020-04-01 17:07:52 -04003876 if (cap == ci->i_auth_cap) {
Yan, Zheng11df2df2013-11-24 14:44:38 +08003877 ci->i_auth_cap = tcap;
Jeff Layton1cf03a62020-04-01 17:07:52 -04003878 change_auth_cap_ses(ci, tcap->session);
Sage Weildb354052011-05-24 11:46:31 -07003879 }
Sage Weila8599bd2009-10-06 11:31:12 -07003880 }
Xiubo Lia76d0a92021-08-25 21:45:45 +08003881 ceph_remove_cap(cap, false);
Yan, Zheng11df2df2013-11-24 14:44:38 +08003882 goto out_unlock;
Yan, Zhengd9df2782014-04-18 09:57:11 +08003883 } else if (tsession) {
Yan, Zheng11df2df2013-11-24 14:44:38 +08003884 /* add placeholder for the export tagert */
Yan, Zhengd9df2782014-04-18 09:57:11 +08003885 int flag = (cap == ci->i_auth_cap) ? CEPH_CAP_FLAG_AUTH : 0;
Yan, Zheng00f06cb2017-01-24 10:02:32 +08003886 tcap = new_cap;
Yan, Zheng135e6712020-03-05 20:21:02 +08003887 ceph_add_cap(inode, tsession, t_cap_id, issued, 0,
Yan, Zhengd9df2782014-04-18 09:57:11 +08003888 t_seq - 1, t_mseq, (u64)-1, flag, &new_cap);
3889
Yan, Zheng00f06cb2017-01-24 10:02:32 +08003890 if (!list_empty(&ci->i_cap_flush_list) &&
3891 ci->i_auth_cap == tcap) {
3892 spin_lock(&mdsc->cap_dirty_lock);
3893 list_move_tail(&ci->i_flushing_item,
3894 &tcap->session->s_cap_flushing);
3895 spin_unlock(&mdsc->cap_dirty_lock);
3896 }
3897
Xiubo Lia76d0a92021-08-25 21:45:45 +08003898 ceph_remove_cap(cap, false);
Yan, Zhengd9df2782014-04-18 09:57:11 +08003899 goto out_unlock;
Yan, Zheng11df2df2013-11-24 14:44:38 +08003900 }
Sage Weila8599bd2009-10-06 11:31:12 -07003901
Sage Weilbe655592011-11-30 09:47:09 -08003902 spin_unlock(&ci->i_ceph_lock);
Yan, Zheng11df2df2013-11-24 14:44:38 +08003903 mutex_unlock(&session->s_mutex);
3904
3905 /* open target session */
3906 tsession = ceph_mdsc_open_export_target_session(mdsc, target);
3907 if (!IS_ERR(tsession)) {
3908 if (mds > target) {
3909 mutex_lock(&session->s_mutex);
3910 mutex_lock_nested(&tsession->s_mutex,
3911 SINGLE_DEPTH_NESTING);
3912 } else {
3913 mutex_lock(&tsession->s_mutex);
3914 mutex_lock_nested(&session->s_mutex,
3915 SINGLE_DEPTH_NESTING);
3916 }
Yan, Zhengd9df2782014-04-18 09:57:11 +08003917 new_cap = ceph_get_cap(mdsc, NULL);
Yan, Zheng11df2df2013-11-24 14:44:38 +08003918 } else {
3919 WARN_ON(1);
3920 tsession = NULL;
3921 target = -1;
Wu Bo4d8e28f2020-04-30 14:12:49 +08003922 mutex_lock(&session->s_mutex);
Yan, Zheng11df2df2013-11-24 14:44:38 +08003923 }
3924 goto retry;
3925
3926out_unlock:
3927 spin_unlock(&ci->i_ceph_lock);
3928 mutex_unlock(&session->s_mutex);
3929 if (tsession) {
3930 mutex_unlock(&tsession->s_mutex);
3931 ceph_put_mds_session(tsession);
3932 }
Yan, Zhengd9df2782014-04-18 09:57:11 +08003933 if (new_cap)
3934 ceph_put_cap(mdsc, new_cap);
Sage Weila8599bd2009-10-06 11:31:12 -07003935}
3936
3937/*
Yan, Zheng2cd698b2014-04-18 13:20:27 +08003938 * Handle cap IMPORT.
Sage Weila8599bd2009-10-06 11:31:12 -07003939 *
Yan, Zheng2cd698b2014-04-18 13:20:27 +08003940 * caller holds s_mutex. acquires i_ceph_lock
Sage Weila8599bd2009-10-06 11:31:12 -07003941 */
3942static void handle_cap_import(struct ceph_mds_client *mdsc,
3943 struct inode *inode, struct ceph_mds_caps *im,
Yan, Zheng4ee6a912013-11-24 14:43:46 +08003944 struct ceph_mds_cap_peer *ph,
Sage Weila8599bd2009-10-06 11:31:12 -07003945 struct ceph_mds_session *session,
Yan, Zheng2cd698b2014-04-18 13:20:27 +08003946 struct ceph_cap **target_cap, int *old_issued)
Sage Weila8599bd2009-10-06 11:31:12 -07003947{
3948 struct ceph_inode_info *ci = ceph_inode(inode);
Yan, Zheng2cd698b2014-04-18 13:20:27 +08003949 struct ceph_cap *cap, *ocap, *new_cap = NULL;
Sage Weila8599bd2009-10-06 11:31:12 -07003950 int mds = session->s_mds;
Yan, Zheng2cd698b2014-04-18 13:20:27 +08003951 int issued;
3952 unsigned caps = le32_to_cpu(im->caps);
Sage Weila8599bd2009-10-06 11:31:12 -07003953 unsigned wanted = le32_to_cpu(im->wanted);
3954 unsigned seq = le32_to_cpu(im->seq);
3955 unsigned mseq = le32_to_cpu(im->migrate_seq);
3956 u64 realmino = le64_to_cpu(im->realm);
3957 u64 cap_id = le64_to_cpu(im->cap_id);
Yan, Zheng4ee6a912013-11-24 14:43:46 +08003958 u64 p_cap_id;
3959 int peer;
Sage Weila8599bd2009-10-06 11:31:12 -07003960
Yan, Zheng4ee6a912013-11-24 14:43:46 +08003961 if (ph) {
3962 p_cap_id = le64_to_cpu(ph->cap_id);
3963 peer = le32_to_cpu(ph->mds);
Sage Weila8599bd2009-10-06 11:31:12 -07003964 } else {
Yan, Zheng4ee6a912013-11-24 14:43:46 +08003965 p_cap_id = 0;
3966 peer = -1;
Sage Weila8599bd2009-10-06 11:31:12 -07003967 }
3968
Yan, Zheng4ee6a912013-11-24 14:43:46 +08003969 dout("handle_cap_import inode %p ci %p mds%d mseq %d peer %d\n",
3970 inode, ci, mds, mseq, peer);
Yan, Zhengd9df2782014-04-18 09:57:11 +08003971retry:
Yan, Zhengd9df2782014-04-18 09:57:11 +08003972 cap = __get_cap_for_mds(ci, mds);
3973 if (!cap) {
3974 if (!new_cap) {
3975 spin_unlock(&ci->i_ceph_lock);
3976 new_cap = ceph_get_cap(mdsc, NULL);
Jeff Layton78333232020-03-19 12:00:16 -04003977 spin_lock(&ci->i_ceph_lock);
Yan, Zhengd9df2782014-04-18 09:57:11 +08003978 goto retry;
3979 }
Yan, Zheng2cd698b2014-04-18 13:20:27 +08003980 cap = new_cap;
3981 } else {
3982 if (new_cap) {
3983 ceph_put_cap(mdsc, new_cap);
3984 new_cap = NULL;
3985 }
Yan, Zhengd9df2782014-04-18 09:57:11 +08003986 }
3987
Yan, Zheng2cd698b2014-04-18 13:20:27 +08003988 __ceph_caps_issued(ci, &issued);
3989 issued |= __ceph_caps_dirty(ci);
3990
Yan, Zheng135e6712020-03-05 20:21:02 +08003991 ceph_add_cap(inode, session, cap_id, caps, wanted, seq, mseq,
Yan, Zhengd9df2782014-04-18 09:57:11 +08003992 realmino, CEPH_CAP_FLAG_AUTH, &new_cap);
3993
Yan, Zheng2cd698b2014-04-18 13:20:27 +08003994 ocap = peer >= 0 ? __get_cap_for_mds(ci, peer) : NULL;
3995 if (ocap && ocap->cap_id == p_cap_id) {
Yan, Zheng4ee6a912013-11-24 14:43:46 +08003996 dout(" remove export cap %p mds%d flags %d\n",
Yan, Zheng2cd698b2014-04-18 13:20:27 +08003997 ocap, peer, ph->flags);
Yan, Zheng4ee6a912013-11-24 14:43:46 +08003998 if ((ph->flags & CEPH_CAP_FLAG_AUTH) &&
Yan, Zheng2cd698b2014-04-18 13:20:27 +08003999 (ocap->seq != le32_to_cpu(ph->seq) ||
4000 ocap->mseq != le32_to_cpu(ph->mseq))) {
Yan, Zhengd84b37f2018-01-03 11:16:27 +08004001 pr_err_ratelimited("handle_cap_import: "
4002 "mismatched seq/mseq: ino (%llx.%llx) "
4003 "mds%d seq %d mseq %d importer mds%d "
4004 "has peer seq %d mseq %d\n",
4005 ceph_vinop(inode), peer, ocap->seq,
4006 ocap->mseq, mds, le32_to_cpu(ph->seq),
4007 le32_to_cpu(ph->mseq));
Yan, Zheng4ee6a912013-11-24 14:43:46 +08004008 }
Xiubo Lia76d0a92021-08-25 21:45:45 +08004009 ceph_remove_cap(ocap, (ph->flags & CEPH_CAP_FLAG_RELEASE));
Yan, Zheng4ee6a912013-11-24 14:43:46 +08004010 }
4011
Yan, Zheng2cd698b2014-04-18 13:20:27 +08004012 *old_issued = issued;
4013 *target_cap = cap;
Sage Weila8599bd2009-10-06 11:31:12 -07004014}
4015
4016/*
4017 * Handle a caps message from the MDS.
4018 *
4019 * Identify the appropriate session, inode, and call the right handler
4020 * based on the cap op.
4021 */
4022void ceph_handle_caps(struct ceph_mds_session *session,
4023 struct ceph_msg *msg)
4024{
4025 struct ceph_mds_client *mdsc = session->s_mdsc;
Sage Weila8599bd2009-10-06 11:31:12 -07004026 struct inode *inode;
Sage Weilbe655592011-11-30 09:47:09 -08004027 struct ceph_inode_info *ci;
Sage Weila8599bd2009-10-06 11:31:12 -07004028 struct ceph_cap *cap;
4029 struct ceph_mds_caps *h;
Yan, Zheng4ee6a912013-11-24 14:43:46 +08004030 struct ceph_mds_cap_peer *peer = NULL;
Yan, Zheng779fe0f2016-03-07 09:35:06 +08004031 struct ceph_snap_realm *realm = NULL;
Yan, Zhenga1c6b832018-04-27 10:29:44 +08004032 int op;
Yan, Zheng4985d6f2018-04-27 11:11:31 +08004033 int msg_version = le16_to_cpu(msg->hdr.version);
Sage Weil3d7ded42010-06-09 16:47:10 -07004034 u32 seq, mseq;
Sage Weila8599bd2009-10-06 11:31:12 -07004035 struct ceph_vino vino;
Sage Weil70edb552010-03-01 13:20:50 -08004036 void *snaptrace;
Sage Weilce1fbc82010-08-02 15:09:39 -07004037 size_t snaptrace_len;
Yan, Zhengfb01d1f2014-11-14 21:29:55 +08004038 void *p, *end;
Yan, Zhenga1c6b832018-04-27 10:29:44 +08004039 struct cap_extra_info extra_info = {};
Jeff Layton7391fba2020-03-18 16:43:30 -04004040 bool queue_trunc;
Sage Weila8599bd2009-10-06 11:31:12 -07004041
Yan, Zhenga1c6b832018-04-27 10:29:44 +08004042 dout("handle_caps from mds%d\n", session->s_mds);
Sage Weila8599bd2009-10-06 11:31:12 -07004043
4044 /* decode */
Yan, Zheng4ee6a912013-11-24 14:43:46 +08004045 end = msg->front.iov_base + msg->front.iov_len;
Sage Weila8599bd2009-10-06 11:31:12 -07004046 if (msg->front.iov_len < sizeof(*h))
4047 goto bad;
4048 h = msg->front.iov_base;
4049 op = le32_to_cpu(h->op);
4050 vino.ino = le64_to_cpu(h->ino);
4051 vino.snap = CEPH_NOSNAP;
Sage Weila8599bd2009-10-06 11:31:12 -07004052 seq = le32_to_cpu(h->seq);
Sage Weil3d7ded42010-06-09 16:47:10 -07004053 mseq = le32_to_cpu(h->migrate_seq);
Sage Weila8599bd2009-10-06 11:31:12 -07004054
Sage Weilce1fbc82010-08-02 15:09:39 -07004055 snaptrace = h + 1;
4056 snaptrace_len = le32_to_cpu(h->snap_trace_len);
Yan, Zhengfb01d1f2014-11-14 21:29:55 +08004057 p = snaptrace + snaptrace_len;
Sage Weilce1fbc82010-08-02 15:09:39 -07004058
Yan, Zheng4985d6f2018-04-27 11:11:31 +08004059 if (msg_version >= 2) {
Yan, Zhengfb01d1f2014-11-14 21:29:55 +08004060 u32 flock_len;
Sage Weilce1fbc82010-08-02 15:09:39 -07004061 ceph_decode_32_safe(&p, end, flock_len, bad);
Yan, Zheng4ee6a912013-11-24 14:43:46 +08004062 if (p + flock_len > end)
4063 goto bad;
Yan, Zhengfb01d1f2014-11-14 21:29:55 +08004064 p += flock_len;
Sage Weilce1fbc82010-08-02 15:09:39 -07004065 }
4066
Yan, Zheng4985d6f2018-04-27 11:11:31 +08004067 if (msg_version >= 3) {
Yan, Zheng4ee6a912013-11-24 14:43:46 +08004068 if (op == CEPH_CAP_OP_IMPORT) {
Yan, Zheng4ee6a912013-11-24 14:43:46 +08004069 if (p + sizeof(*peer) > end)
4070 goto bad;
4071 peer = p;
Yan, Zhengfb01d1f2014-11-14 21:29:55 +08004072 p += sizeof(*peer);
Yan, Zheng11df2df2013-11-24 14:44:38 +08004073 } else if (op == CEPH_CAP_OP_EXPORT) {
4074 /* recorded in unused fields */
4075 peer = (void *)&h->size;
Yan, Zheng4ee6a912013-11-24 14:43:46 +08004076 }
4077 }
4078
Yan, Zheng4985d6f2018-04-27 11:11:31 +08004079 if (msg_version >= 4) {
Yan, Zhenga1c6b832018-04-27 10:29:44 +08004080 ceph_decode_64_safe(&p, end, extra_info.inline_version, bad);
4081 ceph_decode_32_safe(&p, end, extra_info.inline_len, bad);
4082 if (p + extra_info.inline_len > end)
Yan, Zhengfb01d1f2014-11-14 21:29:55 +08004083 goto bad;
Yan, Zhenga1c6b832018-04-27 10:29:44 +08004084 extra_info.inline_data = p;
4085 p += extra_info.inline_len;
Yan, Zhengfb01d1f2014-11-14 21:29:55 +08004086 }
4087
Yan, Zheng4985d6f2018-04-27 11:11:31 +08004088 if (msg_version >= 5) {
Jeff Layton92475f02017-04-13 11:07:04 -04004089 struct ceph_osd_client *osdc = &mdsc->fsc->client->osdc;
4090 u32 epoch_barrier;
4091
4092 ceph_decode_32_safe(&p, end, epoch_barrier, bad);
4093 ceph_osdc_update_epoch_barrier(osdc, epoch_barrier);
4094 }
4095
Yan, Zheng4985d6f2018-04-27 11:11:31 +08004096 if (msg_version >= 8) {
Yan, Zheng779fe0f2016-03-07 09:35:06 +08004097 u32 pool_ns_len;
Jeff Layton92475f02017-04-13 11:07:04 -04004098
Yan, Zheng5ea5c5e2016-02-14 18:06:41 +08004099 /* version >= 6 */
Jeff Layton06a1ad42020-09-29 19:32:19 -04004100 ceph_decode_skip_64(&p, end, bad); // flush_tid
Yan, Zheng5ea5c5e2016-02-14 18:06:41 +08004101 /* version >= 7 */
Jeff Layton06a1ad42020-09-29 19:32:19 -04004102 ceph_decode_skip_32(&p, end, bad); // caller_uid
4103 ceph_decode_skip_32(&p, end, bad); // caller_gid
Yan, Zheng5ea5c5e2016-02-14 18:06:41 +08004104 /* version >= 8 */
4105 ceph_decode_32_safe(&p, end, pool_ns_len, bad);
Yan, Zheng779fe0f2016-03-07 09:35:06 +08004106 if (pool_ns_len > 0) {
4107 ceph_decode_need(&p, end, pool_ns_len, bad);
Yan, Zhenga1c6b832018-04-27 10:29:44 +08004108 extra_info.pool_ns =
4109 ceph_find_or_create_string(p, pool_ns_len);
Yan, Zheng779fe0f2016-03-07 09:35:06 +08004110 p += pool_ns_len;
4111 }
Yan, Zheng5ea5c5e2016-02-14 18:06:41 +08004112 }
4113
Jeff Laytonec62b892019-05-29 12:23:14 -04004114 if (msg_version >= 9) {
Yan, Zheng4985d6f2018-04-27 11:11:31 +08004115 struct ceph_timespec *btime;
Yan, Zheng4985d6f2018-04-27 11:11:31 +08004116
Yan, Zheng4985d6f2018-04-27 11:11:31 +08004117 if (p + sizeof(*btime) > end)
4118 goto bad;
4119 btime = p;
Jeff Laytonec62b892019-05-29 12:23:14 -04004120 ceph_decode_timespec64(&extra_info.btime, btime);
Yan, Zheng4985d6f2018-04-27 11:11:31 +08004121 p += sizeof(*btime);
Jeff Layton176c77c2019-06-06 08:06:40 -04004122 ceph_decode_64_safe(&p, end, extra_info.change_attr, bad);
Jeff Laytonec62b892019-05-29 12:23:14 -04004123 }
4124
4125 if (msg_version >= 11) {
Yan, Zheng4985d6f2018-04-27 11:11:31 +08004126 /* version >= 10 */
Jeff Layton06a1ad42020-09-29 19:32:19 -04004127 ceph_decode_skip_32(&p, end, bad); // flags
Yan, Zheng4985d6f2018-04-27 11:11:31 +08004128 /* version >= 11 */
4129 extra_info.dirstat_valid = true;
4130 ceph_decode_64_safe(&p, end, extra_info.nfiles, bad);
4131 ceph_decode_64_safe(&p, end, extra_info.nsubdirs, bad);
4132 }
4133
Yan, Zheng6cd3bca2014-09-17 07:45:12 +08004134 /* lookup ino */
Yan, Zhenga1c6b832018-04-27 10:29:44 +08004135 inode = ceph_find_inode(mdsc->fsc->sb, vino);
Yan, Zheng6cd3bca2014-09-17 07:45:12 +08004136 ci = ceph_inode(inode);
4137 dout(" op %s ino %llx.%llx inode %p\n", ceph_cap_op_name(op), vino.ino,
4138 vino.snap, inode);
4139
Sage Weila8599bd2009-10-06 11:31:12 -07004140 mutex_lock(&session->s_mutex);
Jeff Layton62575e22020-10-12 09:39:06 -04004141 inc_session_sequence(session);
Sage Weila8599bd2009-10-06 11:31:12 -07004142 dout(" mds%d seq %lld cap seq %u\n", session->s_mds, session->s_seq,
4143 (unsigned)seq);
4144
Sage Weila8599bd2009-10-06 11:31:12 -07004145 if (!inode) {
4146 dout(" i don't have ino %llx\n", vino.ino);
Sage Weil3d7ded42010-06-09 16:47:10 -07004147
Yan, Zhenga096b092013-09-22 10:15:58 +08004148 if (op == CEPH_CAP_OP_IMPORT) {
Yan, Zheng745a8e32015-05-14 17:22:42 +08004149 cap = ceph_get_cap(mdsc, NULL);
4150 cap->cap_ino = vino.ino;
4151 cap->queue_release = 1;
Yan, Zheng779fe0f2016-03-07 09:35:06 +08004152 cap->cap_id = le64_to_cpu(h->cap_id);
Yan, Zheng745a8e32015-05-14 17:22:42 +08004153 cap->mseq = mseq;
4154 cap->seq = seq;
Yan, Zhengdc24de82016-11-17 19:55:30 +08004155 cap->issue_seq = seq;
Yan, Zhenga096b092013-09-22 10:15:58 +08004156 spin_lock(&session->s_cap_lock);
Yan, Zhenge3ec8d62019-01-14 17:21:19 +08004157 __ceph_queue_cap_release(session, cap);
Yan, Zhenga096b092013-09-22 10:15:58 +08004158 spin_unlock(&session->s_cap_lock);
4159 }
Jeff Laytonfb33c112020-05-20 10:36:07 -04004160 goto flush_cap_releases;
Sage Weila8599bd2009-10-06 11:31:12 -07004161 }
4162
4163 /* these will work even if we don't have a cap yet */
4164 switch (op) {
4165 case CEPH_CAP_OP_FLUSHSNAP_ACK:
Yan, Zhenga1c6b832018-04-27 10:29:44 +08004166 handle_cap_flushsnap_ack(inode, le64_to_cpu(msg->hdr.tid),
4167 h, session);
Sage Weila8599bd2009-10-06 11:31:12 -07004168 goto done;
4169
4170 case CEPH_CAP_OP_EXPORT:
Yan, Zheng11df2df2013-11-24 14:44:38 +08004171 handle_cap_export(inode, h, peer, session);
4172 goto done_unlocked;
Sage Weila8599bd2009-10-06 11:31:12 -07004173
4174 case CEPH_CAP_OP_IMPORT:
Yan, Zheng982d6012014-12-23 15:30:54 +08004175 realm = NULL;
4176 if (snaptrace_len) {
4177 down_write(&mdsc->snap_rwsem);
4178 ceph_update_snap_trace(mdsc, snaptrace,
4179 snaptrace + snaptrace_len,
4180 false, &realm);
4181 downgrade_write(&mdsc->snap_rwsem);
4182 } else {
4183 down_read(&mdsc->snap_rwsem);
4184 }
Jeff Layton78333232020-03-19 12:00:16 -04004185 spin_lock(&ci->i_ceph_lock);
Yan, Zheng4ee6a912013-11-24 14:43:46 +08004186 handle_cap_import(mdsc, inode, h, peer, session,
Yan, Zhenga1c6b832018-04-27 10:29:44 +08004187 &cap, &extra_info.issued);
4188 handle_cap_grant(inode, session, cap,
4189 h, msg->middle, &extra_info);
Yan, Zheng982d6012014-12-23 15:30:54 +08004190 if (realm)
4191 ceph_put_snap_realm(mdsc, realm);
Yan, Zheng2cd698b2014-04-18 13:20:27 +08004192 goto done_unlocked;
Sage Weila8599bd2009-10-06 11:31:12 -07004193 }
4194
4195 /* the rest require a cap */
Sage Weilbe655592011-11-30 09:47:09 -08004196 spin_lock(&ci->i_ceph_lock);
Yan, Zhenga1c6b832018-04-27 10:29:44 +08004197 cap = __get_cap_for_mds(ceph_inode(inode), session->s_mds);
Sage Weila8599bd2009-10-06 11:31:12 -07004198 if (!cap) {
Sage Weil9dbd4122010-06-10 13:21:20 -07004199 dout(" no cap on %p ino %llx.%llx from mds%d\n",
Yan, Zhenga1c6b832018-04-27 10:29:44 +08004200 inode, ceph_ino(inode), ceph_snap(inode),
4201 session->s_mds);
Sage Weilbe655592011-11-30 09:47:09 -08004202 spin_unlock(&ci->i_ceph_lock);
Greg Farnum21b559d2010-10-06 15:46:30 -07004203 goto flush_cap_releases;
Sage Weila8599bd2009-10-06 11:31:12 -07004204 }
4205
Sage Weilbe655592011-11-30 09:47:09 -08004206 /* note that each of these drops i_ceph_lock for us */
Sage Weila8599bd2009-10-06 11:31:12 -07004207 switch (op) {
4208 case CEPH_CAP_OP_REVOKE:
4209 case CEPH_CAP_OP_GRANT:
Yan, Zhenga1c6b832018-04-27 10:29:44 +08004210 __ceph_caps_issued(ci, &extra_info.issued);
4211 extra_info.issued |= __ceph_caps_dirty(ci);
4212 handle_cap_grant(inode, session, cap,
4213 h, msg->middle, &extra_info);
Sage Weil15637c82010-03-16 13:42:00 -07004214 goto done_unlocked;
Sage Weila8599bd2009-10-06 11:31:12 -07004215
4216 case CEPH_CAP_OP_FLUSH_ACK:
Yan, Zhenga1c6b832018-04-27 10:29:44 +08004217 handle_cap_flush_ack(inode, le64_to_cpu(msg->hdr.tid),
4218 h, session, cap);
Sage Weila8599bd2009-10-06 11:31:12 -07004219 break;
4220
4221 case CEPH_CAP_OP_TRUNC:
Jeff Layton7391fba2020-03-18 16:43:30 -04004222 queue_trunc = handle_cap_trunc(inode, h, session);
4223 spin_unlock(&ci->i_ceph_lock);
4224 if (queue_trunc)
4225 ceph_queue_vmtruncate(inode);
Sage Weila8599bd2009-10-06 11:31:12 -07004226 break;
4227
4228 default:
Sage Weilbe655592011-11-30 09:47:09 -08004229 spin_unlock(&ci->i_ceph_lock);
Sage Weila8599bd2009-10-06 11:31:12 -07004230 pr_err("ceph_handle_caps: unknown cap op %d %s\n", op,
4231 ceph_cap_op_name(op));
4232 }
4233
Yan, Zhenge3ec8d62019-01-14 17:21:19 +08004234done:
4235 mutex_unlock(&session->s_mutex);
4236done_unlocked:
Jeff Layton23c2c762021-06-04 12:03:09 -04004237 iput(inode);
Jeff Layton2ad32cf2021-07-01 10:41:46 -04004238out:
4239 ceph_put_string(extra_info.pool_ns);
Yan, Zhenge3ec8d62019-01-14 17:21:19 +08004240 return;
Greg Farnum21b559d2010-10-06 15:46:30 -07004241
4242flush_cap_releases:
4243 /*
Yan, Zheng745a8e32015-05-14 17:22:42 +08004244 * send any cap release message to try to move things
Greg Farnum21b559d2010-10-06 15:46:30 -07004245 * along for the mds (who clearly thinks we still have this
4246 * cap).
4247 */
Yan, Zhenge3ec8d62019-01-14 17:21:19 +08004248 ceph_flush_cap_releases(mdsc, session);
4249 goto done;
Sage Weila8599bd2009-10-06 11:31:12 -07004250
4251bad:
4252 pr_err("ceph_handle_caps: corrupt message\n");
Sage Weil9ec7cab2009-12-14 15:13:47 -08004253 ceph_msg_dump(msg);
Jeff Layton2ad32cf2021-07-01 10:41:46 -04004254 goto out;
Sage Weila8599bd2009-10-06 11:31:12 -07004255}
4256
4257/*
4258 * Delayed work handler to process end of delayed cap release LRU list.
Luis Henriquesbf2ba432021-07-06 14:52:41 +01004259 *
4260 * If new caps are added to the list while processing it, these won't get
4261 * processed in this run. In this case, the ci->i_hold_caps_max will be
4262 * returned so that the work can be scheduled accordingly.
Sage Weila8599bd2009-10-06 11:31:12 -07004263 */
Luis Henriquesbf2ba432021-07-06 14:52:41 +01004264unsigned long ceph_check_delayed_caps(struct ceph_mds_client *mdsc)
Sage Weila8599bd2009-10-06 11:31:12 -07004265{
Yan, Zheng4b9f2042017-06-27 17:17:24 +08004266 struct inode *inode;
Sage Weila8599bd2009-10-06 11:31:12 -07004267 struct ceph_inode_info *ci;
Luis Henriquesbf2ba432021-07-06 14:52:41 +01004268 struct ceph_mount_options *opt = mdsc->fsc->mount_options;
4269 unsigned long delay_max = opt->caps_wanted_delay_max * HZ;
4270 unsigned long loop_start = jiffies;
4271 unsigned long delay = 0;
Sage Weila8599bd2009-10-06 11:31:12 -07004272
Sage Weila8599bd2009-10-06 11:31:12 -07004273 dout("check_delayed_caps\n");
Jeff Layton585d72f32020-06-30 15:36:21 -04004274 spin_lock(&mdsc->cap_delay_lock);
4275 while (!list_empty(&mdsc->cap_delay_list)) {
Sage Weila8599bd2009-10-06 11:31:12 -07004276 ci = list_first_entry(&mdsc->cap_delay_list,
4277 struct ceph_inode_info,
4278 i_cap_delay_list);
Luis Henriquesbf2ba432021-07-06 14:52:41 +01004279 if (time_before(loop_start, ci->i_hold_caps_max - delay_max)) {
4280 dout("%s caps added recently. Exiting loop", __func__);
4281 delay = ci->i_hold_caps_max;
4282 break;
4283 }
Sage Weila8599bd2009-10-06 11:31:12 -07004284 if ((ci->i_ceph_flags & CEPH_I_FLUSH) == 0 &&
4285 time_before(jiffies, ci->i_hold_caps_max))
4286 break;
4287 list_del_init(&ci->i_cap_delay_list);
Yan, Zheng4b9f2042017-06-27 17:17:24 +08004288
4289 inode = igrab(&ci->vfs_inode);
Yan, Zheng4b9f2042017-06-27 17:17:24 +08004290 if (inode) {
Jeff Layton585d72f32020-06-30 15:36:21 -04004291 spin_unlock(&mdsc->cap_delay_lock);
Yan, Zheng4b9f2042017-06-27 17:17:24 +08004292 dout("check_delayed_caps on %p\n", inode);
Yan, Zhenga0d93e32020-03-05 20:21:01 +08004293 ceph_check_caps(ci, 0, NULL);
Jeff Layton23c2c762021-06-04 12:03:09 -04004294 iput(inode);
Jeff Layton585d72f32020-06-30 15:36:21 -04004295 spin_lock(&mdsc->cap_delay_lock);
Yan, Zheng4b9f2042017-06-27 17:17:24 +08004296 }
Sage Weila8599bd2009-10-06 11:31:12 -07004297 }
4298 spin_unlock(&mdsc->cap_delay_lock);
Luis Henriquesbf2ba432021-07-06 14:52:41 +01004299
4300 return delay;
Sage Weila8599bd2009-10-06 11:31:12 -07004301}
4302
4303/*
Sage Weilafcdaea2009-10-14 14:27:38 -07004304 * Flush all dirty caps to the mds
4305 */
Jeff Layton1cf03a62020-04-01 17:07:52 -04004306static void flush_dirty_session_caps(struct ceph_mds_session *s)
Sage Weilafcdaea2009-10-14 14:27:38 -07004307{
Jeff Layton1cf03a62020-04-01 17:07:52 -04004308 struct ceph_mds_client *mdsc = s->s_mdsc;
Sage Weildb354052011-05-24 11:46:31 -07004309 struct ceph_inode_info *ci;
4310 struct inode *inode;
Sage Weilafcdaea2009-10-14 14:27:38 -07004311
4312 dout("flush_dirty_caps\n");
4313 spin_lock(&mdsc->cap_dirty_lock);
Jeff Layton1cf03a62020-04-01 17:07:52 -04004314 while (!list_empty(&s->s_cap_dirty)) {
4315 ci = list_first_entry(&s->s_cap_dirty, struct ceph_inode_info,
Sage Weildb354052011-05-24 11:46:31 -07004316 i_dirty_item);
Sage Weil70b666c2011-05-27 09:24:26 -07004317 inode = &ci->vfs_inode;
4318 ihold(inode);
Jeff Layton6407fbb2021-09-02 09:12:35 -04004319 dout("flush_dirty_caps %llx.%llx\n", ceph_vinop(inode));
Sage Weilafcdaea2009-10-14 14:27:38 -07004320 spin_unlock(&mdsc->cap_dirty_lock);
Yan, Zhenga0d93e32020-03-05 20:21:01 +08004321 ceph_check_caps(ci, CHECK_CAPS_FLUSH, NULL);
Sage Weil70b666c2011-05-27 09:24:26 -07004322 iput(inode);
Sage Weilafcdaea2009-10-14 14:27:38 -07004323 spin_lock(&mdsc->cap_dirty_lock);
4324 }
4325 spin_unlock(&mdsc->cap_dirty_lock);
Sage Weildb354052011-05-24 11:46:31 -07004326 dout("flush_dirty_caps done\n");
Sage Weilafcdaea2009-10-14 14:27:38 -07004327}
4328
Jeff Layton1cf03a62020-04-01 17:07:52 -04004329void ceph_flush_dirty_caps(struct ceph_mds_client *mdsc)
4330{
Xiubo Li59b312f2021-07-05 09:22:55 +08004331 ceph_mdsc_iterate_sessions(mdsc, flush_dirty_session_caps, true);
Jeff Layton1cf03a62020-04-01 17:07:52 -04004332}
4333
Yan, Zheng719a2512020-03-05 20:21:00 +08004334void __ceph_touch_fmode(struct ceph_inode_info *ci,
4335 struct ceph_mds_client *mdsc, int fmode)
4336{
4337 unsigned long now = jiffies;
4338 if (fmode & CEPH_FILE_MODE_RD)
4339 ci->i_last_rd = now;
4340 if (fmode & CEPH_FILE_MODE_WR)
4341 ci->i_last_wr = now;
4342 /* queue periodic check */
4343 if (fmode &&
4344 __ceph_is_any_real_caps(ci) &&
4345 list_empty(&ci->i_cap_delay_list))
Yan, Zhenga0d93e32020-03-05 20:21:01 +08004346 __cap_delay_requeue(mdsc, ci);
Yan, Zheng719a2512020-03-05 20:21:00 +08004347}
4348
4349void ceph_get_fmode(struct ceph_inode_info *ci, int fmode, int count)
4350{
Xiubo Li1dd8d472020-09-03 09:01:40 -04004351 struct ceph_mds_client *mdsc = ceph_sb_to_mdsc(ci->vfs_inode.i_sb);
Yan, Zheng719a2512020-03-05 20:21:00 +08004352 int bits = (fmode << 1) | 1;
Hu Weiwen973e5242021-11-22 22:22:12 +08004353 bool already_opened = false;
Xiubo Li1dd8d472020-09-03 09:01:40 -04004354 int i;
4355
4356 if (count == 1)
4357 atomic64_inc(&mdsc->metric.opened_files);
4358
Yan, Zheng719a2512020-03-05 20:21:00 +08004359 spin_lock(&ci->i_ceph_lock);
4360 for (i = 0; i < CEPH_FILE_MODE_BITS; i++) {
Xiubo Li1dd8d472020-09-03 09:01:40 -04004361 /*
Hu Weiwen973e5242021-11-22 22:22:12 +08004362 * If any of the mode ref is larger than 0,
Xiubo Li1dd8d472020-09-03 09:01:40 -04004363 * that means it has been already opened by
4364 * others. Just skip checking the PIN ref.
4365 */
Hu Weiwen973e5242021-11-22 22:22:12 +08004366 if (i && ci->i_nr_by_mode[i])
4367 already_opened = true;
4368
4369 if (bits & (1 << i))
4370 ci->i_nr_by_mode[i] += count;
Yan, Zheng719a2512020-03-05 20:21:00 +08004371 }
Xiubo Li1dd8d472020-09-03 09:01:40 -04004372
Hu Weiwen973e5242021-11-22 22:22:12 +08004373 if (!already_opened)
Xiubo Li1dd8d472020-09-03 09:01:40 -04004374 percpu_counter_inc(&mdsc->metric.opened_inodes);
Yan, Zheng719a2512020-03-05 20:21:00 +08004375 spin_unlock(&ci->i_ceph_lock);
4376}
4377
Sage Weilafcdaea2009-10-14 14:27:38 -07004378/*
Sage Weila8599bd2009-10-06 11:31:12 -07004379 * Drop open file reference. If we were the last open file,
4380 * we may need to release capabilities to the MDS (or schedule
4381 * their delayed release).
4382 */
Yan, Zheng719a2512020-03-05 20:21:00 +08004383void ceph_put_fmode(struct ceph_inode_info *ci, int fmode, int count)
Sage Weila8599bd2009-10-06 11:31:12 -07004384{
Xiubo Li1dd8d472020-09-03 09:01:40 -04004385 struct ceph_mds_client *mdsc = ceph_sb_to_mdsc(ci->vfs_inode.i_sb);
Yan, Zheng774a6a12016-06-06 16:01:39 +08004386 int bits = (fmode << 1) | 1;
Xiubo Li1dd8d472020-09-03 09:01:40 -04004387 bool is_closed = true;
4388 int i;
4389
4390 if (count == 1)
4391 atomic64_dec(&mdsc->metric.opened_files);
4392
Sage Weilbe655592011-11-30 09:47:09 -08004393 spin_lock(&ci->i_ceph_lock);
Yan, Zheng774a6a12016-06-06 16:01:39 +08004394 for (i = 0; i < CEPH_FILE_MODE_BITS; i++) {
4395 if (bits & (1 << i)) {
Yan, Zheng719a2512020-03-05 20:21:00 +08004396 BUG_ON(ci->i_nr_by_mode[i] < count);
4397 ci->i_nr_by_mode[i] -= count;
Yan, Zheng774a6a12016-06-06 16:01:39 +08004398 }
Xiubo Li1dd8d472020-09-03 09:01:40 -04004399
4400 /*
4401 * If any of the mode ref is not 0 after
4402 * decreased, that means it is still opened
4403 * by others. Just skip checking the PIN ref.
4404 */
4405 if (i && ci->i_nr_by_mode[i])
4406 is_closed = false;
Yan, Zheng774a6a12016-06-06 16:01:39 +08004407 }
Xiubo Li1dd8d472020-09-03 09:01:40 -04004408
4409 if (is_closed)
4410 percpu_counter_dec(&mdsc->metric.opened_inodes);
Sage Weilbe655592011-11-30 09:47:09 -08004411 spin_unlock(&ci->i_ceph_lock);
Sage Weila8599bd2009-10-06 11:31:12 -07004412}
4413
4414/*
Jeff Laytona452bc02019-04-02 14:20:24 -04004415 * For a soon-to-be unlinked file, drop the LINK caps. If it
Zhi Zhang6ef0bc62018-01-24 21:24:33 +08004416 * looks like the link count will hit 0, drop any other caps (other
4417 * than PIN) we don't specifically want (due to the file still being
4418 * open).
4419 */
4420int ceph_drop_caps_for_unlink(struct inode *inode)
4421{
4422 struct ceph_inode_info *ci = ceph_inode(inode);
4423 int drop = CEPH_CAP_LINK_SHARED | CEPH_CAP_LINK_EXCL;
4424
4425 spin_lock(&ci->i_ceph_lock);
4426 if (inode->i_nlink == 1) {
4427 drop |= ~(__ceph_caps_wanted(ci) | CEPH_CAP_PIN);
4428
Zhi Zhang6ef0bc62018-01-24 21:24:33 +08004429 if (__ceph_caps_dirty(ci)) {
4430 struct ceph_mds_client *mdsc =
4431 ceph_inode_to_client(inode)->mdsc;
4432 __cap_delay_requeue_front(mdsc, ci);
4433 }
4434 }
4435 spin_unlock(&ci->i_ceph_lock);
4436 return drop;
4437}
4438
4439/*
Sage Weila8599bd2009-10-06 11:31:12 -07004440 * Helpers for embedding cap and dentry lease releases into mds
4441 * requests.
4442 *
4443 * @force is used by dentry_release (below) to force inclusion of a
4444 * record for the directory inode, even when there aren't any caps to
4445 * drop.
4446 */
4447int ceph_encode_inode_release(void **p, struct inode *inode,
4448 int mds, int drop, int unless, int force)
4449{
4450 struct ceph_inode_info *ci = ceph_inode(inode);
4451 struct ceph_cap *cap;
4452 struct ceph_mds_request_release *rel = *p;
Sage Weilec97f882010-06-24 15:12:37 -07004453 int used, dirty;
Sage Weila8599bd2009-10-06 11:31:12 -07004454 int ret = 0;
Sage Weila8599bd2009-10-06 11:31:12 -07004455
Sage Weilbe655592011-11-30 09:47:09 -08004456 spin_lock(&ci->i_ceph_lock);
Sage Weil916623d2010-03-16 15:01:07 -07004457 used = __ceph_caps_used(ci);
Sage Weilec97f882010-06-24 15:12:37 -07004458 dirty = __ceph_caps_dirty(ci);
Sage Weil916623d2010-03-16 15:01:07 -07004459
Sage Weilec97f882010-06-24 15:12:37 -07004460 dout("encode_inode_release %p mds%d used|dirty %s drop %s unless %s\n",
4461 inode, mds, ceph_cap_string(used|dirty), ceph_cap_string(drop),
Sage Weil916623d2010-03-16 15:01:07 -07004462 ceph_cap_string(unless));
4463
Sage Weilec97f882010-06-24 15:12:37 -07004464 /* only drop unused, clean caps */
4465 drop &= ~(used | dirty);
Sage Weil916623d2010-03-16 15:01:07 -07004466
Sage Weila8599bd2009-10-06 11:31:12 -07004467 cap = __get_cap_for_mds(ci, mds);
4468 if (cap && __cap_is_valid(cap)) {
Yan, Zheng222b7f92017-11-23 17:47:15 +08004469 unless &= cap->issued;
4470 if (unless) {
4471 if (unless & CEPH_CAP_AUTH_EXCL)
4472 drop &= ~CEPH_CAP_AUTH_SHARED;
4473 if (unless & CEPH_CAP_LINK_EXCL)
4474 drop &= ~CEPH_CAP_LINK_SHARED;
4475 if (unless & CEPH_CAP_XATTR_EXCL)
4476 drop &= ~CEPH_CAP_XATTR_SHARED;
4477 if (unless & CEPH_CAP_FILE_EXCL)
4478 drop &= ~CEPH_CAP_FILE_SHARED;
4479 }
4480
4481 if (force || (cap->issued & drop)) {
4482 if (cap->issued & drop) {
Yan, Zhengbb137f82013-06-03 18:22:17 +08004483 int wanted = __ceph_caps_wanted(ci);
Yan, Zhengbb137f82013-06-03 18:22:17 +08004484 dout("encode_inode_release %p cap %p "
4485 "%s -> %s, wanted %s -> %s\n", inode, cap,
Sage Weila8599bd2009-10-06 11:31:12 -07004486 ceph_cap_string(cap->issued),
Yan, Zhengbb137f82013-06-03 18:22:17 +08004487 ceph_cap_string(cap->issued & ~drop),
4488 ceph_cap_string(cap->mds_wanted),
4489 ceph_cap_string(wanted));
4490
Sage Weila8599bd2009-10-06 11:31:12 -07004491 cap->issued &= ~drop;
4492 cap->implemented &= ~drop;
Yan, Zhengbb137f82013-06-03 18:22:17 +08004493 cap->mds_wanted = wanted;
Yan, Zheng6f05b302020-03-30 19:56:37 +08004494 if (cap == ci->i_auth_cap &&
4495 !(wanted & CEPH_CAP_ANY_FILE_WR))
4496 ci->i_requested_max_size = 0;
Sage Weila8599bd2009-10-06 11:31:12 -07004497 } else {
4498 dout("encode_inode_release %p cap %p %s"
4499 " (force)\n", inode, cap,
4500 ceph_cap_string(cap->issued));
4501 }
4502
4503 rel->ino = cpu_to_le64(ceph_ino(inode));
4504 rel->cap_id = cpu_to_le64(cap->cap_id);
4505 rel->seq = cpu_to_le32(cap->seq);
Himangi Saraogi08a0f242014-07-23 20:11:11 +05304506 rel->issue_seq = cpu_to_le32(cap->issue_seq);
Sage Weila8599bd2009-10-06 11:31:12 -07004507 rel->mseq = cpu_to_le32(cap->mseq);
Yan, Zhengfd7b95c2014-04-17 08:02:02 +08004508 rel->caps = cpu_to_le32(cap->implemented);
Sage Weila8599bd2009-10-06 11:31:12 -07004509 rel->wanted = cpu_to_le32(cap->mds_wanted);
4510 rel->dname_len = 0;
4511 rel->dname_seq = 0;
4512 *p += sizeof(*rel);
4513 ret = 1;
4514 } else {
Yan, Zheng222b7f92017-11-23 17:47:15 +08004515 dout("encode_inode_release %p cap %p %s (noop)\n",
Sage Weila8599bd2009-10-06 11:31:12 -07004516 inode, cap, ceph_cap_string(cap->issued));
4517 }
4518 }
Sage Weilbe655592011-11-30 09:47:09 -08004519 spin_unlock(&ci->i_ceph_lock);
Sage Weila8599bd2009-10-06 11:31:12 -07004520 return ret;
4521}
4522
4523int ceph_encode_dentry_release(void **p, struct dentry *dentry,
Jeff Laytonca6c8ae2016-12-15 08:37:59 -05004524 struct inode *dir,
Sage Weila8599bd2009-10-06 11:31:12 -07004525 int mds, int drop, int unless)
4526{
Jeff Laytonca6c8ae2016-12-15 08:37:59 -05004527 struct dentry *parent = NULL;
Sage Weila8599bd2009-10-06 11:31:12 -07004528 struct ceph_mds_request_release *rel = *p;
4529 struct ceph_dentry_info *di = ceph_dentry(dentry);
4530 int force = 0;
4531 int ret;
4532
4533 /*
4534 * force an record for the directory caps if we have a dentry lease.
Sage Weilbe655592011-11-30 09:47:09 -08004535 * this is racy (can't take i_ceph_lock and d_lock together), but it
Sage Weila8599bd2009-10-06 11:31:12 -07004536 * doesn't have to be perfect; the mds will revoke anything we don't
4537 * release.
4538 */
4539 spin_lock(&dentry->d_lock);
4540 if (di->lease_session && di->lease_session->s_mds == mds)
4541 force = 1;
Jeff Laytonca6c8ae2016-12-15 08:37:59 -05004542 if (!dir) {
4543 parent = dget(dentry->d_parent);
4544 dir = d_inode(parent);
4545 }
Sage Weila8599bd2009-10-06 11:31:12 -07004546 spin_unlock(&dentry->d_lock);
4547
Jeff Laytonca6c8ae2016-12-15 08:37:59 -05004548 ret = ceph_encode_inode_release(p, dir, mds, drop, unless, force);
Jeff Laytonadf0d682016-12-15 08:37:58 -05004549 dput(parent);
Sage Weila8599bd2009-10-06 11:31:12 -07004550
4551 spin_lock(&dentry->d_lock);
4552 if (ret && di->lease_session && di->lease_session->s_mds == mds) {
4553 dout("encode_dentry_release %p mds%d seq %d\n",
4554 dentry, mds, (int)di->lease_seq);
4555 rel->dname_len = cpu_to_le32(dentry->d_name.len);
4556 memcpy(*p, dentry->d_name.name, dentry->d_name.len);
4557 *p += dentry->d_name.len;
4558 rel->dname_seq = cpu_to_le32(di->lease_seq);
Sage Weil1dadcce2010-07-23 13:54:21 -07004559 __ceph_mdsc_drop_dentry_lease(dentry);
Sage Weila8599bd2009-10-06 11:31:12 -07004560 }
4561 spin_unlock(&dentry->d_lock);
4562 return ret;
4563}
Jeff Layton36e6da92021-09-02 13:06:57 -04004564
4565static int remove_capsnaps(struct ceph_mds_client *mdsc, struct inode *inode)
4566{
4567 struct ceph_inode_info *ci = ceph_inode(inode);
4568 struct ceph_cap_snap *capsnap;
4569 int capsnap_release = 0;
4570
4571 lockdep_assert_held(&ci->i_ceph_lock);
4572
4573 dout("removing capsnaps, ci is %p, inode is %p\n", ci, inode);
4574
4575 while (!list_empty(&ci->i_cap_snaps)) {
4576 capsnap = list_first_entry(&ci->i_cap_snaps,
4577 struct ceph_cap_snap, ci_item);
4578 __ceph_remove_capsnap(inode, capsnap, NULL, NULL);
4579 ceph_put_snap_context(capsnap->context);
4580 ceph_put_cap_snap(capsnap);
4581 capsnap_release++;
4582 }
4583 wake_up_all(&ci->i_cap_wq);
4584 wake_up_all(&mdsc->cap_flushing_wq);
4585 return capsnap_release;
4586}
4587
4588int ceph_purge_inode_cap(struct inode *inode, struct ceph_cap *cap, bool *invalidate)
4589{
4590 struct ceph_fs_client *fsc = ceph_inode_to_client(inode);
4591 struct ceph_mds_client *mdsc = fsc->mdsc;
4592 struct ceph_inode_info *ci = ceph_inode(inode);
4593 bool is_auth;
4594 bool dirty_dropped = false;
4595 int iputs = 0;
4596
4597 lockdep_assert_held(&ci->i_ceph_lock);
4598
4599 dout("removing cap %p, ci is %p, inode is %p\n",
4600 cap, ci, &ci->vfs_inode);
4601
4602 is_auth = (cap == ci->i_auth_cap);
4603 __ceph_remove_cap(cap, false);
4604 if (is_auth) {
4605 struct ceph_cap_flush *cf;
4606
Jeff Layton5d6451b2021-08-31 13:39:13 -04004607 if (ceph_inode_is_shutdown(inode)) {
Jeff Layton36e6da92021-09-02 13:06:57 -04004608 if (inode->i_data.nrpages > 0)
4609 *invalidate = true;
4610 if (ci->i_wrbuffer_ref > 0)
4611 mapping_set_error(&inode->i_data, -EIO);
4612 }
4613
4614 spin_lock(&mdsc->cap_dirty_lock);
4615
4616 /* trash all of the cap flushes for this inode */
4617 while (!list_empty(&ci->i_cap_flush_list)) {
4618 cf = list_first_entry(&ci->i_cap_flush_list,
4619 struct ceph_cap_flush, i_list);
4620 list_del_init(&cf->g_list);
4621 list_del_init(&cf->i_list);
4622 if (!cf->is_capsnap)
4623 ceph_free_cap_flush(cf);
4624 }
4625
4626 if (!list_empty(&ci->i_dirty_item)) {
4627 pr_warn_ratelimited(
4628 " dropping dirty %s state for %p %lld\n",
4629 ceph_cap_string(ci->i_dirty_caps),
4630 inode, ceph_ino(inode));
4631 ci->i_dirty_caps = 0;
4632 list_del_init(&ci->i_dirty_item);
4633 dirty_dropped = true;
4634 }
4635 if (!list_empty(&ci->i_flushing_item)) {
4636 pr_warn_ratelimited(
4637 " dropping dirty+flushing %s state for %p %lld\n",
4638 ceph_cap_string(ci->i_flushing_caps),
4639 inode, ceph_ino(inode));
4640 ci->i_flushing_caps = 0;
4641 list_del_init(&ci->i_flushing_item);
4642 mdsc->num_cap_flushing--;
4643 dirty_dropped = true;
4644 }
4645 spin_unlock(&mdsc->cap_dirty_lock);
4646
4647 if (dirty_dropped) {
4648 mapping_set_error(inode->i_mapping, -EIO);
4649
4650 if (ci->i_wrbuffer_ref_head == 0 &&
4651 ci->i_wr_ref == 0 &&
4652 ci->i_dirty_caps == 0 &&
4653 ci->i_flushing_caps == 0) {
4654 ceph_put_snap_context(ci->i_head_snapc);
4655 ci->i_head_snapc = NULL;
4656 }
4657 }
4658
4659 if (atomic_read(&ci->i_filelock_ref) > 0) {
4660 /* make further file lock syscall return -EIO */
4661 ci->i_ceph_flags |= CEPH_I_ERROR_FILELOCK;
4662 pr_warn_ratelimited(" dropping file locks for %p %lld\n",
4663 inode, ceph_ino(inode));
4664 }
4665
4666 if (!ci->i_dirty_caps && ci->i_prealloc_cap_flush) {
4667 cf = ci->i_prealloc_cap_flush;
4668 ci->i_prealloc_cap_flush = NULL;
4669 if (!cf->is_capsnap)
4670 ceph_free_cap_flush(cf);
4671 }
4672
4673 if (!list_empty(&ci->i_cap_snaps))
4674 iputs = remove_capsnaps(mdsc, inode);
4675 }
4676 if (dirty_dropped)
4677 ++iputs;
4678 return iputs;
4679}