blob: 1e48377f18a7905019e82f3a963d0776c752abc2 [file] [log] [blame]
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -07001#include <linux/ceph/ceph_debug.h>
Sage Weila8599bd2009-10-06 11:31:12 -07002
3#include <linux/fs.h>
4#include <linux/kernel.h>
5#include <linux/sched.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +09006#include <linux/slab.h>
Sage Weila8599bd2009-10-06 11:31:12 -07007#include <linux/vmalloc.h>
8#include <linux/wait.h>
Stephen Rothwellf1a3d572010-01-18 11:53:08 +11009#include <linux/writeback.h>
Sage Weila8599bd2009-10-06 11:31:12 -070010
11#include "super.h"
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -070012#include "mds_client.h"
Milosz Tanski99ccbd22013-08-21 17:29:54 -040013#include "cache.h"
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -070014#include <linux/ceph/decode.h>
15#include <linux/ceph/messenger.h>
Sage Weila8599bd2009-10-06 11:31:12 -070016
17/*
18 * Capability management
19 *
20 * The Ceph metadata servers control client access to inode metadata
21 * and file data by issuing capabilities, granting clients permission
22 * to read and/or write both inode field and file data to OSDs
23 * (storage nodes). Each capability consists of a set of bits
24 * indicating which operations are allowed.
25 *
26 * If the client holds a *_SHARED cap, the client has a coherent value
27 * that can be safely read from the cached inode.
28 *
29 * In the case of a *_EXCL (exclusive) or FILE_WR capabilities, the
30 * client is allowed to change inode attributes (e.g., file size,
31 * mtime), note its dirty state in the ceph_cap, and asynchronously
32 * flush that metadata change to the MDS.
33 *
34 * In the event of a conflicting operation (perhaps by another
35 * client), the MDS will revoke the conflicting client capabilities.
36 *
37 * In order for a client to cache an inode, it must hold a capability
38 * with at least one MDS server. When inodes are released, release
39 * notifications are batched and periodically sent en masse to the MDS
40 * cluster to release server state.
41 */
42
43
44/*
45 * Generate readable cap strings for debugging output.
46 */
47#define MAX_CAP_STR 20
48static char cap_str[MAX_CAP_STR][40];
49static DEFINE_SPINLOCK(cap_str_lock);
50static int last_cap_str;
51
52static char *gcap_string(char *s, int c)
53{
54 if (c & CEPH_CAP_GSHARED)
55 *s++ = 's';
56 if (c & CEPH_CAP_GEXCL)
57 *s++ = 'x';
58 if (c & CEPH_CAP_GCACHE)
59 *s++ = 'c';
60 if (c & CEPH_CAP_GRD)
61 *s++ = 'r';
62 if (c & CEPH_CAP_GWR)
63 *s++ = 'w';
64 if (c & CEPH_CAP_GBUFFER)
65 *s++ = 'b';
66 if (c & CEPH_CAP_GLAZYIO)
67 *s++ = 'l';
68 return s;
69}
70
71const char *ceph_cap_string(int caps)
72{
73 int i;
74 char *s;
75 int c;
76
77 spin_lock(&cap_str_lock);
78 i = last_cap_str++;
79 if (last_cap_str == MAX_CAP_STR)
80 last_cap_str = 0;
81 spin_unlock(&cap_str_lock);
82
83 s = cap_str[i];
84
85 if (caps & CEPH_CAP_PIN)
86 *s++ = 'p';
87
88 c = (caps >> CEPH_CAP_SAUTH) & 3;
89 if (c) {
90 *s++ = 'A';
91 s = gcap_string(s, c);
92 }
93
94 c = (caps >> CEPH_CAP_SLINK) & 3;
95 if (c) {
96 *s++ = 'L';
97 s = gcap_string(s, c);
98 }
99
100 c = (caps >> CEPH_CAP_SXATTR) & 3;
101 if (c) {
102 *s++ = 'X';
103 s = gcap_string(s, c);
104 }
105
106 c = caps >> CEPH_CAP_SFILE;
107 if (c) {
108 *s++ = 'F';
109 s = gcap_string(s, c);
110 }
111
112 if (s == cap_str[i])
113 *s++ = '-';
114 *s = 0;
115 return cap_str[i];
116}
117
Yehuda Sadeh37151662010-06-17 16:16:12 -0700118void ceph_caps_init(struct ceph_mds_client *mdsc)
Sage Weila8599bd2009-10-06 11:31:12 -0700119{
Yehuda Sadeh37151662010-06-17 16:16:12 -0700120 INIT_LIST_HEAD(&mdsc->caps_list);
121 spin_lock_init(&mdsc->caps_list_lock);
Sage Weila8599bd2009-10-06 11:31:12 -0700122}
123
Yehuda Sadeh37151662010-06-17 16:16:12 -0700124void ceph_caps_finalize(struct ceph_mds_client *mdsc)
Sage Weila8599bd2009-10-06 11:31:12 -0700125{
126 struct ceph_cap *cap;
127
Yehuda Sadeh37151662010-06-17 16:16:12 -0700128 spin_lock(&mdsc->caps_list_lock);
129 while (!list_empty(&mdsc->caps_list)) {
130 cap = list_first_entry(&mdsc->caps_list,
131 struct ceph_cap, caps_item);
Sage Weila8599bd2009-10-06 11:31:12 -0700132 list_del(&cap->caps_item);
133 kmem_cache_free(ceph_cap_cachep, cap);
134 }
Yehuda Sadeh37151662010-06-17 16:16:12 -0700135 mdsc->caps_total_count = 0;
136 mdsc->caps_avail_count = 0;
137 mdsc->caps_use_count = 0;
138 mdsc->caps_reserve_count = 0;
139 mdsc->caps_min_count = 0;
140 spin_unlock(&mdsc->caps_list_lock);
Sage Weil85ccce42010-02-17 10:02:43 -0800141}
142
Yehuda Sadeh37151662010-06-17 16:16:12 -0700143void ceph_adjust_min_caps(struct ceph_mds_client *mdsc, int delta)
Sage Weil85ccce42010-02-17 10:02:43 -0800144{
Yehuda Sadeh37151662010-06-17 16:16:12 -0700145 spin_lock(&mdsc->caps_list_lock);
146 mdsc->caps_min_count += delta;
147 BUG_ON(mdsc->caps_min_count < 0);
148 spin_unlock(&mdsc->caps_list_lock);
Sage Weila8599bd2009-10-06 11:31:12 -0700149}
150
majianpeng93faca62013-06-26 11:15:27 +0800151void ceph_reserve_caps(struct ceph_mds_client *mdsc,
Yehuda Sadeh37151662010-06-17 16:16:12 -0700152 struct ceph_cap_reservation *ctx, int need)
Sage Weila8599bd2009-10-06 11:31:12 -0700153{
154 int i;
155 struct ceph_cap *cap;
156 int have;
157 int alloc = 0;
158 LIST_HEAD(newcaps);
Sage Weila8599bd2009-10-06 11:31:12 -0700159
160 dout("reserve caps ctx=%p need=%d\n", ctx, need);
161
162 /* first reserve any caps that are already allocated */
Yehuda Sadeh37151662010-06-17 16:16:12 -0700163 spin_lock(&mdsc->caps_list_lock);
164 if (mdsc->caps_avail_count >= need)
Sage Weila8599bd2009-10-06 11:31:12 -0700165 have = need;
166 else
Yehuda Sadeh37151662010-06-17 16:16:12 -0700167 have = mdsc->caps_avail_count;
168 mdsc->caps_avail_count -= have;
169 mdsc->caps_reserve_count += have;
170 BUG_ON(mdsc->caps_total_count != mdsc->caps_use_count +
171 mdsc->caps_reserve_count +
172 mdsc->caps_avail_count);
173 spin_unlock(&mdsc->caps_list_lock);
Sage Weila8599bd2009-10-06 11:31:12 -0700174
175 for (i = have; i < need; i++) {
176 cap = kmem_cache_alloc(ceph_cap_cachep, GFP_NOFS);
majianpeng93faca62013-06-26 11:15:27 +0800177 if (!cap)
178 break;
Sage Weila8599bd2009-10-06 11:31:12 -0700179 list_add(&cap->caps_item, &newcaps);
180 alloc++;
181 }
majianpeng93faca62013-06-26 11:15:27 +0800182 /* we didn't manage to reserve as much as we needed */
183 if (have + alloc != need)
184 pr_warn("reserve caps ctx=%p ENOMEM need=%d got=%d\n",
185 ctx, need, have + alloc);
Sage Weila8599bd2009-10-06 11:31:12 -0700186
Yehuda Sadeh37151662010-06-17 16:16:12 -0700187 spin_lock(&mdsc->caps_list_lock);
188 mdsc->caps_total_count += alloc;
189 mdsc->caps_reserve_count += alloc;
190 list_splice(&newcaps, &mdsc->caps_list);
Sage Weila8599bd2009-10-06 11:31:12 -0700191
Yehuda Sadeh37151662010-06-17 16:16:12 -0700192 BUG_ON(mdsc->caps_total_count != mdsc->caps_use_count +
193 mdsc->caps_reserve_count +
194 mdsc->caps_avail_count);
195 spin_unlock(&mdsc->caps_list_lock);
Sage Weila8599bd2009-10-06 11:31:12 -0700196
197 ctx->count = need;
198 dout("reserve caps ctx=%p %d = %d used + %d resv + %d avail\n",
Yehuda Sadeh37151662010-06-17 16:16:12 -0700199 ctx, mdsc->caps_total_count, mdsc->caps_use_count,
200 mdsc->caps_reserve_count, mdsc->caps_avail_count);
Sage Weila8599bd2009-10-06 11:31:12 -0700201}
202
Yehuda Sadeh37151662010-06-17 16:16:12 -0700203int ceph_unreserve_caps(struct ceph_mds_client *mdsc,
204 struct ceph_cap_reservation *ctx)
Sage Weila8599bd2009-10-06 11:31:12 -0700205{
206 dout("unreserve caps ctx=%p count=%d\n", ctx, ctx->count);
207 if (ctx->count) {
Yehuda Sadeh37151662010-06-17 16:16:12 -0700208 spin_lock(&mdsc->caps_list_lock);
209 BUG_ON(mdsc->caps_reserve_count < ctx->count);
210 mdsc->caps_reserve_count -= ctx->count;
211 mdsc->caps_avail_count += ctx->count;
Sage Weila8599bd2009-10-06 11:31:12 -0700212 ctx->count = 0;
213 dout("unreserve caps %d = %d used + %d resv + %d avail\n",
Yehuda Sadeh37151662010-06-17 16:16:12 -0700214 mdsc->caps_total_count, mdsc->caps_use_count,
215 mdsc->caps_reserve_count, mdsc->caps_avail_count);
216 BUG_ON(mdsc->caps_total_count != mdsc->caps_use_count +
217 mdsc->caps_reserve_count +
218 mdsc->caps_avail_count);
219 spin_unlock(&mdsc->caps_list_lock);
Sage Weila8599bd2009-10-06 11:31:12 -0700220 }
221 return 0;
222}
223
Yan, Zhengd9df2782014-04-18 09:57:11 +0800224struct ceph_cap *ceph_get_cap(struct ceph_mds_client *mdsc,
225 struct ceph_cap_reservation *ctx)
Sage Weila8599bd2009-10-06 11:31:12 -0700226{
227 struct ceph_cap *cap = NULL;
228
229 /* temporary, until we do something about cap import/export */
Sage Weil443b3762010-06-29 09:28:39 -0700230 if (!ctx) {
231 cap = kmem_cache_alloc(ceph_cap_cachep, GFP_NOFS);
232 if (cap) {
Yan, Zheng4d1d0532012-11-03 10:32:37 +0800233 spin_lock(&mdsc->caps_list_lock);
Yehuda Sadeh37151662010-06-17 16:16:12 -0700234 mdsc->caps_use_count++;
235 mdsc->caps_total_count++;
Yan, Zheng4d1d0532012-11-03 10:32:37 +0800236 spin_unlock(&mdsc->caps_list_lock);
Sage Weil443b3762010-06-29 09:28:39 -0700237 }
238 return cap;
239 }
Sage Weila8599bd2009-10-06 11:31:12 -0700240
Yehuda Sadeh37151662010-06-17 16:16:12 -0700241 spin_lock(&mdsc->caps_list_lock);
Sage Weila8599bd2009-10-06 11:31:12 -0700242 dout("get_cap ctx=%p (%d) %d = %d used + %d resv + %d avail\n",
Yehuda Sadeh37151662010-06-17 16:16:12 -0700243 ctx, ctx->count, mdsc->caps_total_count, mdsc->caps_use_count,
244 mdsc->caps_reserve_count, mdsc->caps_avail_count);
Sage Weila8599bd2009-10-06 11:31:12 -0700245 BUG_ON(!ctx->count);
Yehuda Sadeh37151662010-06-17 16:16:12 -0700246 BUG_ON(ctx->count > mdsc->caps_reserve_count);
247 BUG_ON(list_empty(&mdsc->caps_list));
Sage Weila8599bd2009-10-06 11:31:12 -0700248
249 ctx->count--;
Yehuda Sadeh37151662010-06-17 16:16:12 -0700250 mdsc->caps_reserve_count--;
251 mdsc->caps_use_count++;
Sage Weila8599bd2009-10-06 11:31:12 -0700252
Yehuda Sadeh37151662010-06-17 16:16:12 -0700253 cap = list_first_entry(&mdsc->caps_list, struct ceph_cap, caps_item);
Sage Weila8599bd2009-10-06 11:31:12 -0700254 list_del(&cap->caps_item);
255
Yehuda Sadeh37151662010-06-17 16:16:12 -0700256 BUG_ON(mdsc->caps_total_count != mdsc->caps_use_count +
257 mdsc->caps_reserve_count + mdsc->caps_avail_count);
258 spin_unlock(&mdsc->caps_list_lock);
Sage Weila8599bd2009-10-06 11:31:12 -0700259 return cap;
260}
261
Yehuda Sadeh37151662010-06-17 16:16:12 -0700262void ceph_put_cap(struct ceph_mds_client *mdsc, struct ceph_cap *cap)
Sage Weila8599bd2009-10-06 11:31:12 -0700263{
Yehuda Sadeh37151662010-06-17 16:16:12 -0700264 spin_lock(&mdsc->caps_list_lock);
Sage Weil7c1332b2010-02-16 11:39:45 -0800265 dout("put_cap %p %d = %d used + %d resv + %d avail\n",
Yehuda Sadeh37151662010-06-17 16:16:12 -0700266 cap, mdsc->caps_total_count, mdsc->caps_use_count,
267 mdsc->caps_reserve_count, mdsc->caps_avail_count);
268 mdsc->caps_use_count--;
Sage Weila8599bd2009-10-06 11:31:12 -0700269 /*
Sage Weil85ccce42010-02-17 10:02:43 -0800270 * Keep some preallocated caps around (ceph_min_count), to
271 * avoid lots of free/alloc churn.
Sage Weila8599bd2009-10-06 11:31:12 -0700272 */
Yehuda Sadeh37151662010-06-17 16:16:12 -0700273 if (mdsc->caps_avail_count >= mdsc->caps_reserve_count +
274 mdsc->caps_min_count) {
275 mdsc->caps_total_count--;
Sage Weila8599bd2009-10-06 11:31:12 -0700276 kmem_cache_free(ceph_cap_cachep, cap);
277 } else {
Yehuda Sadeh37151662010-06-17 16:16:12 -0700278 mdsc->caps_avail_count++;
279 list_add(&cap->caps_item, &mdsc->caps_list);
Sage Weila8599bd2009-10-06 11:31:12 -0700280 }
281
Yehuda Sadeh37151662010-06-17 16:16:12 -0700282 BUG_ON(mdsc->caps_total_count != mdsc->caps_use_count +
283 mdsc->caps_reserve_count + mdsc->caps_avail_count);
284 spin_unlock(&mdsc->caps_list_lock);
Sage Weila8599bd2009-10-06 11:31:12 -0700285}
286
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700287void ceph_reservation_status(struct ceph_fs_client *fsc,
Sage Weil85ccce42010-02-17 10:02:43 -0800288 int *total, int *avail, int *used, int *reserved,
289 int *min)
Sage Weila8599bd2009-10-06 11:31:12 -0700290{
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700291 struct ceph_mds_client *mdsc = fsc->mdsc;
Yehuda Sadeh37151662010-06-17 16:16:12 -0700292
Sage Weila8599bd2009-10-06 11:31:12 -0700293 if (total)
Yehuda Sadeh37151662010-06-17 16:16:12 -0700294 *total = mdsc->caps_total_count;
Sage Weila8599bd2009-10-06 11:31:12 -0700295 if (avail)
Yehuda Sadeh37151662010-06-17 16:16:12 -0700296 *avail = mdsc->caps_avail_count;
Sage Weila8599bd2009-10-06 11:31:12 -0700297 if (used)
Yehuda Sadeh37151662010-06-17 16:16:12 -0700298 *used = mdsc->caps_use_count;
Sage Weila8599bd2009-10-06 11:31:12 -0700299 if (reserved)
Yehuda Sadeh37151662010-06-17 16:16:12 -0700300 *reserved = mdsc->caps_reserve_count;
Sage Weil85ccce42010-02-17 10:02:43 -0800301 if (min)
Yehuda Sadeh37151662010-06-17 16:16:12 -0700302 *min = mdsc->caps_min_count;
Sage Weila8599bd2009-10-06 11:31:12 -0700303}
304
305/*
306 * Find ceph_cap for given mds, if any.
307 *
Sage Weilbe655592011-11-30 09:47:09 -0800308 * Called with i_ceph_lock held.
Sage Weila8599bd2009-10-06 11:31:12 -0700309 */
310static struct ceph_cap *__get_cap_for_mds(struct ceph_inode_info *ci, int mds)
311{
312 struct ceph_cap *cap;
313 struct rb_node *n = ci->i_caps.rb_node;
314
315 while (n) {
316 cap = rb_entry(n, struct ceph_cap, ci_node);
317 if (mds < cap->mds)
318 n = n->rb_left;
319 else if (mds > cap->mds)
320 n = n->rb_right;
321 else
322 return cap;
323 }
324 return NULL;
325}
326
Greg Farnum2bc50252010-06-30 12:44:34 -0700327struct ceph_cap *ceph_get_cap_for_mds(struct ceph_inode_info *ci, int mds)
328{
329 struct ceph_cap *cap;
330
Sage Weilbe655592011-11-30 09:47:09 -0800331 spin_lock(&ci->i_ceph_lock);
Greg Farnum2bc50252010-06-30 12:44:34 -0700332 cap = __get_cap_for_mds(ci, mds);
Sage Weilbe655592011-11-30 09:47:09 -0800333 spin_unlock(&ci->i_ceph_lock);
Greg Farnum2bc50252010-06-30 12:44:34 -0700334 return cap;
335}
336
Sage Weila8599bd2009-10-06 11:31:12 -0700337/*
Sage Weil33caad32010-05-26 14:31:27 -0700338 * Return id of any MDS with a cap, preferably FILE_WR|BUFFER|EXCL, else -1.
Sage Weila8599bd2009-10-06 11:31:12 -0700339 */
Sage Weilca81f3f2010-06-10 14:21:36 -0700340static int __ceph_get_cap_mds(struct ceph_inode_info *ci)
Sage Weila8599bd2009-10-06 11:31:12 -0700341{
342 struct ceph_cap *cap;
343 int mds = -1;
344 struct rb_node *p;
345
Sage Weil33caad32010-05-26 14:31:27 -0700346 /* prefer mds with WR|BUFFER|EXCL caps */
Sage Weila8599bd2009-10-06 11:31:12 -0700347 for (p = rb_first(&ci->i_caps); p; p = rb_next(p)) {
348 cap = rb_entry(p, struct ceph_cap, ci_node);
349 mds = cap->mds;
Sage Weila8599bd2009-10-06 11:31:12 -0700350 if (cap->issued & (CEPH_CAP_FILE_WR |
351 CEPH_CAP_FILE_BUFFER |
352 CEPH_CAP_FILE_EXCL))
353 break;
354 }
355 return mds;
356}
357
358int ceph_get_cap_mds(struct inode *inode)
359{
Sage Weilbe655592011-11-30 09:47:09 -0800360 struct ceph_inode_info *ci = ceph_inode(inode);
Sage Weila8599bd2009-10-06 11:31:12 -0700361 int mds;
Sage Weilbe655592011-11-30 09:47:09 -0800362 spin_lock(&ci->i_ceph_lock);
Sage Weilca81f3f2010-06-10 14:21:36 -0700363 mds = __ceph_get_cap_mds(ceph_inode(inode));
Sage Weilbe655592011-11-30 09:47:09 -0800364 spin_unlock(&ci->i_ceph_lock);
Sage Weila8599bd2009-10-06 11:31:12 -0700365 return mds;
366}
367
368/*
Sage Weilbe655592011-11-30 09:47:09 -0800369 * Called under i_ceph_lock.
Sage Weila8599bd2009-10-06 11:31:12 -0700370 */
371static void __insert_cap_node(struct ceph_inode_info *ci,
372 struct ceph_cap *new)
373{
374 struct rb_node **p = &ci->i_caps.rb_node;
375 struct rb_node *parent = NULL;
376 struct ceph_cap *cap = NULL;
377
378 while (*p) {
379 parent = *p;
380 cap = rb_entry(parent, struct ceph_cap, ci_node);
381 if (new->mds < cap->mds)
382 p = &(*p)->rb_left;
383 else if (new->mds > cap->mds)
384 p = &(*p)->rb_right;
385 else
386 BUG();
387 }
388
389 rb_link_node(&new->ci_node, parent, p);
390 rb_insert_color(&new->ci_node, &ci->i_caps);
391}
392
393/*
394 * (re)set cap hold timeouts, which control the delayed release
395 * of unused caps back to the MDS. Should be called on cap use.
396 */
397static void __cap_set_timeouts(struct ceph_mds_client *mdsc,
398 struct ceph_inode_info *ci)
399{
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700400 struct ceph_mount_options *ma = mdsc->fsc->mount_options;
Sage Weila8599bd2009-10-06 11:31:12 -0700401
402 ci->i_hold_caps_min = round_jiffies(jiffies +
403 ma->caps_wanted_delay_min * HZ);
404 ci->i_hold_caps_max = round_jiffies(jiffies +
405 ma->caps_wanted_delay_max * HZ);
406 dout("__cap_set_timeouts %p min %lu max %lu\n", &ci->vfs_inode,
407 ci->i_hold_caps_min - jiffies, ci->i_hold_caps_max - jiffies);
408}
409
410/*
411 * (Re)queue cap at the end of the delayed cap release list.
412 *
413 * If I_FLUSH is set, leave the inode at the front of the list.
414 *
Sage Weilbe655592011-11-30 09:47:09 -0800415 * Caller holds i_ceph_lock
Sage Weila8599bd2009-10-06 11:31:12 -0700416 * -> we take mdsc->cap_delay_lock
417 */
418static void __cap_delay_requeue(struct ceph_mds_client *mdsc,
419 struct ceph_inode_info *ci)
420{
421 __cap_set_timeouts(mdsc, ci);
422 dout("__cap_delay_requeue %p flags %d at %lu\n", &ci->vfs_inode,
423 ci->i_ceph_flags, ci->i_hold_caps_max);
424 if (!mdsc->stopping) {
425 spin_lock(&mdsc->cap_delay_lock);
426 if (!list_empty(&ci->i_cap_delay_list)) {
427 if (ci->i_ceph_flags & CEPH_I_FLUSH)
428 goto no_change;
429 list_del_init(&ci->i_cap_delay_list);
430 }
431 list_add_tail(&ci->i_cap_delay_list, &mdsc->cap_delay_list);
432no_change:
433 spin_unlock(&mdsc->cap_delay_lock);
434 }
435}
436
437/*
438 * Queue an inode for immediate writeback. Mark inode with I_FLUSH,
439 * indicating we should send a cap message to flush dirty metadata
440 * asap, and move to the front of the delayed cap list.
441 */
442static void __cap_delay_requeue_front(struct ceph_mds_client *mdsc,
443 struct ceph_inode_info *ci)
444{
445 dout("__cap_delay_requeue_front %p\n", &ci->vfs_inode);
446 spin_lock(&mdsc->cap_delay_lock);
447 ci->i_ceph_flags |= CEPH_I_FLUSH;
448 if (!list_empty(&ci->i_cap_delay_list))
449 list_del_init(&ci->i_cap_delay_list);
450 list_add(&ci->i_cap_delay_list, &mdsc->cap_delay_list);
451 spin_unlock(&mdsc->cap_delay_lock);
452}
453
454/*
455 * Cancel delayed work on cap.
456 *
Sage Weilbe655592011-11-30 09:47:09 -0800457 * Caller must hold i_ceph_lock.
Sage Weila8599bd2009-10-06 11:31:12 -0700458 */
459static void __cap_delay_cancel(struct ceph_mds_client *mdsc,
460 struct ceph_inode_info *ci)
461{
462 dout("__cap_delay_cancel %p\n", &ci->vfs_inode);
463 if (list_empty(&ci->i_cap_delay_list))
464 return;
465 spin_lock(&mdsc->cap_delay_lock);
466 list_del_init(&ci->i_cap_delay_list);
467 spin_unlock(&mdsc->cap_delay_lock);
468}
469
470/*
471 * Common issue checks for add_cap, handle_cap_grant.
472 */
473static void __check_cap_issue(struct ceph_inode_info *ci, struct ceph_cap *cap,
474 unsigned issued)
475{
476 unsigned had = __ceph_caps_issued(ci, NULL);
477
478 /*
479 * Each time we receive FILE_CACHE anew, we increment
480 * i_rdcache_gen.
481 */
Sage Weil29625072010-05-27 10:40:43 -0700482 if ((issued & (CEPH_CAP_FILE_CACHE|CEPH_CAP_FILE_LAZYIO)) &&
Milosz Tanski99ccbd22013-08-21 17:29:54 -0400483 (had & (CEPH_CAP_FILE_CACHE|CEPH_CAP_FILE_LAZYIO)) == 0) {
Sage Weila8599bd2009-10-06 11:31:12 -0700484 ci->i_rdcache_gen++;
Milosz Tanski99ccbd22013-08-21 17:29:54 -0400485 }
Sage Weila8599bd2009-10-06 11:31:12 -0700486
487 /*
Yan, Zheng2f276c52013-03-13 19:44:32 +0800488 * if we are newly issued FILE_SHARED, mark dir not complete; we
Sage Weila8599bd2009-10-06 11:31:12 -0700489 * don't know what happened to this directory while we didn't
490 * have the cap.
491 */
492 if ((issued & CEPH_CAP_FILE_SHARED) &&
493 (had & CEPH_CAP_FILE_SHARED) == 0) {
494 ci->i_shared_gen++;
Yan, Zhenga8673d62013-02-18 16:38:14 +0800495 if (S_ISDIR(ci->vfs_inode.i_mode)) {
496 dout(" marking %p NOT complete\n", &ci->vfs_inode);
Yan, Zheng2f276c52013-03-13 19:44:32 +0800497 __ceph_dir_clear_complete(ci);
Yan, Zhenga8673d62013-02-18 16:38:14 +0800498 }
Sage Weila8599bd2009-10-06 11:31:12 -0700499 }
500}
501
502/*
503 * Add a capability under the given MDS session.
504 *
505 * Caller should hold session snap_rwsem (read) and s_mutex.
506 *
507 * @fmode is the open file mode, if we are opening a file, otherwise
508 * it is < 0. (This is so we can atomically add the cap and add an
509 * open file reference to it.)
510 */
Yan, Zhengd9df2782014-04-18 09:57:11 +0800511void ceph_add_cap(struct inode *inode,
512 struct ceph_mds_session *session, u64 cap_id,
513 int fmode, unsigned issued, unsigned wanted,
514 unsigned seq, unsigned mseq, u64 realmino, int flags,
515 struct ceph_cap **new_cap)
Sage Weila8599bd2009-10-06 11:31:12 -0700516{
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700517 struct ceph_mds_client *mdsc = ceph_inode_to_client(inode)->mdsc;
Sage Weila8599bd2009-10-06 11:31:12 -0700518 struct ceph_inode_info *ci = ceph_inode(inode);
Sage Weila8599bd2009-10-06 11:31:12 -0700519 struct ceph_cap *cap;
520 int mds = session->s_mds;
521 int actual_wanted;
522
523 dout("add_cap %p mds%d cap %llx %s seq %d\n", inode,
524 session->s_mds, cap_id, ceph_cap_string(issued), seq);
525
526 /*
527 * If we are opening the file, include file mode wanted bits
528 * in wanted.
529 */
530 if (fmode >= 0)
531 wanted |= ceph_caps_for_mode(fmode);
532
Sage Weila8599bd2009-10-06 11:31:12 -0700533 cap = __get_cap_for_mds(ci, mds);
534 if (!cap) {
Yan, Zhengd9df2782014-04-18 09:57:11 +0800535 cap = *new_cap;
536 *new_cap = NULL;
Sage Weila8599bd2009-10-06 11:31:12 -0700537
538 cap->issued = 0;
539 cap->implemented = 0;
540 cap->mds = mds;
541 cap->mds_wanted = 0;
Yan, Zheng964266c2013-02-27 09:26:09 +0800542 cap->mseq = 0;
Sage Weila8599bd2009-10-06 11:31:12 -0700543
544 cap->ci = ci;
545 __insert_cap_node(ci, cap);
546
Sage Weila8599bd2009-10-06 11:31:12 -0700547 /* add to session cap list */
548 cap->session = session;
549 spin_lock(&session->s_cap_lock);
550 list_add_tail(&cap->session_caps, &session->s_caps);
551 session->s_nr_caps++;
552 spin_unlock(&session->s_cap_lock);
Yan, Zheng11df2df2013-11-24 14:44:38 +0800553 } else {
Yan, Zheng11df2df2013-11-24 14:44:38 +0800554 /*
555 * auth mds of the inode changed. we received the cap export
556 * message, but still haven't received the cap import message.
557 * handle_cap_export() updated the new auth MDS' cap.
558 *
559 * "ceph_seq_cmp(seq, cap->seq) <= 0" means we are processing
560 * a message that was send before the cap import message. So
561 * don't remove caps.
562 */
563 if (ceph_seq_cmp(seq, cap->seq) <= 0) {
564 WARN_ON(cap != ci->i_auth_cap);
565 WARN_ON(cap->cap_id != cap_id);
566 seq = cap->seq;
567 mseq = cap->mseq;
568 issued |= cap->issued;
569 flags |= CEPH_CAP_FLAG_AUTH;
570 }
571 }
Sage Weila8599bd2009-10-06 11:31:12 -0700572
573 if (!ci->i_snap_realm) {
574 /*
575 * add this inode to the appropriate snap realm
576 */
577 struct ceph_snap_realm *realm = ceph_lookup_snap_realm(mdsc,
578 realmino);
579 if (realm) {
Sage Weila8599bd2009-10-06 11:31:12 -0700580 spin_lock(&realm->inodes_with_caps_lock);
581 ci->i_snap_realm = realm;
582 list_add(&ci->i_snap_realm_item,
583 &realm->inodes_with_caps);
584 spin_unlock(&realm->inodes_with_caps_lock);
585 } else {
586 pr_err("ceph_add_cap: couldn't find snap realm %llx\n",
587 realmino);
Sage Weilb8cd07e2010-07-16 12:00:02 -0700588 WARN_ON(!realm);
Sage Weila8599bd2009-10-06 11:31:12 -0700589 }
590 }
591
592 __check_cap_issue(ci, cap, issued);
593
594 /*
595 * If we are issued caps we don't want, or the mds' wanted
596 * value appears to be off, queue a check so we'll release
597 * later and/or update the mds wanted value.
598 */
599 actual_wanted = __ceph_caps_wanted(ci);
600 if ((wanted & ~actual_wanted) ||
601 (issued & ~actual_wanted & CEPH_CAP_ANY_WR)) {
602 dout(" issued %s, mds wanted %s, actual %s, queueing\n",
603 ceph_cap_string(issued), ceph_cap_string(wanted),
604 ceph_cap_string(actual_wanted));
605 __cap_delay_requeue(mdsc, ci);
606 }
607
Yan, Zhengb8c2f3a2013-05-31 16:37:11 +0800608 if (flags & CEPH_CAP_FLAG_AUTH) {
609 if (ci->i_auth_cap == NULL ||
Yan, Zhengd9ffc4f2014-03-18 10:15:29 +0800610 ceph_seq_cmp(ci->i_auth_cap->mseq, mseq) < 0) {
Yan, Zhengb8c2f3a2013-05-31 16:37:11 +0800611 ci->i_auth_cap = cap;
Yan, Zhengd9ffc4f2014-03-18 10:15:29 +0800612 cap->mds_wanted = wanted;
613 }
Yan, Zheng11df2df2013-11-24 14:44:38 +0800614 } else {
615 WARN_ON(ci->i_auth_cap == cap);
Yan, Zheng8a92a112013-01-04 14:28:07 +0800616 }
Sage Weila8599bd2009-10-06 11:31:12 -0700617
618 dout("add_cap inode %p (%llx.%llx) cap %p %s now %s seq %d mds%d\n",
619 inode, ceph_vinop(inode), cap, ceph_cap_string(issued),
620 ceph_cap_string(issued|cap->issued), seq, mds);
621 cap->cap_id = cap_id;
622 cap->issued = issued;
623 cap->implemented |= issued;
Yan, Zhengd1b87802013-11-13 14:47:19 +0800624 if (ceph_seq_cmp(mseq, cap->mseq) > 0)
Yan, Zheng964266c2013-02-27 09:26:09 +0800625 cap->mds_wanted = wanted;
626 else
627 cap->mds_wanted |= wanted;
Sage Weila8599bd2009-10-06 11:31:12 -0700628 cap->seq = seq;
629 cap->issue_seq = seq;
630 cap->mseq = mseq;
Sage Weil685f9a5d2009-11-09 12:05:48 -0800631 cap->cap_gen = session->s_cap_gen;
Sage Weila8599bd2009-10-06 11:31:12 -0700632
633 if (fmode >= 0)
634 __ceph_get_fmode(ci, fmode);
Sage Weila8599bd2009-10-06 11:31:12 -0700635}
636
637/*
638 * Return true if cap has not timed out and belongs to the current
639 * generation of the MDS session (i.e. has not gone 'stale' due to
640 * us losing touch with the mds).
641 */
642static int __cap_is_valid(struct ceph_cap *cap)
643{
644 unsigned long ttl;
Sage Weilcdac8302009-11-10 16:02:23 -0800645 u32 gen;
Sage Weila8599bd2009-10-06 11:31:12 -0700646
Alex Elderd8fb02a2012-01-12 17:48:10 -0800647 spin_lock(&cap->session->s_gen_ttl_lock);
Sage Weila8599bd2009-10-06 11:31:12 -0700648 gen = cap->session->s_cap_gen;
649 ttl = cap->session->s_cap_ttl;
Alex Elderd8fb02a2012-01-12 17:48:10 -0800650 spin_unlock(&cap->session->s_gen_ttl_lock);
Sage Weila8599bd2009-10-06 11:31:12 -0700651
Sage Weil685f9a5d2009-11-09 12:05:48 -0800652 if (cap->cap_gen < gen || time_after_eq(jiffies, ttl)) {
Sage Weila8599bd2009-10-06 11:31:12 -0700653 dout("__cap_is_valid %p cap %p issued %s "
654 "but STALE (gen %u vs %u)\n", &cap->ci->vfs_inode,
Sage Weil685f9a5d2009-11-09 12:05:48 -0800655 cap, ceph_cap_string(cap->issued), cap->cap_gen, gen);
Sage Weila8599bd2009-10-06 11:31:12 -0700656 return 0;
657 }
658
659 return 1;
660}
661
662/*
663 * Return set of valid cap bits issued to us. Note that caps time
664 * out, and may be invalidated in bulk if the client session times out
665 * and session->s_cap_gen is bumped.
666 */
667int __ceph_caps_issued(struct ceph_inode_info *ci, int *implemented)
668{
Yan, Zhengd9df2782014-04-18 09:57:11 +0800669 int have = ci->i_snap_caps;
Sage Weila8599bd2009-10-06 11:31:12 -0700670 struct ceph_cap *cap;
671 struct rb_node *p;
672
673 if (implemented)
674 *implemented = 0;
675 for (p = rb_first(&ci->i_caps); p; p = rb_next(p)) {
676 cap = rb_entry(p, struct ceph_cap, ci_node);
677 if (!__cap_is_valid(cap))
678 continue;
679 dout("__ceph_caps_issued %p cap %p issued %s\n",
680 &ci->vfs_inode, cap, ceph_cap_string(cap->issued));
681 have |= cap->issued;
682 if (implemented)
683 *implemented |= cap->implemented;
684 }
Yan, Zhengb1530f52013-07-02 12:40:20 +0800685 /*
686 * exclude caps issued by non-auth MDS, but are been revoking
687 * by the auth MDS. The non-auth MDS should be revoking/exporting
688 * these caps, but the message is delayed.
689 */
690 if (ci->i_auth_cap) {
691 cap = ci->i_auth_cap;
692 have &= ~cap->implemented | cap->issued;
693 }
Sage Weila8599bd2009-10-06 11:31:12 -0700694 return have;
695}
696
697/*
698 * Get cap bits issued by caps other than @ocap
699 */
700int __ceph_caps_issued_other(struct ceph_inode_info *ci, struct ceph_cap *ocap)
701{
702 int have = ci->i_snap_caps;
703 struct ceph_cap *cap;
704 struct rb_node *p;
705
706 for (p = rb_first(&ci->i_caps); p; p = rb_next(p)) {
707 cap = rb_entry(p, struct ceph_cap, ci_node);
708 if (cap == ocap)
709 continue;
710 if (!__cap_is_valid(cap))
711 continue;
712 have |= cap->issued;
713 }
714 return have;
715}
716
717/*
718 * Move a cap to the end of the LRU (oldest caps at list head, newest
719 * at list tail).
720 */
721static void __touch_cap(struct ceph_cap *cap)
722{
723 struct ceph_mds_session *s = cap->session;
724
Sage Weila8599bd2009-10-06 11:31:12 -0700725 spin_lock(&s->s_cap_lock);
Sage Weil7c1332b2010-02-16 11:39:45 -0800726 if (s->s_cap_iterator == NULL) {
Sage Weil5dacf092009-12-21 20:40:34 -0800727 dout("__touch_cap %p cap %p mds%d\n", &cap->ci->vfs_inode, cap,
728 s->s_mds);
729 list_move_tail(&cap->session_caps, &s->s_caps);
730 } else {
731 dout("__touch_cap %p cap %p mds%d NOP, iterating over caps\n",
732 &cap->ci->vfs_inode, cap, s->s_mds);
733 }
Sage Weila8599bd2009-10-06 11:31:12 -0700734 spin_unlock(&s->s_cap_lock);
735}
736
737/*
738 * Check if we hold the given mask. If so, move the cap(s) to the
739 * front of their respective LRUs. (This is the preferred way for
740 * callers to check for caps they want.)
741 */
742int __ceph_caps_issued_mask(struct ceph_inode_info *ci, int mask, int touch)
743{
744 struct ceph_cap *cap;
745 struct rb_node *p;
746 int have = ci->i_snap_caps;
747
748 if ((have & mask) == mask) {
749 dout("__ceph_caps_issued_mask %p snap issued %s"
750 " (mask %s)\n", &ci->vfs_inode,
751 ceph_cap_string(have),
752 ceph_cap_string(mask));
753 return 1;
754 }
755
756 for (p = rb_first(&ci->i_caps); p; p = rb_next(p)) {
757 cap = rb_entry(p, struct ceph_cap, ci_node);
758 if (!__cap_is_valid(cap))
759 continue;
760 if ((cap->issued & mask) == mask) {
761 dout("__ceph_caps_issued_mask %p cap %p issued %s"
762 " (mask %s)\n", &ci->vfs_inode, cap,
763 ceph_cap_string(cap->issued),
764 ceph_cap_string(mask));
765 if (touch)
766 __touch_cap(cap);
767 return 1;
768 }
769
770 /* does a combination of caps satisfy mask? */
771 have |= cap->issued;
772 if ((have & mask) == mask) {
773 dout("__ceph_caps_issued_mask %p combo issued %s"
774 " (mask %s)\n", &ci->vfs_inode,
775 ceph_cap_string(cap->issued),
776 ceph_cap_string(mask));
777 if (touch) {
778 struct rb_node *q;
779
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300780 /* touch this + preceding caps */
Sage Weila8599bd2009-10-06 11:31:12 -0700781 __touch_cap(cap);
782 for (q = rb_first(&ci->i_caps); q != p;
783 q = rb_next(q)) {
784 cap = rb_entry(q, struct ceph_cap,
785 ci_node);
786 if (!__cap_is_valid(cap))
787 continue;
788 __touch_cap(cap);
789 }
790 }
791 return 1;
792 }
793 }
794
795 return 0;
796}
797
798/*
799 * Return true if mask caps are currently being revoked by an MDS.
800 */
Yan, Zheng6ee6b9532013-07-02 12:40:21 +0800801int __ceph_caps_revoking_other(struct ceph_inode_info *ci,
802 struct ceph_cap *ocap, int mask)
803{
804 struct ceph_cap *cap;
805 struct rb_node *p;
806
807 for (p = rb_first(&ci->i_caps); p; p = rb_next(p)) {
808 cap = rb_entry(p, struct ceph_cap, ci_node);
Yan, Zheng9563f882013-11-22 13:50:45 +0800809 if (cap != ocap &&
Yan, Zheng6ee6b9532013-07-02 12:40:21 +0800810 (cap->implemented & ~cap->issued & mask))
811 return 1;
812 }
813 return 0;
814}
815
Sage Weila8599bd2009-10-06 11:31:12 -0700816int ceph_caps_revoking(struct ceph_inode_info *ci, int mask)
817{
818 struct inode *inode = &ci->vfs_inode;
Yan, Zheng6ee6b9532013-07-02 12:40:21 +0800819 int ret;
Sage Weila8599bd2009-10-06 11:31:12 -0700820
Sage Weilbe655592011-11-30 09:47:09 -0800821 spin_lock(&ci->i_ceph_lock);
Yan, Zheng6ee6b9532013-07-02 12:40:21 +0800822 ret = __ceph_caps_revoking_other(ci, NULL, mask);
Sage Weilbe655592011-11-30 09:47:09 -0800823 spin_unlock(&ci->i_ceph_lock);
Sage Weila8599bd2009-10-06 11:31:12 -0700824 dout("ceph_caps_revoking %p %s = %d\n", inode,
825 ceph_cap_string(mask), ret);
826 return ret;
827}
828
829int __ceph_caps_used(struct ceph_inode_info *ci)
830{
831 int used = 0;
832 if (ci->i_pin_ref)
833 used |= CEPH_CAP_PIN;
834 if (ci->i_rd_ref)
835 used |= CEPH_CAP_FILE_RD;
Yan, Zhengfdd4e152015-06-16 20:48:56 +0800836 if (ci->i_rdcache_ref ||
837 (!S_ISDIR(ci->vfs_inode.i_mode) && /* ignore readdir cache */
838 ci->vfs_inode.i_data.nrpages))
Sage Weila8599bd2009-10-06 11:31:12 -0700839 used |= CEPH_CAP_FILE_CACHE;
840 if (ci->i_wr_ref)
841 used |= CEPH_CAP_FILE_WR;
Henry C Changd3d07202011-05-11 10:29:54 +0000842 if (ci->i_wb_ref || ci->i_wrbuffer_ref)
Sage Weila8599bd2009-10-06 11:31:12 -0700843 used |= CEPH_CAP_FILE_BUFFER;
844 return used;
845}
846
847/*
848 * wanted, by virtue of open file modes
849 */
850int __ceph_caps_file_wanted(struct ceph_inode_info *ci)
851{
Yan, Zheng774a6a12016-06-06 16:01:39 +0800852 int i, bits = 0;
853 for (i = 0; i < CEPH_FILE_MODE_BITS; i++) {
854 if (ci->i_nr_by_mode[i])
855 bits |= 1 << i;
856 }
857 if (bits == 0)
858 return 0;
859 return ceph_caps_for_mode(bits >> 1);
Sage Weila8599bd2009-10-06 11:31:12 -0700860}
861
862/*
863 * Return caps we have registered with the MDS(s) as 'wanted'.
864 */
865int __ceph_caps_mds_wanted(struct ceph_inode_info *ci)
866{
867 struct ceph_cap *cap;
868 struct rb_node *p;
869 int mds_wanted = 0;
870
871 for (p = rb_first(&ci->i_caps); p; p = rb_next(p)) {
872 cap = rb_entry(p, struct ceph_cap, ci_node);
873 if (!__cap_is_valid(cap))
874 continue;
Yan, Zhenga2550602014-03-08 09:51:45 +0800875 if (cap == ci->i_auth_cap)
876 mds_wanted |= cap->mds_wanted;
877 else
878 mds_wanted |= (cap->mds_wanted & ~CEPH_CAP_ANY_FILE_WR);
Sage Weila8599bd2009-10-06 11:31:12 -0700879 }
880 return mds_wanted;
881}
882
883/*
Sage Weilbe655592011-11-30 09:47:09 -0800884 * called under i_ceph_lock
Sage Weila8599bd2009-10-06 11:31:12 -0700885 */
886static int __ceph_is_any_caps(struct ceph_inode_info *ci)
887{
Yan, Zhengd9df2782014-04-18 09:57:11 +0800888 return !RB_EMPTY_ROOT(&ci->i_caps);
Sage Weila8599bd2009-10-06 11:31:12 -0700889}
890
Yan, Zheng9215aee2013-11-30 12:47:41 +0800891int ceph_is_any_caps(struct inode *inode)
892{
893 struct ceph_inode_info *ci = ceph_inode(inode);
894 int ret;
895
896 spin_lock(&ci->i_ceph_lock);
897 ret = __ceph_is_any_caps(ci);
898 spin_unlock(&ci->i_ceph_lock);
899
900 return ret;
901}
902
Yan, Zhengdb40cc12015-03-23 20:12:20 +0800903static void drop_inode_snap_realm(struct ceph_inode_info *ci)
904{
905 struct ceph_snap_realm *realm = ci->i_snap_realm;
906 spin_lock(&realm->inodes_with_caps_lock);
907 list_del_init(&ci->i_snap_realm_item);
908 ci->i_snap_realm_counter++;
909 ci->i_snap_realm = NULL;
910 spin_unlock(&realm->inodes_with_caps_lock);
911 ceph_put_snap_realm(ceph_sb_to_client(ci->vfs_inode.i_sb)->mdsc,
912 realm);
913}
914
Sage Weila8599bd2009-10-06 11:31:12 -0700915/*
Sage Weilf818a732010-05-11 20:56:31 -0700916 * Remove a cap. Take steps to deal with a racing iterate_session_caps.
917 *
Sage Weilbe655592011-11-30 09:47:09 -0800918 * caller should hold i_ceph_lock.
Sage Weila6369742010-02-22 13:59:00 -0800919 * caller will not hold session s_mutex if called from destroy_inode.
Sage Weila8599bd2009-10-06 11:31:12 -0700920 */
Yan, Zhenga096b092013-09-22 10:15:58 +0800921void __ceph_remove_cap(struct ceph_cap *cap, bool queue_release)
Sage Weila8599bd2009-10-06 11:31:12 -0700922{
923 struct ceph_mds_session *session = cap->session;
924 struct ceph_inode_info *ci = cap->ci;
Cheng Renquan640ef792010-03-26 17:40:33 +0800925 struct ceph_mds_client *mdsc =
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -0700926 ceph_sb_to_client(ci->vfs_inode.i_sb)->mdsc;
Sage Weilf818a732010-05-11 20:56:31 -0700927 int removed = 0;
Sage Weila8599bd2009-10-06 11:31:12 -0700928
929 dout("__ceph_remove_cap %p from %p\n", cap, &ci->vfs_inode);
930
Sage Weil7c1332b2010-02-16 11:39:45 -0800931 /* remove from session list */
932 spin_lock(&session->s_cap_lock);
933 if (session->s_cap_iterator == cap) {
934 /* not yet, we are iterating over this very cap */
935 dout("__ceph_remove_cap delaying %p removal from session %p\n",
936 cap, cap->session);
937 } else {
938 list_del_init(&cap->session_caps);
939 session->s_nr_caps--;
940 cap->session = NULL;
Sage Weilf818a732010-05-11 20:56:31 -0700941 removed = 1;
Sage Weil7c1332b2010-02-16 11:39:45 -0800942 }
Sage Weilf818a732010-05-11 20:56:31 -0700943 /* protect backpointer with s_cap_lock: see iterate_session_caps */
944 cap->ci = NULL;
Yan, Zheng745a8e32015-05-14 17:22:42 +0800945
946 /*
947 * s_cap_reconnect is protected by s_cap_lock. no one changes
948 * s_cap_gen while session is in the reconnect state.
949 */
950 if (queue_release &&
951 (!session->s_cap_reconnect || cap->cap_gen == session->s_cap_gen)) {
952 cap->queue_release = 1;
953 if (removed) {
954 list_add_tail(&cap->session_caps,
955 &session->s_cap_releases);
956 session->s_num_cap_releases++;
957 removed = 0;
958 }
959 } else {
960 cap->queue_release = 0;
961 }
962 cap->cap_ino = ci->i_vino.ino;
963
Sage Weil7c1332b2010-02-16 11:39:45 -0800964 spin_unlock(&session->s_cap_lock);
965
Sage Weilf818a732010-05-11 20:56:31 -0700966 /* remove from inode list */
967 rb_erase(&cap->ci_node, &ci->i_caps);
968 if (ci->i_auth_cap == cap)
969 ci->i_auth_cap = NULL;
970
971 if (removed)
Yehuda Sadeh37151662010-06-17 16:16:12 -0700972 ceph_put_cap(mdsc, cap);
Sage Weila8599bd2009-10-06 11:31:12 -0700973
Yan, Zhengdb40cc12015-03-23 20:12:20 +0800974 /* when reconnect denied, we remove session caps forcibly,
975 * i_wr_ref can be non-zero. If there are ongoing write,
976 * keep i_snap_realm.
977 */
978 if (!__ceph_is_any_caps(ci) && ci->i_wr_ref == 0 && ci->i_snap_realm)
979 drop_inode_snap_realm(ci);
980
Sage Weila8599bd2009-10-06 11:31:12 -0700981 if (!__ceph_is_any_real_caps(ci))
982 __cap_delay_cancel(mdsc, ci);
983}
984
985/*
986 * Build and send a cap message to the given MDS.
987 *
988 * Caller should be holding s_mutex.
989 */
990static int send_cap_msg(struct ceph_mds_session *session,
991 u64 ino, u64 cid, int op,
992 int caps, int wanted, int dirty,
Yan, Zhenga2971c82015-06-10 11:09:32 +0800993 u32 seq, u64 flush_tid, u64 oldest_flush_tid,
994 u32 issue_seq, u32 mseq, u64 size, u64 max_size,
Sage Weila8599bd2009-10-06 11:31:12 -0700995 struct timespec *mtime, struct timespec *atime,
Yan, Zhengd1eee0c2016-01-22 18:30:12 +0800996 struct timespec *ctime, u64 time_warp_seq,
Eric W. Biederman05cb11c2013-01-31 02:56:19 -0800997 kuid_t uid, kgid_t gid, umode_t mode,
Sage Weila8599bd2009-10-06 11:31:12 -0700998 u64 xattr_version,
999 struct ceph_buffer *xattrs_buf,
Yan, Zhenge20d2582014-11-14 22:39:13 +08001000 u64 follows, bool inline_data)
Sage Weila8599bd2009-10-06 11:31:12 -07001001{
1002 struct ceph_mds_caps *fc;
1003 struct ceph_msg *msg;
Yan, Zhenge20d2582014-11-14 22:39:13 +08001004 void *p;
1005 size_t extra_len;
Sage Weila8599bd2009-10-06 11:31:12 -07001006
1007 dout("send_cap_msg %s %llx %llx caps %s wanted %s dirty %s"
Yan, Zhenga2971c82015-06-10 11:09:32 +08001008 " seq %u/%u tid %llu/%llu mseq %u follows %lld size %llu/%llu"
Sage Weila8599bd2009-10-06 11:31:12 -07001009 " xattr_ver %llu xattr_len %d\n", ceph_cap_op_name(op),
1010 cid, ino, ceph_cap_string(caps), ceph_cap_string(wanted),
1011 ceph_cap_string(dirty),
Yan, Zhenga2971c82015-06-10 11:09:32 +08001012 seq, issue_seq, flush_tid, oldest_flush_tid,
1013 mseq, follows, size, max_size,
Sage Weila8599bd2009-10-06 11:31:12 -07001014 xattr_version, xattrs_buf ? (int)xattrs_buf->vec.iov_len : 0);
1015
Yan, Zhenga2971c82015-06-10 11:09:32 +08001016 /* flock buffer size + inline version + inline data size +
1017 * osd_epoch_barrier + oldest_flush_tid */
1018 extra_len = 4 + 8 + 4 + 4 + 8;
Yan, Zhenge20d2582014-11-14 22:39:13 +08001019 msg = ceph_msg_new(CEPH_MSG_CLIENT_CAPS, sizeof(*fc) + extra_len,
1020 GFP_NOFS, false);
Sage Weila79832f2010-04-01 16:06:19 -07001021 if (!msg)
1022 return -ENOMEM;
Sage Weila8599bd2009-10-06 11:31:12 -07001023
Yan, Zhenga2971c82015-06-10 11:09:32 +08001024 msg->hdr.version = cpu_to_le16(6);
Sage Weil6df058c2009-12-22 11:24:33 -08001025 msg->hdr.tid = cpu_to_le64(flush_tid);
Sage Weila8599bd2009-10-06 11:31:12 -07001026
Sage Weil6df058c2009-12-22 11:24:33 -08001027 fc = msg->front.iov_base;
Sage Weila8599bd2009-10-06 11:31:12 -07001028 memset(fc, 0, sizeof(*fc));
1029
1030 fc->cap_id = cpu_to_le64(cid);
1031 fc->op = cpu_to_le32(op);
1032 fc->seq = cpu_to_le32(seq);
Sage Weila8599bd2009-10-06 11:31:12 -07001033 fc->issue_seq = cpu_to_le32(issue_seq);
1034 fc->migrate_seq = cpu_to_le32(mseq);
1035 fc->caps = cpu_to_le32(caps);
1036 fc->wanted = cpu_to_le32(wanted);
1037 fc->dirty = cpu_to_le32(dirty);
1038 fc->ino = cpu_to_le64(ino);
1039 fc->snap_follows = cpu_to_le64(follows);
1040
1041 fc->size = cpu_to_le64(size);
1042 fc->max_size = cpu_to_le64(max_size);
1043 if (mtime)
1044 ceph_encode_timespec(&fc->mtime, mtime);
1045 if (atime)
1046 ceph_encode_timespec(&fc->atime, atime);
Yan, Zhengd1eee0c2016-01-22 18:30:12 +08001047 if (ctime)
1048 ceph_encode_timespec(&fc->ctime, ctime);
Sage Weila8599bd2009-10-06 11:31:12 -07001049 fc->time_warp_seq = cpu_to_le32(time_warp_seq);
1050
Eric W. Biederman05cb11c2013-01-31 02:56:19 -08001051 fc->uid = cpu_to_le32(from_kuid(&init_user_ns, uid));
1052 fc->gid = cpu_to_le32(from_kgid(&init_user_ns, gid));
Sage Weila8599bd2009-10-06 11:31:12 -07001053 fc->mode = cpu_to_le32(mode);
1054
Yan, Zhenge20d2582014-11-14 22:39:13 +08001055 p = fc + 1;
1056 /* flock buffer size */
1057 ceph_encode_32(&p, 0);
1058 /* inline version */
1059 ceph_encode_64(&p, inline_data ? 0 : CEPH_INLINE_NONE);
1060 /* inline data size */
1061 ceph_encode_32(&p, 0);
Yan, Zhenga2971c82015-06-10 11:09:32 +08001062 /* osd_epoch_barrier */
1063 ceph_encode_32(&p, 0);
1064 /* oldest_flush_tid */
1065 ceph_encode_64(&p, oldest_flush_tid);
Yan, Zhenge20d2582014-11-14 22:39:13 +08001066
Sage Weila8599bd2009-10-06 11:31:12 -07001067 fc->xattr_version = cpu_to_le64(xattr_version);
1068 if (xattrs_buf) {
1069 msg->middle = ceph_buffer_get(xattrs_buf);
1070 fc->xattr_len = cpu_to_le32(xattrs_buf->vec.iov_len);
1071 msg->hdr.middle_len = cpu_to_le32(xattrs_buf->vec.iov_len);
1072 }
1073
1074 ceph_con_send(&session->s_con, msg);
1075 return 0;
1076}
1077
1078/*
Sage Weila6369742010-02-22 13:59:00 -08001079 * Queue cap releases when an inode is dropped from our cache. Since
Sage Weilbe655592011-11-30 09:47:09 -08001080 * inode is about to be destroyed, there is no need for i_ceph_lock.
Sage Weila8599bd2009-10-06 11:31:12 -07001081 */
1082void ceph_queue_caps_release(struct inode *inode)
1083{
1084 struct ceph_inode_info *ci = ceph_inode(inode);
1085 struct rb_node *p;
1086
Sage Weila8599bd2009-10-06 11:31:12 -07001087 p = rb_first(&ci->i_caps);
1088 while (p) {
1089 struct ceph_cap *cap = rb_entry(p, struct ceph_cap, ci_node);
Sage Weila8599bd2009-10-06 11:31:12 -07001090 p = rb_next(p);
Yan, Zhenga096b092013-09-22 10:15:58 +08001091 __ceph_remove_cap(cap, true);
Sage Weila8599bd2009-10-06 11:31:12 -07001092 }
Sage Weila8599bd2009-10-06 11:31:12 -07001093}
1094
1095/*
1096 * Send a cap msg on the given inode. Update our caps state, then
Sage Weilbe655592011-11-30 09:47:09 -08001097 * drop i_ceph_lock and send the message.
Sage Weila8599bd2009-10-06 11:31:12 -07001098 *
1099 * Make note of max_size reported/requested from mds, revoked caps
1100 * that have now been implemented.
1101 *
1102 * Make half-hearted attempt ot to invalidate page cache if we are
1103 * dropping RDCACHE. Note that this will leave behind locked pages
1104 * that we'll then need to deal with elsewhere.
1105 *
1106 * Return non-zero if delayed release, or we experienced an error
1107 * such that the caller should requeue + retry later.
1108 *
Sage Weilbe655592011-11-30 09:47:09 -08001109 * called with i_ceph_lock, then drops it.
Sage Weila8599bd2009-10-06 11:31:12 -07001110 * caller should hold snap_rwsem (read), s_mutex.
1111 */
1112static int __send_cap(struct ceph_mds_client *mdsc, struct ceph_cap *cap,
Yan, Zheng553adfd2015-06-09 15:48:57 +08001113 int op, int used, int want, int retain, int flushing,
Yan, Zhenga2971c82015-06-10 11:09:32 +08001114 u64 flush_tid, u64 oldest_flush_tid)
Sage Weilbe655592011-11-30 09:47:09 -08001115 __releases(cap->ci->i_ceph_lock)
Sage Weila8599bd2009-10-06 11:31:12 -07001116{
1117 struct ceph_inode_info *ci = cap->ci;
1118 struct inode *inode = &ci->vfs_inode;
1119 u64 cap_id = cap->cap_id;
Sage Weil68c28322010-02-09 13:41:47 -08001120 int held, revoking, dropping, keep;
Sage Weila8599bd2009-10-06 11:31:12 -07001121 u64 seq, issue_seq, mseq, time_warp_seq, follows;
1122 u64 size, max_size;
Yan, Zhengd1eee0c2016-01-22 18:30:12 +08001123 struct timespec mtime, atime, ctime;
Sage Weila8599bd2009-10-06 11:31:12 -07001124 int wake = 0;
Al Viro5706b272011-07-26 04:52:22 -04001125 umode_t mode;
Eric W. Biederman05cb11c2013-01-31 02:56:19 -08001126 kuid_t uid;
1127 kgid_t gid;
Sage Weila8599bd2009-10-06 11:31:12 -07001128 struct ceph_mds_session *session;
1129 u64 xattr_version = 0;
Sage Weil082afec2010-08-22 15:16:41 -07001130 struct ceph_buffer *xattr_blob = NULL;
Sage Weila8599bd2009-10-06 11:31:12 -07001131 int delayed = 0;
Sage Weila8599bd2009-10-06 11:31:12 -07001132 int ret;
Yan, Zhenge20d2582014-11-14 22:39:13 +08001133 bool inline_data;
Sage Weila8599bd2009-10-06 11:31:12 -07001134
Sage Weil68c28322010-02-09 13:41:47 -08001135 held = cap->issued | cap->implemented;
1136 revoking = cap->implemented & ~cap->issued;
1137 retain &= ~revoking;
1138 dropping = cap->issued & ~retain;
1139
Sage Weila8599bd2009-10-06 11:31:12 -07001140 dout("__send_cap %p cap %p session %p %s -> %s (revoking %s)\n",
1141 inode, cap, cap->session,
1142 ceph_cap_string(held), ceph_cap_string(held & retain),
1143 ceph_cap_string(revoking));
1144 BUG_ON((retain & CEPH_CAP_PIN) == 0);
1145
1146 session = cap->session;
1147
1148 /* don't release wanted unless we've waited a bit. */
1149 if ((ci->i_ceph_flags & CEPH_I_NODELAY) == 0 &&
1150 time_before(jiffies, ci->i_hold_caps_min)) {
1151 dout(" delaying issued %s -> %s, wanted %s -> %s on send\n",
1152 ceph_cap_string(cap->issued),
1153 ceph_cap_string(cap->issued & retain),
1154 ceph_cap_string(cap->mds_wanted),
1155 ceph_cap_string(want));
1156 want |= cap->mds_wanted;
1157 retain |= cap->issued;
1158 delayed = 1;
1159 }
1160 ci->i_ceph_flags &= ~(CEPH_I_NODELAY | CEPH_I_FLUSH);
1161
1162 cap->issued &= retain; /* drop bits we don't want */
1163 if (cap->implemented & ~cap->issued) {
1164 /*
1165 * Wake up any waiters on wanted -> needed transition.
1166 * This is due to the weird transition from buffered
1167 * to sync IO... we need to flush dirty pages _before_
1168 * allowing sync writes to avoid reordering.
1169 */
1170 wake = 1;
1171 }
1172 cap->implemented &= cap->issued | used;
1173 cap->mds_wanted = want;
1174
Yan, Zheng553adfd2015-06-09 15:48:57 +08001175 follows = flushing ? ci->i_head_snapc->seq : 0;
Sage Weila8599bd2009-10-06 11:31:12 -07001176
1177 keep = cap->implemented;
1178 seq = cap->seq;
1179 issue_seq = cap->issue_seq;
1180 mseq = cap->mseq;
1181 size = inode->i_size;
1182 ci->i_reported_size = size;
1183 max_size = ci->i_wanted_max_size;
1184 ci->i_requested_max_size = max_size;
1185 mtime = inode->i_mtime;
1186 atime = inode->i_atime;
Yan, Zhengd1eee0c2016-01-22 18:30:12 +08001187 ctime = inode->i_ctime;
Sage Weila8599bd2009-10-06 11:31:12 -07001188 time_warp_seq = ci->i_time_warp_seq;
Sage Weila8599bd2009-10-06 11:31:12 -07001189 uid = inode->i_uid;
1190 gid = inode->i_gid;
1191 mode = inode->i_mode;
1192
Sage Weil082afec2010-08-22 15:16:41 -07001193 if (flushing & CEPH_CAP_XATTR_EXCL) {
Sage Weila8599bd2009-10-06 11:31:12 -07001194 __ceph_build_xattrs_blob(ci);
Sage Weil082afec2010-08-22 15:16:41 -07001195 xattr_blob = ci->i_xattrs.blob;
1196 xattr_version = ci->i_xattrs.version;
Sage Weila8599bd2009-10-06 11:31:12 -07001197 }
1198
Yan, Zhenge20d2582014-11-14 22:39:13 +08001199 inline_data = ci->i_inline_version != CEPH_INLINE_NONE;
1200
Sage Weilbe655592011-11-30 09:47:09 -08001201 spin_unlock(&ci->i_ceph_lock);
Sage Weila8599bd2009-10-06 11:31:12 -07001202
Sage Weila8599bd2009-10-06 11:31:12 -07001203 ret = send_cap_msg(session, ceph_vino(inode).ino, cap_id,
Yan, Zhenga2971c82015-06-10 11:09:32 +08001204 op, keep, want, flushing, seq,
1205 flush_tid, oldest_flush_tid, issue_seq, mseq,
Yan, Zhengd1eee0c2016-01-22 18:30:12 +08001206 size, max_size, &mtime, &atime, &ctime, time_warp_seq,
Sage Weil082afec2010-08-22 15:16:41 -07001207 uid, gid, mode, xattr_version, xattr_blob,
Yan, Zhenge20d2582014-11-14 22:39:13 +08001208 follows, inline_data);
Sage Weila8599bd2009-10-06 11:31:12 -07001209 if (ret < 0) {
1210 dout("error sending cap msg, must requeue %p\n", inode);
1211 delayed = 1;
1212 }
1213
1214 if (wake)
Yehuda Sadeh03066f22010-07-27 13:11:08 -07001215 wake_up_all(&ci->i_cap_wq);
Sage Weila8599bd2009-10-06 11:31:12 -07001216
1217 return delayed;
1218}
1219
1220/*
1221 * When a snapshot is taken, clients accumulate dirty metadata on
1222 * inodes with capabilities in ceph_cap_snaps to describe the file
1223 * state at the time the snapshot was taken. This must be flushed
1224 * asynchronously back to the MDS once sync writes complete and dirty
1225 * data is written out.
1226 *
Yan, Zhengaffbc192015-05-05 21:22:13 +08001227 * Unless @kick is true, skip cap_snaps that were already sent to
Sage Weile8351242010-09-17 08:03:08 -07001228 * the MDS (i.e., during this session).
1229 *
Sage Weilbe655592011-11-30 09:47:09 -08001230 * Called under i_ceph_lock. Takes s_mutex as needed.
Sage Weila8599bd2009-10-06 11:31:12 -07001231 */
1232void __ceph_flush_snaps(struct ceph_inode_info *ci,
Sage Weile8351242010-09-17 08:03:08 -07001233 struct ceph_mds_session **psession,
Yan, Zhengaffbc192015-05-05 21:22:13 +08001234 int kick)
Sage Weilbe655592011-11-30 09:47:09 -08001235 __releases(ci->i_ceph_lock)
1236 __acquires(ci->i_ceph_lock)
Sage Weila8599bd2009-10-06 11:31:12 -07001237{
1238 struct inode *inode = &ci->vfs_inode;
1239 int mds;
1240 struct ceph_cap_snap *capsnap;
1241 u32 mseq;
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -07001242 struct ceph_mds_client *mdsc = ceph_inode_to_client(inode)->mdsc;
Sage Weila8599bd2009-10-06 11:31:12 -07001243 struct ceph_mds_session *session = NULL; /* if session != NULL, we hold
1244 session->s_mutex */
1245 u64 next_follows = 0; /* keep track of how far we've gotten through the
1246 i_cap_snaps list, and skip these entries next time
1247 around to avoid an infinite loop */
1248
1249 if (psession)
1250 session = *psession;
1251
1252 dout("__flush_snaps %p\n", inode);
1253retry:
1254 list_for_each_entry(capsnap, &ci->i_cap_snaps, ci_item) {
1255 /* avoid an infiniute loop after retry */
1256 if (capsnap->follows < next_follows)
1257 continue;
1258 /*
1259 * we need to wait for sync writes to complete and for dirty
1260 * pages to be written out.
1261 */
1262 if (capsnap->dirty_pages || capsnap->writing)
Sage Weilcfc0bf62010-09-14 15:50:59 -07001263 break;
Sage Weila8599bd2009-10-06 11:31:12 -07001264
Yan, Zheng86056092015-05-01 16:57:16 +08001265 /* should be removed by ceph_try_drop_cap_snap() */
1266 BUG_ON(!capsnap->need_flush);
Sage Weil819ccbf2010-04-01 09:33:46 -07001267
Sage Weila8599bd2009-10-06 11:31:12 -07001268 /* pick mds, take s_mutex */
Sage Weilca81f3f2010-06-10 14:21:36 -07001269 if (ci->i_auth_cap == NULL) {
1270 dout("no auth cap (migrating?), doing nothing\n");
1271 goto out;
1272 }
Sage Weile8351242010-09-17 08:03:08 -07001273
1274 /* only flush each capsnap once */
Yan, Zhengaffbc192015-05-05 21:22:13 +08001275 if (!kick && !list_empty(&capsnap->flushing_item)) {
Sage Weile8351242010-09-17 08:03:08 -07001276 dout("already flushed %p, skipping\n", capsnap);
1277 continue;
1278 }
1279
Sage Weilca81f3f2010-06-10 14:21:36 -07001280 mds = ci->i_auth_cap->session->s_mds;
1281 mseq = ci->i_auth_cap->mseq;
1282
Sage Weila8599bd2009-10-06 11:31:12 -07001283 if (session && session->s_mds != mds) {
1284 dout("oops, wrong session %p mutex\n", session);
Yan, Zhengaffbc192015-05-05 21:22:13 +08001285 if (kick)
1286 goto out;
1287
Sage Weila8599bd2009-10-06 11:31:12 -07001288 mutex_unlock(&session->s_mutex);
1289 ceph_put_mds_session(session);
1290 session = NULL;
1291 }
1292 if (!session) {
Sage Weilbe655592011-11-30 09:47:09 -08001293 spin_unlock(&ci->i_ceph_lock);
Sage Weila8599bd2009-10-06 11:31:12 -07001294 mutex_lock(&mdsc->mutex);
1295 session = __ceph_lookup_mds_session(mdsc, mds);
1296 mutex_unlock(&mdsc->mutex);
1297 if (session) {
1298 dout("inverting session/ino locks on %p\n",
1299 session);
1300 mutex_lock(&session->s_mutex);
1301 }
1302 /*
1303 * if session == NULL, we raced against a cap
Sage Weilca81f3f2010-06-10 14:21:36 -07001304 * deletion or migration. retry, and we'll
1305 * get a better @mds value next time.
Sage Weila8599bd2009-10-06 11:31:12 -07001306 */
Sage Weilbe655592011-11-30 09:47:09 -08001307 spin_lock(&ci->i_ceph_lock);
Sage Weila8599bd2009-10-06 11:31:12 -07001308 goto retry;
1309 }
1310
Yan, Zheng553adfd2015-06-09 15:48:57 +08001311 spin_lock(&mdsc->cap_dirty_lock);
1312 capsnap->flush_tid = ++mdsc->last_cap_flush_tid;
1313 spin_unlock(&mdsc->cap_dirty_lock);
1314
Sage Weila8599bd2009-10-06 11:31:12 -07001315 atomic_inc(&capsnap->nref);
Yan, Zhengaffbc192015-05-05 21:22:13 +08001316 if (list_empty(&capsnap->flushing_item))
1317 list_add_tail(&capsnap->flushing_item,
1318 &session->s_cap_snaps_flushing);
Sage Weilbe655592011-11-30 09:47:09 -08001319 spin_unlock(&ci->i_ceph_lock);
Sage Weila8599bd2009-10-06 11:31:12 -07001320
Sage Weilcfc0bf62010-09-14 15:50:59 -07001321 dout("flush_snaps %p cap_snap %p follows %lld tid %llu\n",
1322 inode, capsnap, capsnap->follows, capsnap->flush_tid);
Sage Weila8599bd2009-10-06 11:31:12 -07001323 send_cap_msg(session, ceph_vino(inode).ino, 0,
1324 CEPH_CAP_OP_FLUSHSNAP, capsnap->issued, 0,
Yan, Zhenga2971c82015-06-10 11:09:32 +08001325 capsnap->dirty, 0, capsnap->flush_tid, 0,
1326 0, mseq, capsnap->size, 0,
Sage Weila8599bd2009-10-06 11:31:12 -07001327 &capsnap->mtime, &capsnap->atime,
Yan, Zhengd1eee0c2016-01-22 18:30:12 +08001328 &capsnap->ctime, capsnap->time_warp_seq,
Sage Weila8599bd2009-10-06 11:31:12 -07001329 capsnap->uid, capsnap->gid, capsnap->mode,
Sage Weil4a625be2010-08-22 15:03:56 -07001330 capsnap->xattr_version, capsnap->xattr_blob,
Yan, Zhenge20d2582014-11-14 22:39:13 +08001331 capsnap->follows, capsnap->inline_data);
Sage Weila8599bd2009-10-06 11:31:12 -07001332
1333 next_follows = capsnap->follows + 1;
1334 ceph_put_cap_snap(capsnap);
1335
Sage Weilbe655592011-11-30 09:47:09 -08001336 spin_lock(&ci->i_ceph_lock);
Sage Weila8599bd2009-10-06 11:31:12 -07001337 goto retry;
1338 }
1339
1340 /* we flushed them all; remove this inode from the queue */
1341 spin_lock(&mdsc->snap_flush_lock);
1342 list_del_init(&ci->i_snap_flush_item);
1343 spin_unlock(&mdsc->snap_flush_lock);
1344
Sage Weilca81f3f2010-06-10 14:21:36 -07001345out:
Sage Weila8599bd2009-10-06 11:31:12 -07001346 if (psession)
1347 *psession = session;
1348 else if (session) {
1349 mutex_unlock(&session->s_mutex);
1350 ceph_put_mds_session(session);
1351 }
1352}
1353
1354static void ceph_flush_snaps(struct ceph_inode_info *ci)
1355{
Sage Weilbe655592011-11-30 09:47:09 -08001356 spin_lock(&ci->i_ceph_lock);
Sage Weile8351242010-09-17 08:03:08 -07001357 __ceph_flush_snaps(ci, NULL, 0);
Sage Weilbe655592011-11-30 09:47:09 -08001358 spin_unlock(&ci->i_ceph_lock);
Sage Weila8599bd2009-10-06 11:31:12 -07001359}
1360
1361/*
Sage Weilfca65b42011-05-04 11:33:47 -07001362 * Mark caps dirty. If inode is newly dirty, return the dirty flags.
1363 * Caller is then responsible for calling __mark_inode_dirty with the
1364 * returned flags value.
Sage Weil76e3b392009-10-15 18:13:53 -07001365 */
Yan, Zhengf66fd9f2015-06-10 17:26:13 +08001366int __ceph_mark_dirty_caps(struct ceph_inode_info *ci, int mask,
1367 struct ceph_cap_flush **pcf)
Sage Weil76e3b392009-10-15 18:13:53 -07001368{
Cheng Renquan640ef792010-03-26 17:40:33 +08001369 struct ceph_mds_client *mdsc =
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -07001370 ceph_sb_to_client(ci->vfs_inode.i_sb)->mdsc;
Sage Weil76e3b392009-10-15 18:13:53 -07001371 struct inode *inode = &ci->vfs_inode;
1372 int was = ci->i_dirty_caps;
1373 int dirty = 0;
1374
Yan, Zheng571ade32015-03-24 11:36:08 +08001375 if (!ci->i_auth_cap) {
1376 pr_warn("__mark_dirty_caps %p %llx mask %s, "
1377 "but no auth cap (session was closed?)\n",
1378 inode, ceph_ino(inode), ceph_cap_string(mask));
1379 return 0;
1380 }
1381
Sage Weil76e3b392009-10-15 18:13:53 -07001382 dout("__mark_dirty_caps %p %s dirty %s -> %s\n", &ci->vfs_inode,
1383 ceph_cap_string(mask), ceph_cap_string(was),
1384 ceph_cap_string(was | mask));
1385 ci->i_dirty_caps |= mask;
1386 if (was == 0) {
Yan, Zhengf66fd9f2015-06-10 17:26:13 +08001387 WARN_ON_ONCE(ci->i_prealloc_cap_flush);
1388 swap(ci->i_prealloc_cap_flush, *pcf);
1389
Yan, Zheng604d1b02015-05-01 17:49:16 +08001390 if (!ci->i_head_snapc) {
1391 WARN_ON_ONCE(!rwsem_is_locked(&mdsc->snap_rwsem));
Sage Weil7d8cb262010-08-24 08:44:16 -07001392 ci->i_head_snapc = ceph_get_snap_context(
1393 ci->i_snap_realm->cached_context);
Yan, Zheng604d1b02015-05-01 17:49:16 +08001394 }
Yan, Zheng06852352012-11-19 10:49:07 +08001395 dout(" inode %p now dirty snapc %p auth cap %p\n",
1396 &ci->vfs_inode, ci->i_head_snapc, ci->i_auth_cap);
Sage Weil76e3b392009-10-15 18:13:53 -07001397 BUG_ON(!list_empty(&ci->i_dirty_item));
1398 spin_lock(&mdsc->cap_dirty_lock);
Yan, Zheng11df2df2013-11-24 14:44:38 +08001399 list_add(&ci->i_dirty_item, &mdsc->cap_dirty);
Sage Weil76e3b392009-10-15 18:13:53 -07001400 spin_unlock(&mdsc->cap_dirty_lock);
1401 if (ci->i_flushing_caps == 0) {
Sage Weil3772d262011-05-03 09:28:08 -07001402 ihold(inode);
Sage Weil76e3b392009-10-15 18:13:53 -07001403 dirty |= I_DIRTY_SYNC;
1404 }
Yan, Zhengf66fd9f2015-06-10 17:26:13 +08001405 } else {
1406 WARN_ON_ONCE(!ci->i_prealloc_cap_flush);
Sage Weil76e3b392009-10-15 18:13:53 -07001407 }
1408 BUG_ON(list_empty(&ci->i_dirty_item));
1409 if (((was | ci->i_flushing_caps) & CEPH_CAP_FILE_BUFFER) &&
1410 (mask & CEPH_CAP_FILE_BUFFER))
1411 dirty |= I_DIRTY_DATASYNC;
Sage Weil76e3b392009-10-15 18:13:53 -07001412 __cap_delay_requeue(mdsc, ci);
Sage Weilfca65b42011-05-04 11:33:47 -07001413 return dirty;
Sage Weil76e3b392009-10-15 18:13:53 -07001414}
1415
Yan, Zheng553adfd2015-06-09 15:48:57 +08001416static void __add_cap_flushing_to_inode(struct ceph_inode_info *ci,
1417 struct ceph_cap_flush *cf)
1418{
1419 struct rb_node **p = &ci->i_cap_flush_tree.rb_node;
1420 struct rb_node *parent = NULL;
1421 struct ceph_cap_flush *other = NULL;
1422
1423 while (*p) {
1424 parent = *p;
1425 other = rb_entry(parent, struct ceph_cap_flush, i_node);
1426
1427 if (cf->tid < other->tid)
1428 p = &(*p)->rb_left;
1429 else if (cf->tid > other->tid)
1430 p = &(*p)->rb_right;
1431 else
1432 BUG();
1433 }
1434
1435 rb_link_node(&cf->i_node, parent, p);
1436 rb_insert_color(&cf->i_node, &ci->i_cap_flush_tree);
1437}
1438
Yan, Zheng8310b082015-06-09 17:20:12 +08001439static void __add_cap_flushing_to_mdsc(struct ceph_mds_client *mdsc,
1440 struct ceph_cap_flush *cf)
1441{
1442 struct rb_node **p = &mdsc->cap_flush_tree.rb_node;
1443 struct rb_node *parent = NULL;
1444 struct ceph_cap_flush *other = NULL;
1445
1446 while (*p) {
1447 parent = *p;
1448 other = rb_entry(parent, struct ceph_cap_flush, g_node);
1449
1450 if (cf->tid < other->tid)
1451 p = &(*p)->rb_left;
1452 else if (cf->tid > other->tid)
1453 p = &(*p)->rb_right;
1454 else
1455 BUG();
1456 }
1457
1458 rb_link_node(&cf->g_node, parent, p);
1459 rb_insert_color(&cf->g_node, &mdsc->cap_flush_tree);
1460}
1461
Yan, Zhengf66fd9f2015-06-10 17:26:13 +08001462struct ceph_cap_flush *ceph_alloc_cap_flush(void)
1463{
1464 return kmem_cache_alloc(ceph_cap_flush_cachep, GFP_KERNEL);
1465}
1466
1467void ceph_free_cap_flush(struct ceph_cap_flush *cf)
1468{
1469 if (cf)
1470 kmem_cache_free(ceph_cap_flush_cachep, cf);
1471}
1472
Yan, Zhenga2971c82015-06-10 11:09:32 +08001473static u64 __get_oldest_flush_tid(struct ceph_mds_client *mdsc)
1474{
1475 struct rb_node *n = rb_first(&mdsc->cap_flush_tree);
1476 if (n) {
1477 struct ceph_cap_flush *cf =
1478 rb_entry(n, struct ceph_cap_flush, g_node);
1479 return cf->tid;
1480 }
1481 return 0;
1482}
1483
Sage Weil76e3b392009-10-15 18:13:53 -07001484/*
Sage Weila8599bd2009-10-06 11:31:12 -07001485 * Add dirty inode to the flushing list. Assigned a seq number so we
1486 * can wait for caps to flush without starving.
Sage Weilcdc35f92009-10-14 14:24:19 -07001487 *
Sage Weilbe655592011-11-30 09:47:09 -08001488 * Called under i_ceph_lock.
Sage Weila8599bd2009-10-06 11:31:12 -07001489 */
Sage Weilcdc35f92009-10-14 14:24:19 -07001490static int __mark_caps_flushing(struct inode *inode,
Yan, Zheng553adfd2015-06-09 15:48:57 +08001491 struct ceph_mds_session *session,
Yan, Zhenga2971c82015-06-10 11:09:32 +08001492 u64 *flush_tid, u64 *oldest_flush_tid)
Sage Weila8599bd2009-10-06 11:31:12 -07001493{
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -07001494 struct ceph_mds_client *mdsc = ceph_sb_to_client(inode->i_sb)->mdsc;
Sage Weila8599bd2009-10-06 11:31:12 -07001495 struct ceph_inode_info *ci = ceph_inode(inode);
Yan, Zhengf66fd9f2015-06-10 17:26:13 +08001496 struct ceph_cap_flush *cf = NULL;
Sage Weilcdc35f92009-10-14 14:24:19 -07001497 int flushing;
Sage Weil50b885b2009-12-01 14:12:07 -08001498
Sage Weilcdc35f92009-10-14 14:24:19 -07001499 BUG_ON(ci->i_dirty_caps == 0);
Sage Weila8599bd2009-10-06 11:31:12 -07001500 BUG_ON(list_empty(&ci->i_dirty_item));
Yan, Zhengf66fd9f2015-06-10 17:26:13 +08001501 BUG_ON(!ci->i_prealloc_cap_flush);
Sage Weilcdc35f92009-10-14 14:24:19 -07001502
1503 flushing = ci->i_dirty_caps;
1504 dout("__mark_caps_flushing flushing %s, flushing_caps %s -> %s\n",
1505 ceph_cap_string(flushing),
1506 ceph_cap_string(ci->i_flushing_caps),
1507 ceph_cap_string(ci->i_flushing_caps | flushing));
1508 ci->i_flushing_caps |= flushing;
1509 ci->i_dirty_caps = 0;
Sage Weilafcdaea2009-10-14 14:27:38 -07001510 dout(" inode %p now !dirty\n", inode);
Sage Weilcdc35f92009-10-14 14:24:19 -07001511
Yan, Zhengf66fd9f2015-06-10 17:26:13 +08001512 swap(cf, ci->i_prealloc_cap_flush);
Yan, Zheng553adfd2015-06-09 15:48:57 +08001513 cf->caps = flushing;
1514
Sage Weila8599bd2009-10-06 11:31:12 -07001515 spin_lock(&mdsc->cap_dirty_lock);
Sage Weilafcdaea2009-10-14 14:27:38 -07001516 list_del_init(&ci->i_dirty_item);
1517
Yan, Zheng553adfd2015-06-09 15:48:57 +08001518 cf->tid = ++mdsc->last_cap_flush_tid;
Yan, Zheng8310b082015-06-09 17:20:12 +08001519 __add_cap_flushing_to_mdsc(mdsc, cf);
Yan, Zhenga2971c82015-06-10 11:09:32 +08001520 *oldest_flush_tid = __get_oldest_flush_tid(mdsc);
Yan, Zheng553adfd2015-06-09 15:48:57 +08001521
Sage Weila8599bd2009-10-06 11:31:12 -07001522 if (list_empty(&ci->i_flushing_item)) {
1523 list_add_tail(&ci->i_flushing_item, &session->s_cap_flushing);
1524 mdsc->num_cap_flushing++;
Yan, Zheng8310b082015-06-09 17:20:12 +08001525 dout(" inode %p now flushing tid %llu\n", inode, cf->tid);
Sage Weilafcdaea2009-10-14 14:27:38 -07001526 } else {
1527 list_move_tail(&ci->i_flushing_item, &session->s_cap_flushing);
Yan, Zheng8310b082015-06-09 17:20:12 +08001528 dout(" inode %p now flushing (more) tid %llu\n",
1529 inode, cf->tid);
Sage Weila8599bd2009-10-06 11:31:12 -07001530 }
1531 spin_unlock(&mdsc->cap_dirty_lock);
Sage Weilcdc35f92009-10-14 14:24:19 -07001532
Yan, Zheng553adfd2015-06-09 15:48:57 +08001533 __add_cap_flushing_to_inode(ci, cf);
1534
1535 *flush_tid = cf->tid;
Sage Weilcdc35f92009-10-14 14:24:19 -07001536 return flushing;
Sage Weila8599bd2009-10-06 11:31:12 -07001537}
1538
1539/*
Sage Weil5ecad6f2010-02-17 10:43:37 -08001540 * try to invalidate mapping pages without blocking.
1541 */
Sage Weil5ecad6f2010-02-17 10:43:37 -08001542static int try_nonblocking_invalidate(struct inode *inode)
1543{
1544 struct ceph_inode_info *ci = ceph_inode(inode);
1545 u32 invalidating_gen = ci->i_rdcache_gen;
1546
Sage Weilbe655592011-11-30 09:47:09 -08001547 spin_unlock(&ci->i_ceph_lock);
Sage Weil5ecad6f2010-02-17 10:43:37 -08001548 invalidate_mapping_pages(&inode->i_data, 0, -1);
Sage Weilbe655592011-11-30 09:47:09 -08001549 spin_lock(&ci->i_ceph_lock);
Sage Weil5ecad6f2010-02-17 10:43:37 -08001550
Sage Weil18a38192010-09-17 10:46:44 -07001551 if (inode->i_data.nrpages == 0 &&
Sage Weil5ecad6f2010-02-17 10:43:37 -08001552 invalidating_gen == ci->i_rdcache_gen) {
1553 /* success. */
1554 dout("try_nonblocking_invalidate %p success\n", inode);
Sage Weilcd045cb2010-11-04 11:05:05 -07001555 /* save any racing async invalidate some trouble */
1556 ci->i_rdcache_revoking = ci->i_rdcache_gen - 1;
Sage Weil5ecad6f2010-02-17 10:43:37 -08001557 return 0;
1558 }
1559 dout("try_nonblocking_invalidate %p failed\n", inode);
1560 return -1;
1561}
1562
1563/*
Sage Weila8599bd2009-10-06 11:31:12 -07001564 * Swiss army knife function to examine currently used and wanted
1565 * versus held caps. Release, flush, ack revoked caps to mds as
1566 * appropriate.
1567 *
1568 * CHECK_CAPS_NODELAY - caller is delayed work and we should not delay
1569 * cap release further.
1570 * CHECK_CAPS_AUTHONLY - we should only check the auth cap
1571 * CHECK_CAPS_FLUSH - we should flush any dirty caps immediately, without
1572 * further delay.
1573 */
1574void ceph_check_caps(struct ceph_inode_info *ci, int flags,
1575 struct ceph_mds_session *session)
1576{
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -07001577 struct ceph_fs_client *fsc = ceph_inode_to_client(&ci->vfs_inode);
1578 struct ceph_mds_client *mdsc = fsc->mdsc;
Sage Weila8599bd2009-10-06 11:31:12 -07001579 struct inode *inode = &ci->vfs_inode;
1580 struct ceph_cap *cap;
Yan, Zhenga2971c82015-06-10 11:09:32 +08001581 u64 flush_tid, oldest_flush_tid;
Yan, Zheng395c3122013-01-04 14:37:57 +08001582 int file_wanted, used, cap_used;
Sage Weila8599bd2009-10-06 11:31:12 -07001583 int took_snap_rwsem = 0; /* true if mdsc->snap_rwsem held */
Sage Weilcbd03632010-02-09 13:41:18 -08001584 int issued, implemented, want, retain, revoking, flushing = 0;
Sage Weila8599bd2009-10-06 11:31:12 -07001585 int mds = -1; /* keep track of how far we've gone through i_caps list
1586 to avoid an infinite loop on retry */
1587 struct rb_node *p;
1588 int tried_invalidate = 0;
1589 int delayed = 0, sent = 0, force_requeue = 0, num;
Sage Weilcbd03632010-02-09 13:41:18 -08001590 int queue_invalidate = 0;
Sage Weila8599bd2009-10-06 11:31:12 -07001591 int is_delayed = flags & CHECK_CAPS_NODELAY;
1592
1593 /* if we are unmounting, flush any unused caps immediately. */
1594 if (mdsc->stopping)
1595 is_delayed = 1;
1596
Sage Weilbe655592011-11-30 09:47:09 -08001597 spin_lock(&ci->i_ceph_lock);
Sage Weila8599bd2009-10-06 11:31:12 -07001598
1599 if (ci->i_ceph_flags & CEPH_I_FLUSH)
1600 flags |= CHECK_CAPS_FLUSH;
1601
1602 /* flush snaps first time around only */
1603 if (!list_empty(&ci->i_cap_snaps))
Sage Weile8351242010-09-17 08:03:08 -07001604 __ceph_flush_snaps(ci, &session, 0);
Sage Weila8599bd2009-10-06 11:31:12 -07001605 goto retry_locked;
1606retry:
Sage Weilbe655592011-11-30 09:47:09 -08001607 spin_lock(&ci->i_ceph_lock);
Sage Weila8599bd2009-10-06 11:31:12 -07001608retry_locked:
1609 file_wanted = __ceph_caps_file_wanted(ci);
1610 used = __ceph_caps_used(ci);
Sage Weilcbd03632010-02-09 13:41:18 -08001611 issued = __ceph_caps_issued(ci, &implemented);
1612 revoking = implemented & ~issued;
Sage Weila8599bd2009-10-06 11:31:12 -07001613
Yan, Zheng41445992015-05-25 17:36:42 +08001614 want = file_wanted;
1615 retain = file_wanted | used | CEPH_CAP_PIN;
Sage Weila8599bd2009-10-06 11:31:12 -07001616 if (!mdsc->stopping && inode->i_nlink > 0) {
Yan, Zheng41445992015-05-25 17:36:42 +08001617 if (file_wanted) {
Sage Weila8599bd2009-10-06 11:31:12 -07001618 retain |= CEPH_CAP_ANY; /* be greedy */
Yan, Zheng32ec4392015-03-26 19:06:00 +08001619 } else if (S_ISDIR(inode->i_mode) &&
1620 (issued & CEPH_CAP_FILE_SHARED) &&
1621 __ceph_dir_is_complete(ci)) {
1622 /*
1623 * If a directory is complete, we want to keep
1624 * the exclusive cap. So that MDS does not end up
1625 * revoking the shared cap on every create/unlink
1626 * operation.
1627 */
1628 want = CEPH_CAP_ANY_SHARED | CEPH_CAP_FILE_EXCL;
1629 retain |= want;
Sage Weila8599bd2009-10-06 11:31:12 -07001630 } else {
Yan, Zheng32ec4392015-03-26 19:06:00 +08001631
Sage Weila8599bd2009-10-06 11:31:12 -07001632 retain |= CEPH_CAP_ANY_SHARED;
1633 /*
1634 * keep RD only if we didn't have the file open RW,
1635 * because then the mds would revoke it anyway to
1636 * journal max_size=0.
1637 */
1638 if (ci->i_max_size == 0)
1639 retain |= CEPH_CAP_ANY_RD;
1640 }
1641 }
1642
1643 dout("check_caps %p file_want %s used %s dirty %s flushing %s"
Sage Weilcbd03632010-02-09 13:41:18 -08001644 " issued %s revoking %s retain %s %s%s%s\n", inode,
Sage Weila8599bd2009-10-06 11:31:12 -07001645 ceph_cap_string(file_wanted),
1646 ceph_cap_string(used), ceph_cap_string(ci->i_dirty_caps),
1647 ceph_cap_string(ci->i_flushing_caps),
Sage Weilcbd03632010-02-09 13:41:18 -08001648 ceph_cap_string(issued), ceph_cap_string(revoking),
Sage Weila8599bd2009-10-06 11:31:12 -07001649 ceph_cap_string(retain),
1650 (flags & CHECK_CAPS_AUTHONLY) ? " AUTHONLY" : "",
1651 (flags & CHECK_CAPS_NODELAY) ? " NODELAY" : "",
1652 (flags & CHECK_CAPS_FLUSH) ? " FLUSH" : "");
1653
1654 /*
1655 * If we no longer need to hold onto old our caps, and we may
1656 * have cached pages, but don't want them, then try to invalidate.
1657 * If we fail, it's because pages are locked.... try again later.
1658 */
1659 if ((!is_delayed || mdsc->stopping) &&
Yan, Zhengfdd4e152015-06-16 20:48:56 +08001660 !S_ISDIR(inode->i_mode) && /* ignore readdir cache */
Yan, Zheng9abd4db2016-05-18 20:58:26 +08001661 !(ci->i_wb_ref || ci->i_wrbuffer_ref) && /* no dirty pages... */
Yan, Zhengfdd4e152015-06-16 20:48:56 +08001662 inode->i_data.nrpages && /* have cached pages */
Yan, Zheng5e804ac2015-10-26 16:08:43 +08001663 (revoking & (CEPH_CAP_FILE_CACHE|
1664 CEPH_CAP_FILE_LAZYIO)) && /* or revoking cache */
Sage Weila8599bd2009-10-06 11:31:12 -07001665 !tried_invalidate) {
Sage Weila8599bd2009-10-06 11:31:12 -07001666 dout("check_caps trying to invalidate on %p\n", inode);
Sage Weil5ecad6f2010-02-17 10:43:37 -08001667 if (try_nonblocking_invalidate(inode) < 0) {
Sage Weil29625072010-05-27 10:40:43 -07001668 if (revoking & (CEPH_CAP_FILE_CACHE|
1669 CEPH_CAP_FILE_LAZYIO)) {
Sage Weil5ecad6f2010-02-17 10:43:37 -08001670 dout("check_caps queuing invalidate\n");
1671 queue_invalidate = 1;
1672 ci->i_rdcache_revoking = ci->i_rdcache_gen;
1673 } else {
1674 dout("check_caps failed to invalidate pages\n");
1675 /* we failed to invalidate pages. check these
1676 caps again later. */
1677 force_requeue = 1;
1678 __cap_set_timeouts(mdsc, ci);
1679 }
Sage Weila8599bd2009-10-06 11:31:12 -07001680 }
1681 tried_invalidate = 1;
1682 goto retry_locked;
1683 }
1684
1685 num = 0;
1686 for (p = rb_first(&ci->i_caps); p; p = rb_next(p)) {
1687 cap = rb_entry(p, struct ceph_cap, ci_node);
1688 num++;
1689
1690 /* avoid looping forever */
1691 if (mds >= cap->mds ||
1692 ((flags & CHECK_CAPS_AUTHONLY) && cap != ci->i_auth_cap))
1693 continue;
1694
1695 /* NOTE: no side-effects allowed, until we take s_mutex */
1696
Yan, Zheng395c3122013-01-04 14:37:57 +08001697 cap_used = used;
1698 if (ci->i_auth_cap && cap != ci->i_auth_cap)
1699 cap_used &= ~ci->i_auth_cap->issued;
1700
Sage Weila8599bd2009-10-06 11:31:12 -07001701 revoking = cap->implemented & ~cap->issued;
Yan, Zheng395c3122013-01-04 14:37:57 +08001702 dout(" mds%d cap %p used %s issued %s implemented %s revoking %s\n",
Yan, Zheng9abd4db2016-05-18 20:58:26 +08001703 cap->mds, cap, ceph_cap_string(cap_used),
1704 ceph_cap_string(cap->issued),
Sage Weil088b3f52011-01-18 08:56:01 -08001705 ceph_cap_string(cap->implemented),
1706 ceph_cap_string(revoking));
Sage Weila8599bd2009-10-06 11:31:12 -07001707
1708 if (cap == ci->i_auth_cap &&
1709 (cap->issued & CEPH_CAP_FILE_WR)) {
1710 /* request larger max_size from MDS? */
1711 if (ci->i_wanted_max_size > ci->i_max_size &&
1712 ci->i_wanted_max_size > ci->i_requested_max_size) {
1713 dout("requesting new max_size\n");
1714 goto ack;
1715 }
1716
1717 /* approaching file_max? */
1718 if ((inode->i_size << 1) >= ci->i_max_size &&
1719 (ci->i_reported_size << 1) < ci->i_max_size) {
1720 dout("i_size approaching max_size\n");
1721 goto ack;
1722 }
1723 }
1724 /* flush anything dirty? */
1725 if (cap == ci->i_auth_cap && (flags & CHECK_CAPS_FLUSH) &&
1726 ci->i_dirty_caps) {
1727 dout("flushing dirty caps\n");
1728 goto ack;
1729 }
1730
1731 /* completed revocation? going down and there are no caps? */
Yan, Zheng395c3122013-01-04 14:37:57 +08001732 if (revoking && (revoking & cap_used) == 0) {
Sage Weila8599bd2009-10-06 11:31:12 -07001733 dout("completed revocation of %s\n",
1734 ceph_cap_string(cap->implemented & ~cap->issued));
1735 goto ack;
1736 }
1737
1738 /* want more caps from mds? */
1739 if (want & ~(cap->mds_wanted | cap->issued))
1740 goto ack;
1741
1742 /* things we might delay */
1743 if ((cap->issued & ~retain) == 0 &&
1744 cap->mds_wanted == want)
1745 continue; /* nope, all good */
1746
1747 if (is_delayed)
1748 goto ack;
1749
1750 /* delay? */
1751 if ((ci->i_ceph_flags & CEPH_I_NODELAY) == 0 &&
1752 time_before(jiffies, ci->i_hold_caps_max)) {
1753 dout(" delaying issued %s -> %s, wanted %s -> %s\n",
1754 ceph_cap_string(cap->issued),
1755 ceph_cap_string(cap->issued & retain),
1756 ceph_cap_string(cap->mds_wanted),
1757 ceph_cap_string(want));
1758 delayed++;
1759 continue;
1760 }
1761
1762ack:
Sage Weile9964c12010-03-01 15:16:56 -08001763 if (ci->i_ceph_flags & CEPH_I_NOFLUSH) {
1764 dout(" skipping %p I_NOFLUSH set\n", inode);
1765 continue;
1766 }
1767
Sage Weila8599bd2009-10-06 11:31:12 -07001768 if (session && session != cap->session) {
1769 dout("oops, wrong session %p mutex\n", session);
1770 mutex_unlock(&session->s_mutex);
1771 session = NULL;
1772 }
1773 if (!session) {
1774 session = cap->session;
1775 if (mutex_trylock(&session->s_mutex) == 0) {
1776 dout("inverting session/ino locks on %p\n",
1777 session);
Sage Weilbe655592011-11-30 09:47:09 -08001778 spin_unlock(&ci->i_ceph_lock);
Sage Weila8599bd2009-10-06 11:31:12 -07001779 if (took_snap_rwsem) {
1780 up_read(&mdsc->snap_rwsem);
1781 took_snap_rwsem = 0;
1782 }
1783 mutex_lock(&session->s_mutex);
1784 goto retry;
1785 }
1786 }
1787 /* take snap_rwsem after session mutex */
1788 if (!took_snap_rwsem) {
1789 if (down_read_trylock(&mdsc->snap_rwsem) == 0) {
1790 dout("inverting snap/in locks on %p\n",
1791 inode);
Sage Weilbe655592011-11-30 09:47:09 -08001792 spin_unlock(&ci->i_ceph_lock);
Sage Weila8599bd2009-10-06 11:31:12 -07001793 down_read(&mdsc->snap_rwsem);
1794 took_snap_rwsem = 1;
1795 goto retry;
1796 }
1797 took_snap_rwsem = 1;
1798 }
1799
Yan, Zheng553adfd2015-06-09 15:48:57 +08001800 if (cap == ci->i_auth_cap && ci->i_dirty_caps) {
1801 flushing = __mark_caps_flushing(inode, session,
Yan, Zhenga2971c82015-06-10 11:09:32 +08001802 &flush_tid,
1803 &oldest_flush_tid);
Yan, Zheng553adfd2015-06-09 15:48:57 +08001804 } else {
Sage Weil24be0c42011-01-18 08:48:06 -08001805 flushing = 0;
Yan, Zheng553adfd2015-06-09 15:48:57 +08001806 flush_tid = 0;
Yan, Zhenga2971c82015-06-10 11:09:32 +08001807 spin_lock(&mdsc->cap_dirty_lock);
1808 oldest_flush_tid = __get_oldest_flush_tid(mdsc);
1809 spin_unlock(&mdsc->cap_dirty_lock);
Yan, Zheng553adfd2015-06-09 15:48:57 +08001810 }
Sage Weila8599bd2009-10-06 11:31:12 -07001811
1812 mds = cap->mds; /* remember mds, so we don't repeat */
1813 sent++;
1814
Sage Weilbe655592011-11-30 09:47:09 -08001815 /* __send_cap drops i_ceph_lock */
Yan, Zheng395c3122013-01-04 14:37:57 +08001816 delayed += __send_cap(mdsc, cap, CEPH_CAP_OP_UPDATE, cap_used,
Yan, Zhenga2971c82015-06-10 11:09:32 +08001817 want, retain, flushing,
1818 flush_tid, oldest_flush_tid);
Sage Weilbe655592011-11-30 09:47:09 -08001819 goto retry; /* retake i_ceph_lock and restart our cap scan. */
Sage Weila8599bd2009-10-06 11:31:12 -07001820 }
1821
1822 /*
1823 * Reschedule delayed caps release if we delayed anything,
1824 * otherwise cancel.
1825 */
1826 if (delayed && is_delayed)
1827 force_requeue = 1; /* __send_cap delayed release; requeue */
1828 if (!delayed && !is_delayed)
1829 __cap_delay_cancel(mdsc, ci);
1830 else if (!is_delayed || force_requeue)
1831 __cap_delay_requeue(mdsc, ci);
1832
Sage Weilbe655592011-11-30 09:47:09 -08001833 spin_unlock(&ci->i_ceph_lock);
Sage Weila8599bd2009-10-06 11:31:12 -07001834
Sage Weilcbd03632010-02-09 13:41:18 -08001835 if (queue_invalidate)
Sage Weil3c6f6b72010-02-09 15:24:44 -08001836 ceph_queue_invalidate(inode);
Sage Weilcbd03632010-02-09 13:41:18 -08001837
Sage Weilcdc2ce02010-03-16 13:39:28 -07001838 if (session)
Sage Weila8599bd2009-10-06 11:31:12 -07001839 mutex_unlock(&session->s_mutex);
1840 if (took_snap_rwsem)
1841 up_read(&mdsc->snap_rwsem);
1842}
1843
1844/*
Sage Weila8599bd2009-10-06 11:31:12 -07001845 * Try to flush dirty caps back to the auth mds.
1846 */
Yan, Zheng553adfd2015-06-09 15:48:57 +08001847static int try_flush_caps(struct inode *inode, u64 *ptid)
Sage Weila8599bd2009-10-06 11:31:12 -07001848{
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -07001849 struct ceph_mds_client *mdsc = ceph_sb_to_client(inode->i_sb)->mdsc;
Sage Weila8599bd2009-10-06 11:31:12 -07001850 struct ceph_inode_info *ci = ceph_inode(inode);
Yan, Zheng4fe59782013-10-31 16:44:14 +08001851 struct ceph_mds_session *session = NULL;
Yan, Zheng89b52fe2015-05-27 09:59:48 +08001852 int flushing = 0;
Yan, Zhenga2971c82015-06-10 11:09:32 +08001853 u64 flush_tid = 0, oldest_flush_tid = 0;
Sage Weila8599bd2009-10-06 11:31:12 -07001854
1855retry:
Sage Weilbe655592011-11-30 09:47:09 -08001856 spin_lock(&ci->i_ceph_lock);
Sage Weile9964c12010-03-01 15:16:56 -08001857 if (ci->i_ceph_flags & CEPH_I_NOFLUSH) {
1858 dout("try_flush_caps skipping %p I_NOFLUSH set\n", inode);
1859 goto out;
1860 }
Sage Weila8599bd2009-10-06 11:31:12 -07001861 if (ci->i_dirty_caps && ci->i_auth_cap) {
1862 struct ceph_cap *cap = ci->i_auth_cap;
1863 int used = __ceph_caps_used(ci);
1864 int want = __ceph_caps_wanted(ci);
1865 int delayed;
1866
Yan, Zheng4fe59782013-10-31 16:44:14 +08001867 if (!session || session != cap->session) {
Sage Weilbe655592011-11-30 09:47:09 -08001868 spin_unlock(&ci->i_ceph_lock);
Yan, Zheng4fe59782013-10-31 16:44:14 +08001869 if (session)
1870 mutex_unlock(&session->s_mutex);
Sage Weila8599bd2009-10-06 11:31:12 -07001871 session = cap->session;
1872 mutex_lock(&session->s_mutex);
1873 goto retry;
1874 }
Sage Weila8599bd2009-10-06 11:31:12 -07001875 if (cap->session->s_state < CEPH_MDS_SESSION_OPEN)
1876 goto out;
1877
Yan, Zhenga2971c82015-06-10 11:09:32 +08001878 flushing = __mark_caps_flushing(inode, session, &flush_tid,
1879 &oldest_flush_tid);
Sage Weila8599bd2009-10-06 11:31:12 -07001880
Sage Weilbe655592011-11-30 09:47:09 -08001881 /* __send_cap drops i_ceph_lock */
Sage Weila8599bd2009-10-06 11:31:12 -07001882 delayed = __send_cap(mdsc, cap, CEPH_CAP_OP_FLUSH, used, want,
Yan, Zheng553adfd2015-06-09 15:48:57 +08001883 (cap->issued | cap->implemented),
Yan, Zhenga2971c82015-06-10 11:09:32 +08001884 flushing, flush_tid, oldest_flush_tid);
Sage Weila8599bd2009-10-06 11:31:12 -07001885
Yan, Zheng553adfd2015-06-09 15:48:57 +08001886 if (delayed) {
1887 spin_lock(&ci->i_ceph_lock);
Yan, Zheng89b52fe2015-05-27 09:59:48 +08001888 __cap_delay_requeue(mdsc, ci);
Yan, Zheng553adfd2015-06-09 15:48:57 +08001889 spin_unlock(&ci->i_ceph_lock);
1890 }
1891 } else {
1892 struct rb_node *n = rb_last(&ci->i_cap_flush_tree);
1893 if (n) {
1894 struct ceph_cap_flush *cf =
1895 rb_entry(n, struct ceph_cap_flush, i_node);
1896 flush_tid = cf->tid;
1897 }
1898 flushing = ci->i_flushing_caps;
1899 spin_unlock(&ci->i_ceph_lock);
Sage Weila8599bd2009-10-06 11:31:12 -07001900 }
1901out:
Yan, Zheng4fe59782013-10-31 16:44:14 +08001902 if (session)
Sage Weila8599bd2009-10-06 11:31:12 -07001903 mutex_unlock(&session->s_mutex);
Yan, Zheng553adfd2015-06-09 15:48:57 +08001904
1905 *ptid = flush_tid;
Sage Weila8599bd2009-10-06 11:31:12 -07001906 return flushing;
1907}
1908
1909/*
1910 * Return true if we've flushed caps through the given flush_tid.
1911 */
Yan, Zheng553adfd2015-06-09 15:48:57 +08001912static int caps_are_flushed(struct inode *inode, u64 flush_tid)
Sage Weila8599bd2009-10-06 11:31:12 -07001913{
1914 struct ceph_inode_info *ci = ceph_inode(inode);
Yan, Zheng553adfd2015-06-09 15:48:57 +08001915 struct ceph_cap_flush *cf;
1916 struct rb_node *n;
1917 int ret = 1;
Sage Weila8599bd2009-10-06 11:31:12 -07001918
Sage Weilbe655592011-11-30 09:47:09 -08001919 spin_lock(&ci->i_ceph_lock);
Yan, Zheng553adfd2015-06-09 15:48:57 +08001920 n = rb_first(&ci->i_cap_flush_tree);
1921 if (n) {
1922 cf = rb_entry(n, struct ceph_cap_flush, i_node);
1923 if (cf->tid <= flush_tid)
Sage Weila8599bd2009-10-06 11:31:12 -07001924 ret = 0;
Yan, Zheng89b52fe2015-05-27 09:59:48 +08001925 }
Sage Weilbe655592011-11-30 09:47:09 -08001926 spin_unlock(&ci->i_ceph_lock);
Sage Weila8599bd2009-10-06 11:31:12 -07001927 return ret;
1928}
1929
1930/*
Yan, Zheng68cd5b42015-10-27 18:36:06 +08001931 * wait for any unsafe requests to complete.
Yan, Zhengda819c82015-05-27 11:19:34 +08001932 */
Yan, Zheng68cd5b42015-10-27 18:36:06 +08001933static int unsafe_request_wait(struct inode *inode)
Yan, Zhengda819c82015-05-27 11:19:34 +08001934{
1935 struct ceph_inode_info *ci = ceph_inode(inode);
Yan, Zheng68cd5b42015-10-27 18:36:06 +08001936 struct ceph_mds_request *req1 = NULL, *req2 = NULL;
1937 int ret, err = 0;
Yan, Zhengda819c82015-05-27 11:19:34 +08001938
1939 spin_lock(&ci->i_unsafe_lock);
Yan, Zheng68cd5b42015-10-27 18:36:06 +08001940 if (S_ISDIR(inode->i_mode) && !list_empty(&ci->i_unsafe_dirops)) {
1941 req1 = list_last_entry(&ci->i_unsafe_dirops,
1942 struct ceph_mds_request,
1943 r_unsafe_dir_item);
1944 ceph_mdsc_get_request(req1);
1945 }
1946 if (!list_empty(&ci->i_unsafe_iops)) {
1947 req2 = list_last_entry(&ci->i_unsafe_iops,
1948 struct ceph_mds_request,
1949 r_unsafe_target_item);
1950 ceph_mdsc_get_request(req2);
1951 }
Yan, Zhengda819c82015-05-27 11:19:34 +08001952 spin_unlock(&ci->i_unsafe_lock);
Yan, Zheng68cd5b42015-10-27 18:36:06 +08001953
1954 dout("unsafe_requeset_wait %p wait on tid %llu %llu\n",
1955 inode, req1 ? req1->r_tid : 0ULL, req2 ? req2->r_tid : 0ULL);
1956 if (req1) {
1957 ret = !wait_for_completion_timeout(&req1->r_safe_completion,
1958 ceph_timeout_jiffies(req1->r_timeout));
1959 if (ret)
1960 err = -EIO;
1961 ceph_mdsc_put_request(req1);
1962 }
1963 if (req2) {
1964 ret = !wait_for_completion_timeout(&req2->r_safe_completion,
1965 ceph_timeout_jiffies(req2->r_timeout));
1966 if (ret)
1967 err = -EIO;
1968 ceph_mdsc_put_request(req2);
1969 }
1970 return err;
Yan, Zhengda819c82015-05-27 11:19:34 +08001971}
1972
Josef Bacik02c24a82011-07-16 20:44:56 -04001973int ceph_fsync(struct file *file, loff_t start, loff_t end, int datasync)
Sage Weila8599bd2009-10-06 11:31:12 -07001974{
Christoph Hellwig7ea80852010-05-26 17:53:25 +02001975 struct inode *inode = file->f_mapping->host;
Sage Weila8599bd2009-10-06 11:31:12 -07001976 struct ceph_inode_info *ci = ceph_inode(inode);
Yan, Zheng553adfd2015-06-09 15:48:57 +08001977 u64 flush_tid;
Sage Weila8599bd2009-10-06 11:31:12 -07001978 int ret;
1979 int dirty;
1980
1981 dout("fsync %p%s\n", inode, datasync ? " datasync" : "");
Yan, Zheng9a5530c2016-06-15 16:29:18 +08001982
1983 ceph_sync_write_wait(inode);
Sage Weila8599bd2009-10-06 11:31:12 -07001984
Josef Bacik02c24a82011-07-16 20:44:56 -04001985 ret = filemap_write_and_wait_range(inode->i_mapping, start, end);
Sage Weila8599bd2009-10-06 11:31:12 -07001986 if (ret < 0)
Yan, Zhengda819c82015-05-27 11:19:34 +08001987 goto out;
1988
1989 if (datasync)
1990 goto out;
1991
Al Viro59551022016-01-22 15:40:57 -05001992 inode_lock(inode);
Sage Weila8599bd2009-10-06 11:31:12 -07001993
Yan, Zheng553adfd2015-06-09 15:48:57 +08001994 dirty = try_flush_caps(inode, &flush_tid);
Sage Weila8599bd2009-10-06 11:31:12 -07001995 dout("fsync dirty caps are %s\n", ceph_cap_string(dirty));
1996
Yan, Zheng68cd5b42015-10-27 18:36:06 +08001997 ret = unsafe_request_wait(inode);
Yan, Zhengda819c82015-05-27 11:19:34 +08001998
Sage Weila8599bd2009-10-06 11:31:12 -07001999 /*
2000 * only wait on non-file metadata writeback (the mds
2001 * can recover size and mtime, so we don't need to
2002 * wait for that)
2003 */
Yan, Zhengda819c82015-05-27 11:19:34 +08002004 if (!ret && (dirty & ~CEPH_CAP_ANY_FILE_WR)) {
Sage Weila8599bd2009-10-06 11:31:12 -07002005 ret = wait_event_interruptible(ci->i_cap_wq,
Yan, Zhengda819c82015-05-27 11:19:34 +08002006 caps_are_flushed(inode, flush_tid));
Sage Weila8599bd2009-10-06 11:31:12 -07002007 }
Al Viro59551022016-01-22 15:40:57 -05002008 inode_unlock(inode);
Yan, Zhengda819c82015-05-27 11:19:34 +08002009out:
2010 dout("fsync %p%s result=%d\n", inode, datasync ? " datasync" : "", ret);
Sage Weila8599bd2009-10-06 11:31:12 -07002011 return ret;
2012}
2013
2014/*
2015 * Flush any dirty caps back to the mds. If we aren't asked to wait,
2016 * queue inode for flush but don't do so immediately, because we can
2017 * get by with fewer MDS messages if we wait for data writeback to
2018 * complete first.
2019 */
Stephen Rothwellf1a3d572010-01-18 11:53:08 +11002020int ceph_write_inode(struct inode *inode, struct writeback_control *wbc)
Sage Weila8599bd2009-10-06 11:31:12 -07002021{
2022 struct ceph_inode_info *ci = ceph_inode(inode);
Yan, Zheng553adfd2015-06-09 15:48:57 +08002023 u64 flush_tid;
Sage Weila8599bd2009-10-06 11:31:12 -07002024 int err = 0;
2025 int dirty;
Stephen Rothwellf1a3d572010-01-18 11:53:08 +11002026 int wait = wbc->sync_mode == WB_SYNC_ALL;
Sage Weila8599bd2009-10-06 11:31:12 -07002027
2028 dout("write_inode %p wait=%d\n", inode, wait);
2029 if (wait) {
Yan, Zheng553adfd2015-06-09 15:48:57 +08002030 dirty = try_flush_caps(inode, &flush_tid);
Sage Weila8599bd2009-10-06 11:31:12 -07002031 if (dirty)
2032 err = wait_event_interruptible(ci->i_cap_wq,
2033 caps_are_flushed(inode, flush_tid));
2034 } else {
Cheng Renquan640ef792010-03-26 17:40:33 +08002035 struct ceph_mds_client *mdsc =
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -07002036 ceph_sb_to_client(inode->i_sb)->mdsc;
Sage Weila8599bd2009-10-06 11:31:12 -07002037
Sage Weilbe655592011-11-30 09:47:09 -08002038 spin_lock(&ci->i_ceph_lock);
Sage Weila8599bd2009-10-06 11:31:12 -07002039 if (__ceph_caps_dirty(ci))
2040 __cap_delay_requeue_front(mdsc, ci);
Sage Weilbe655592011-11-30 09:47:09 -08002041 spin_unlock(&ci->i_ceph_lock);
Sage Weila8599bd2009-10-06 11:31:12 -07002042 }
2043 return err;
2044}
2045
2046/*
2047 * After a recovering MDS goes active, we need to resend any caps
2048 * we were flushing.
2049 *
2050 * Caller holds session->s_mutex.
2051 */
2052static void kick_flushing_capsnaps(struct ceph_mds_client *mdsc,
2053 struct ceph_mds_session *session)
2054{
2055 struct ceph_cap_snap *capsnap;
2056
2057 dout("kick_flushing_capsnaps mds%d\n", session->s_mds);
2058 list_for_each_entry(capsnap, &session->s_cap_snaps_flushing,
2059 flushing_item) {
2060 struct ceph_inode_info *ci = capsnap->ci;
2061 struct inode *inode = &ci->vfs_inode;
2062 struct ceph_cap *cap;
2063
Sage Weilbe655592011-11-30 09:47:09 -08002064 spin_lock(&ci->i_ceph_lock);
Sage Weila8599bd2009-10-06 11:31:12 -07002065 cap = ci->i_auth_cap;
2066 if (cap && cap->session == session) {
2067 dout("kick_flushing_caps %p cap %p capsnap %p\n", inode,
2068 cap, capsnap);
Sage Weile8351242010-09-17 08:03:08 -07002069 __ceph_flush_snaps(ci, &session, 1);
Sage Weila8599bd2009-10-06 11:31:12 -07002070 } else {
2071 pr_err("%p auth cap %p not mds%d ???\n", inode,
2072 cap, session->s_mds);
Sage Weila8599bd2009-10-06 11:31:12 -07002073 }
Sage Weilbe655592011-11-30 09:47:09 -08002074 spin_unlock(&ci->i_ceph_lock);
Sage Weila8599bd2009-10-06 11:31:12 -07002075 }
2076}
2077
Yan, Zheng553adfd2015-06-09 15:48:57 +08002078static int __kick_flushing_caps(struct ceph_mds_client *mdsc,
2079 struct ceph_mds_session *session,
Yan, Zhengfc927cd2015-07-20 09:50:58 +08002080 struct ceph_inode_info *ci)
Yan, Zheng553adfd2015-06-09 15:48:57 +08002081{
2082 struct inode *inode = &ci->vfs_inode;
2083 struct ceph_cap *cap;
2084 struct ceph_cap_flush *cf;
2085 struct rb_node *n;
2086 int delayed = 0;
2087 u64 first_tid = 0;
Yan, Zhenga2971c82015-06-10 11:09:32 +08002088 u64 oldest_flush_tid;
2089
2090 spin_lock(&mdsc->cap_dirty_lock);
2091 oldest_flush_tid = __get_oldest_flush_tid(mdsc);
2092 spin_unlock(&mdsc->cap_dirty_lock);
Yan, Zheng553adfd2015-06-09 15:48:57 +08002093
2094 while (true) {
2095 spin_lock(&ci->i_ceph_lock);
2096 cap = ci->i_auth_cap;
2097 if (!(cap && cap->session == session)) {
2098 pr_err("%p auth cap %p not mds%d ???\n", inode,
2099 cap, session->s_mds);
2100 spin_unlock(&ci->i_ceph_lock);
2101 break;
2102 }
2103
2104 for (n = rb_first(&ci->i_cap_flush_tree); n; n = rb_next(n)) {
2105 cf = rb_entry(n, struct ceph_cap_flush, i_node);
Yan, Zhengfc927cd2015-07-20 09:50:58 +08002106 if (cf->tid >= first_tid)
Yan, Zheng553adfd2015-06-09 15:48:57 +08002107 break;
2108 }
2109 if (!n) {
2110 spin_unlock(&ci->i_ceph_lock);
2111 break;
2112 }
2113
2114 cf = rb_entry(n, struct ceph_cap_flush, i_node);
Yan, Zhenge548e9b2015-06-10 15:17:56 +08002115
Yan, Zheng553adfd2015-06-09 15:48:57 +08002116 first_tid = cf->tid + 1;
2117
2118 dout("kick_flushing_caps %p cap %p tid %llu %s\n", inode,
2119 cap, cf->tid, ceph_cap_string(cf->caps));
2120 delayed |= __send_cap(mdsc, cap, CEPH_CAP_OP_FLUSH,
2121 __ceph_caps_used(ci),
2122 __ceph_caps_wanted(ci),
2123 cap->issued | cap->implemented,
Yan, Zhenga2971c82015-06-10 11:09:32 +08002124 cf->caps, cf->tid, oldest_flush_tid);
Yan, Zheng553adfd2015-06-09 15:48:57 +08002125 }
2126 return delayed;
2127}
2128
Yan, Zhenge548e9b2015-06-10 15:17:56 +08002129void ceph_early_kick_flushing_caps(struct ceph_mds_client *mdsc,
2130 struct ceph_mds_session *session)
2131{
2132 struct ceph_inode_info *ci;
2133 struct ceph_cap *cap;
Yan, Zhenge548e9b2015-06-10 15:17:56 +08002134
2135 dout("early_kick_flushing_caps mds%d\n", session->s_mds);
2136 list_for_each_entry(ci, &session->s_cap_flushing, i_flushing_item) {
2137 spin_lock(&ci->i_ceph_lock);
2138 cap = ci->i_auth_cap;
2139 if (!(cap && cap->session == session)) {
2140 pr_err("%p auth cap %p not mds%d ???\n",
2141 &ci->vfs_inode, cap, session->s_mds);
2142 spin_unlock(&ci->i_ceph_lock);
2143 continue;
2144 }
2145
2146
2147 /*
2148 * if flushing caps were revoked, we re-send the cap flush
2149 * in client reconnect stage. This guarantees MDS * processes
2150 * the cap flush message before issuing the flushing caps to
2151 * other client.
2152 */
2153 if ((cap->issued & ci->i_flushing_caps) !=
2154 ci->i_flushing_caps) {
2155 spin_unlock(&ci->i_ceph_lock);
Yan, Zhengfc927cd2015-07-20 09:50:58 +08002156 if (!__kick_flushing_caps(mdsc, session, ci))
Yan, Zhenge548e9b2015-06-10 15:17:56 +08002157 continue;
2158 spin_lock(&ci->i_ceph_lock);
2159 }
2160
Yan, Zhenge548e9b2015-06-10 15:17:56 +08002161 spin_unlock(&ci->i_ceph_lock);
2162 }
2163}
2164
Sage Weila8599bd2009-10-06 11:31:12 -07002165void ceph_kick_flushing_caps(struct ceph_mds_client *mdsc,
2166 struct ceph_mds_session *session)
2167{
2168 struct ceph_inode_info *ci;
2169
2170 kick_flushing_capsnaps(mdsc, session);
2171
2172 dout("kick_flushing_caps mds%d\n", session->s_mds);
2173 list_for_each_entry(ci, &session->s_cap_flushing, i_flushing_item) {
Yan, Zhengfc927cd2015-07-20 09:50:58 +08002174 int delayed = __kick_flushing_caps(mdsc, session, ci);
Yan, Zheng553adfd2015-06-09 15:48:57 +08002175 if (delayed) {
2176 spin_lock(&ci->i_ceph_lock);
2177 __cap_delay_requeue(mdsc, ci);
Sage Weilbe655592011-11-30 09:47:09 -08002178 spin_unlock(&ci->i_ceph_lock);
Sage Weila8599bd2009-10-06 11:31:12 -07002179 }
2180 }
2181}
2182
Sage Weil088b3f52011-01-18 08:56:01 -08002183static void kick_flushing_inode_caps(struct ceph_mds_client *mdsc,
2184 struct ceph_mds_session *session,
2185 struct inode *inode)
2186{
2187 struct ceph_inode_info *ci = ceph_inode(inode);
2188 struct ceph_cap *cap;
Sage Weil088b3f52011-01-18 08:56:01 -08002189
Sage Weilbe655592011-11-30 09:47:09 -08002190 spin_lock(&ci->i_ceph_lock);
Sage Weil088b3f52011-01-18 08:56:01 -08002191 cap = ci->i_auth_cap;
Yan, Zheng8310b082015-06-09 17:20:12 +08002192 dout("kick_flushing_inode_caps %p flushing %s\n", inode,
2193 ceph_cap_string(ci->i_flushing_caps));
Yan, Zheng005c4692013-05-31 16:40:24 +08002194
Sage Weil088b3f52011-01-18 08:56:01 -08002195 __ceph_flush_snaps(ci, &session, 1);
Yan, Zheng005c4692013-05-31 16:40:24 +08002196
Sage Weil088b3f52011-01-18 08:56:01 -08002197 if (ci->i_flushing_caps) {
Yan, Zheng553adfd2015-06-09 15:48:57 +08002198 int delayed;
2199
Yan, Zheng005c4692013-05-31 16:40:24 +08002200 spin_lock(&mdsc->cap_dirty_lock);
2201 list_move_tail(&ci->i_flushing_item,
2202 &cap->session->s_cap_flushing);
2203 spin_unlock(&mdsc->cap_dirty_lock);
2204
Yan, Zheng553adfd2015-06-09 15:48:57 +08002205 spin_unlock(&ci->i_ceph_lock);
2206
Yan, Zhengfc927cd2015-07-20 09:50:58 +08002207 delayed = __kick_flushing_caps(mdsc, session, ci);
Sage Weil088b3f52011-01-18 08:56:01 -08002208 if (delayed) {
Sage Weilbe655592011-11-30 09:47:09 -08002209 spin_lock(&ci->i_ceph_lock);
Sage Weil088b3f52011-01-18 08:56:01 -08002210 __cap_delay_requeue(mdsc, ci);
Sage Weilbe655592011-11-30 09:47:09 -08002211 spin_unlock(&ci->i_ceph_lock);
Sage Weil088b3f52011-01-18 08:56:01 -08002212 }
2213 } else {
Sage Weilbe655592011-11-30 09:47:09 -08002214 spin_unlock(&ci->i_ceph_lock);
Sage Weil088b3f52011-01-18 08:56:01 -08002215 }
2216}
2217
Sage Weila8599bd2009-10-06 11:31:12 -07002218
2219/*
2220 * Take references to capabilities we hold, so that we don't release
2221 * them to the MDS prematurely.
2222 *
Sage Weilbe655592011-11-30 09:47:09 -08002223 * Protected by i_ceph_lock.
Sage Weila8599bd2009-10-06 11:31:12 -07002224 */
Yan, Zheng5dda377c2015-04-30 14:40:54 +08002225static void __take_cap_refs(struct ceph_inode_info *ci, int got,
2226 bool snap_rwsem_locked)
Sage Weila8599bd2009-10-06 11:31:12 -07002227{
2228 if (got & CEPH_CAP_PIN)
2229 ci->i_pin_ref++;
2230 if (got & CEPH_CAP_FILE_RD)
2231 ci->i_rd_ref++;
2232 if (got & CEPH_CAP_FILE_CACHE)
2233 ci->i_rdcache_ref++;
Yan, Zheng5dda377c2015-04-30 14:40:54 +08002234 if (got & CEPH_CAP_FILE_WR) {
2235 if (ci->i_wr_ref == 0 && !ci->i_head_snapc) {
2236 BUG_ON(!snap_rwsem_locked);
2237 ci->i_head_snapc = ceph_get_snap_context(
2238 ci->i_snap_realm->cached_context);
2239 }
Sage Weila8599bd2009-10-06 11:31:12 -07002240 ci->i_wr_ref++;
Yan, Zheng5dda377c2015-04-30 14:40:54 +08002241 }
Sage Weila8599bd2009-10-06 11:31:12 -07002242 if (got & CEPH_CAP_FILE_BUFFER) {
Henry C Changd3d07202011-05-11 10:29:54 +00002243 if (ci->i_wb_ref == 0)
Sage Weil3772d262011-05-03 09:28:08 -07002244 ihold(&ci->vfs_inode);
Henry C Changd3d07202011-05-11 10:29:54 +00002245 ci->i_wb_ref++;
2246 dout("__take_cap_refs %p wb %d -> %d (?)\n",
2247 &ci->vfs_inode, ci->i_wb_ref-1, ci->i_wb_ref);
Sage Weila8599bd2009-10-06 11:31:12 -07002248 }
2249}
2250
2251/*
2252 * Try to grab cap references. Specify those refs we @want, and the
2253 * minimal set we @need. Also include the larger offset we are writing
2254 * to (when applicable), and check against max_size here as well.
2255 * Note that caller is responsible for ensuring max_size increases are
2256 * requested from the MDS.
2257 */
2258static int try_get_cap_refs(struct ceph_inode_info *ci, int need, int want,
Yan, Zheng5dda377c2015-04-30 14:40:54 +08002259 loff_t endoff, bool nonblock, int *got, int *err)
Sage Weila8599bd2009-10-06 11:31:12 -07002260{
2261 struct inode *inode = &ci->vfs_inode;
Yan, Zheng5dda377c2015-04-30 14:40:54 +08002262 struct ceph_mds_client *mdsc = ceph_inode_to_client(inode)->mdsc;
Sage Weila8599bd2009-10-06 11:31:12 -07002263 int ret = 0;
Yan, Zhengc4d4a582015-01-09 15:56:18 +08002264 int have, implemented;
Sage Weil195d3ce2010-03-01 09:57:54 -08002265 int file_wanted;
Yan, Zheng5dda377c2015-04-30 14:40:54 +08002266 bool snap_rwsem_locked = false;
Sage Weila8599bd2009-10-06 11:31:12 -07002267
2268 dout("get_cap_refs %p need %s want %s\n", inode,
2269 ceph_cap_string(need), ceph_cap_string(want));
Yan, Zhengc4d4a582015-01-09 15:56:18 +08002270
Yan, Zheng5dda377c2015-04-30 14:40:54 +08002271again:
Sage Weilbe655592011-11-30 09:47:09 -08002272 spin_lock(&ci->i_ceph_lock);
Sage Weila8599bd2009-10-06 11:31:12 -07002273
Sage Weil195d3ce2010-03-01 09:57:54 -08002274 /* make sure file is actually open */
2275 file_wanted = __ceph_caps_file_wanted(ci);
Yan, Zheng77310322016-04-08 15:27:16 +08002276 if ((file_wanted & need) != need) {
Sage Weil195d3ce2010-03-01 09:57:54 -08002277 dout("try_get_cap_refs need %s file_wanted %s, EBADF\n",
2278 ceph_cap_string(need), ceph_cap_string(file_wanted));
Sage Weila8599bd2009-10-06 11:31:12 -07002279 *err = -EBADF;
2280 ret = 1;
Yan, Zheng3738daa2014-11-14 22:10:07 +08002281 goto out_unlock;
Sage Weila8599bd2009-10-06 11:31:12 -07002282 }
2283
Yan, Zheng37505d52013-04-12 16:11:10 +08002284 /* finish pending truncate */
2285 while (ci->i_truncate_pending) {
2286 spin_unlock(&ci->i_ceph_lock);
Yan, Zheng5dda377c2015-04-30 14:40:54 +08002287 if (snap_rwsem_locked) {
2288 up_read(&mdsc->snap_rwsem);
2289 snap_rwsem_locked = false;
2290 }
Yan, Zhengb415bf42013-07-02 12:40:19 +08002291 __ceph_do_pending_vmtruncate(inode);
Yan, Zheng37505d52013-04-12 16:11:10 +08002292 spin_lock(&ci->i_ceph_lock);
2293 }
2294
Yan, Zheng3871cbb2013-08-05 14:10:29 +08002295 have = __ceph_caps_issued(ci, &implemented);
2296
2297 if (have & need & CEPH_CAP_FILE_WR) {
Sage Weila8599bd2009-10-06 11:31:12 -07002298 if (endoff >= 0 && endoff > (loff_t)ci->i_max_size) {
2299 dout("get_cap_refs %p endoff %llu > maxsize %llu\n",
2300 inode, endoff, ci->i_max_size);
Yan, Zheng3871cbb2013-08-05 14:10:29 +08002301 if (endoff > ci->i_requested_max_size) {
Yan, Zheng5dda377c2015-04-30 14:40:54 +08002302 *err = -EAGAIN;
Sage Weila8599bd2009-10-06 11:31:12 -07002303 ret = 1;
2304 }
Yan, Zheng3738daa2014-11-14 22:10:07 +08002305 goto out_unlock;
Sage Weila8599bd2009-10-06 11:31:12 -07002306 }
2307 /*
2308 * If a sync write is in progress, we must wait, so that we
2309 * can get a final snapshot value for size+mtime.
2310 */
2311 if (__ceph_have_pending_cap_snap(ci)) {
2312 dout("get_cap_refs %p cap_snap_pending\n", inode);
Yan, Zheng3738daa2014-11-14 22:10:07 +08002313 goto out_unlock;
Sage Weila8599bd2009-10-06 11:31:12 -07002314 }
2315 }
Sage Weila8599bd2009-10-06 11:31:12 -07002316
Sage Weila8599bd2009-10-06 11:31:12 -07002317 if ((have & need) == need) {
2318 /*
2319 * Look at (implemented & ~have & not) so that we keep waiting
2320 * on transition from wanted -> needed caps. This is needed
2321 * for WRBUFFER|WR -> WR to avoid a new WR sync write from
2322 * going before a prior buffered writeback happens.
2323 */
2324 int not = want & ~(have & need);
2325 int revoking = implemented & ~have;
2326 dout("get_cap_refs %p have %s but not %s (revoking %s)\n",
2327 inode, ceph_cap_string(have), ceph_cap_string(not),
2328 ceph_cap_string(revoking));
2329 if ((revoking & not) == 0) {
Yan, Zheng5dda377c2015-04-30 14:40:54 +08002330 if (!snap_rwsem_locked &&
2331 !ci->i_head_snapc &&
2332 (need & CEPH_CAP_FILE_WR)) {
2333 if (!down_read_trylock(&mdsc->snap_rwsem)) {
2334 /*
2335 * we can not call down_read() when
2336 * task isn't in TASK_RUNNING state
2337 */
2338 if (nonblock) {
2339 *err = -EAGAIN;
2340 ret = 1;
2341 goto out_unlock;
2342 }
2343
2344 spin_unlock(&ci->i_ceph_lock);
2345 down_read(&mdsc->snap_rwsem);
2346 snap_rwsem_locked = true;
2347 goto again;
2348 }
2349 snap_rwsem_locked = true;
2350 }
Yan, Zhengc4d4a582015-01-09 15:56:18 +08002351 *got = need | (have & want);
Yan, Zhengf7f7e7a2016-05-18 20:31:55 +08002352 if ((need & CEPH_CAP_FILE_RD) &&
2353 !(*got & CEPH_CAP_FILE_CACHE))
2354 ceph_disable_fscache_readpage(ci);
Yan, Zheng5dda377c2015-04-30 14:40:54 +08002355 __take_cap_refs(ci, *got, true);
Sage Weila8599bd2009-10-06 11:31:12 -07002356 ret = 1;
2357 }
2358 } else {
Yan, Zheng03f4fcb2015-01-05 11:04:04 +08002359 int session_readonly = false;
2360 if ((need & CEPH_CAP_FILE_WR) && ci->i_auth_cap) {
2361 struct ceph_mds_session *s = ci->i_auth_cap->session;
2362 spin_lock(&s->s_cap_lock);
2363 session_readonly = s->s_readonly;
2364 spin_unlock(&s->s_cap_lock);
2365 }
2366 if (session_readonly) {
2367 dout("get_cap_refs %p needed %s but mds%d readonly\n",
2368 inode, ceph_cap_string(need), ci->i_auth_cap->mds);
2369 *err = -EROFS;
2370 ret = 1;
2371 goto out_unlock;
2372 }
2373
Yan, Zheng77310322016-04-08 15:27:16 +08002374 if (ci->i_ceph_flags & CEPH_I_CAP_DROPPED) {
2375 int mds_wanted;
2376 if (ACCESS_ONCE(mdsc->fsc->mount_state) ==
2377 CEPH_MOUNT_SHUTDOWN) {
2378 dout("get_cap_refs %p forced umount\n", inode);
2379 *err = -EIO;
2380 ret = 1;
2381 goto out_unlock;
2382 }
2383 mds_wanted = __ceph_caps_mds_wanted(ci);
2384 if ((mds_wanted & need) != need) {
2385 dout("get_cap_refs %p caps were dropped"
2386 " (session killed?)\n", inode);
2387 *err = -ESTALE;
2388 ret = 1;
2389 goto out_unlock;
2390 }
2391 if ((mds_wanted & file_wanted) ==
2392 (file_wanted & (CEPH_CAP_FILE_RD|CEPH_CAP_FILE_WR)))
2393 ci->i_ceph_flags &= ~CEPH_I_CAP_DROPPED;
Yan, Zheng48fec5d2015-07-01 16:27:46 +08002394 }
2395
Sage Weila8599bd2009-10-06 11:31:12 -07002396 dout("get_cap_refs %p have %s needed %s\n", inode,
2397 ceph_cap_string(have), ceph_cap_string(need));
2398 }
Yan, Zheng3738daa2014-11-14 22:10:07 +08002399out_unlock:
Sage Weilbe655592011-11-30 09:47:09 -08002400 spin_unlock(&ci->i_ceph_lock);
Yan, Zheng5dda377c2015-04-30 14:40:54 +08002401 if (snap_rwsem_locked)
2402 up_read(&mdsc->snap_rwsem);
Yan, Zheng3738daa2014-11-14 22:10:07 +08002403
Sage Weila8599bd2009-10-06 11:31:12 -07002404 dout("get_cap_refs %p ret %d got %s\n", inode,
Yan, Zhengc4d4a582015-01-09 15:56:18 +08002405 ret, ceph_cap_string(*got));
Sage Weila8599bd2009-10-06 11:31:12 -07002406 return ret;
2407}
2408
2409/*
2410 * Check the offset we are writing up to against our current
2411 * max_size. If necessary, tell the MDS we want to write to
2412 * a larger offset.
2413 */
2414static void check_max_size(struct inode *inode, loff_t endoff)
2415{
2416 struct ceph_inode_info *ci = ceph_inode(inode);
2417 int check = 0;
2418
2419 /* do we need to explicitly request a larger max_size? */
Sage Weilbe655592011-11-30 09:47:09 -08002420 spin_lock(&ci->i_ceph_lock);
Yan, Zheng3871cbb2013-08-05 14:10:29 +08002421 if (endoff >= ci->i_max_size && endoff > ci->i_wanted_max_size) {
Sage Weila8599bd2009-10-06 11:31:12 -07002422 dout("write %p at large endoff %llu, req max_size\n",
2423 inode, endoff);
2424 ci->i_wanted_max_size = endoff;
Sage Weila8599bd2009-10-06 11:31:12 -07002425 }
Yan, Zheng3871cbb2013-08-05 14:10:29 +08002426 /* duplicate ceph_check_caps()'s logic */
2427 if (ci->i_auth_cap &&
2428 (ci->i_auth_cap->issued & CEPH_CAP_FILE_WR) &&
2429 ci->i_wanted_max_size > ci->i_max_size &&
2430 ci->i_wanted_max_size > ci->i_requested_max_size)
2431 check = 1;
Sage Weilbe655592011-11-30 09:47:09 -08002432 spin_unlock(&ci->i_ceph_lock);
Sage Weila8599bd2009-10-06 11:31:12 -07002433 if (check)
2434 ceph_check_caps(ci, CHECK_CAPS_AUTHONLY, NULL);
2435}
2436
2437/*
2438 * Wait for caps, and take cap references. If we can't get a WR cap
2439 * due to a small max_size, make sure we check_max_size (and possibly
2440 * ask the mds) so we don't get hung up indefinitely.
2441 */
Yan, Zheng3738daa2014-11-14 22:10:07 +08002442int ceph_get_caps(struct ceph_inode_info *ci, int need, int want,
2443 loff_t endoff, int *got, struct page **pinned_page)
Sage Weila8599bd2009-10-06 11:31:12 -07002444{
Yan, Zheng5dda377c2015-04-30 14:40:54 +08002445 int _got, ret, err = 0;
Sage Weila8599bd2009-10-06 11:31:12 -07002446
Yan, Zheng10183a62015-04-27 15:33:28 +08002447 ret = ceph_pool_perm_check(ci, need);
2448 if (ret < 0)
2449 return ret;
2450
Yan, Zheng5dda377c2015-04-30 14:40:54 +08002451 while (true) {
2452 if (endoff > 0)
2453 check_max_size(&ci->vfs_inode, endoff);
Yan, Zhengc4d4a582015-01-09 15:56:18 +08002454
Yan, Zheng5dda377c2015-04-30 14:40:54 +08002455 err = 0;
Yan, Zhengc4d4a582015-01-09 15:56:18 +08002456 _got = 0;
Yan, Zheng5dda377c2015-04-30 14:40:54 +08002457 ret = try_get_cap_refs(ci, need, want, endoff,
2458 false, &_got, &err);
2459 if (ret) {
2460 if (err == -EAGAIN)
2461 continue;
2462 if (err < 0)
Yan, Zheng77310322016-04-08 15:27:16 +08002463 ret = err;
Yan, Zheng5dda377c2015-04-30 14:40:54 +08002464 } else {
2465 ret = wait_event_interruptible(ci->i_cap_wq,
2466 try_get_cap_refs(ci, need, want, endoff,
2467 true, &_got, &err));
2468 if (err == -EAGAIN)
2469 continue;
2470 if (err < 0)
2471 ret = err;
Yan, Zheng77310322016-04-08 15:27:16 +08002472 }
2473 if (ret < 0) {
2474 if (err == -ESTALE) {
2475 /* session was killed, try renew caps */
2476 ret = ceph_renew_caps(&ci->vfs_inode);
2477 if (ret == 0)
2478 continue;
2479 }
2480 return ret;
Yan, Zheng5dda377c2015-04-30 14:40:54 +08002481 }
Yan, Zhengc4d4a582015-01-09 15:56:18 +08002482
Yan, Zheng5dda377c2015-04-30 14:40:54 +08002483 if (ci->i_inline_version != CEPH_INLINE_NONE &&
2484 (_got & (CEPH_CAP_FILE_CACHE|CEPH_CAP_FILE_LAZYIO)) &&
2485 i_size_read(&ci->vfs_inode) > 0) {
2486 struct page *page =
2487 find_get_page(ci->vfs_inode.i_mapping, 0);
2488 if (page) {
2489 if (PageUptodate(page)) {
2490 *pinned_page = page;
2491 break;
2492 }
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03002493 put_page(page);
Yan, Zheng5dda377c2015-04-30 14:40:54 +08002494 }
2495 /*
2496 * drop cap refs first because getattr while
2497 * holding * caps refs can cause deadlock.
2498 */
2499 ceph_put_cap_refs(ci, _got);
2500 _got = 0;
2501
2502 /*
2503 * getattr request will bring inline data into
2504 * page cache
2505 */
2506 ret = __ceph_do_getattr(&ci->vfs_inode, NULL,
2507 CEPH_STAT_CAP_INLINE_DATA,
2508 true);
2509 if (ret < 0)
2510 return ret;
2511 continue;
2512 }
2513 break;
Yan, Zhengc4d4a582015-01-09 15:56:18 +08002514 }
Yan, Zheng5dda377c2015-04-30 14:40:54 +08002515
Yan, Zhengf7f7e7a2016-05-18 20:31:55 +08002516 if ((_got & CEPH_CAP_FILE_RD) && (_got & CEPH_CAP_FILE_CACHE))
2517 ceph_fscache_revalidate_cookie(ci);
2518
Yan, Zhengc4d4a582015-01-09 15:56:18 +08002519 *got = _got;
2520 return 0;
Sage Weila8599bd2009-10-06 11:31:12 -07002521}
2522
2523/*
2524 * Take cap refs. Caller must already know we hold at least one ref
2525 * on the caps in question or we don't know this is safe.
2526 */
2527void ceph_get_cap_refs(struct ceph_inode_info *ci, int caps)
2528{
Sage Weilbe655592011-11-30 09:47:09 -08002529 spin_lock(&ci->i_ceph_lock);
Yan, Zheng5dda377c2015-04-30 14:40:54 +08002530 __take_cap_refs(ci, caps, false);
Sage Weilbe655592011-11-30 09:47:09 -08002531 spin_unlock(&ci->i_ceph_lock);
Sage Weila8599bd2009-10-06 11:31:12 -07002532}
2533
Yan, Zheng86056092015-05-01 16:57:16 +08002534
2535/*
2536 * drop cap_snap that is not associated with any snapshot.
2537 * we don't need to send FLUSHSNAP message for it.
2538 */
2539static int ceph_try_drop_cap_snap(struct ceph_cap_snap *capsnap)
2540{
2541 if (!capsnap->need_flush &&
2542 !capsnap->writing && !capsnap->dirty_pages) {
2543
2544 dout("dropping cap_snap %p follows %llu\n",
2545 capsnap, capsnap->follows);
2546 ceph_put_snap_context(capsnap->context);
2547 list_del(&capsnap->ci_item);
2548 list_del(&capsnap->flushing_item);
2549 ceph_put_cap_snap(capsnap);
2550 return 1;
2551 }
2552 return 0;
2553}
2554
Sage Weila8599bd2009-10-06 11:31:12 -07002555/*
2556 * Release cap refs.
2557 *
2558 * If we released the last ref on any given cap, call ceph_check_caps
2559 * to release (or schedule a release).
2560 *
2561 * If we are releasing a WR cap (from a sync write), finalize any affected
2562 * cap_snap, and wake up any waiters.
2563 */
2564void ceph_put_cap_refs(struct ceph_inode_info *ci, int had)
2565{
2566 struct inode *inode = &ci->vfs_inode;
2567 int last = 0, put = 0, flushsnaps = 0, wake = 0;
Sage Weila8599bd2009-10-06 11:31:12 -07002568
Sage Weilbe655592011-11-30 09:47:09 -08002569 spin_lock(&ci->i_ceph_lock);
Sage Weila8599bd2009-10-06 11:31:12 -07002570 if (had & CEPH_CAP_PIN)
2571 --ci->i_pin_ref;
2572 if (had & CEPH_CAP_FILE_RD)
2573 if (--ci->i_rd_ref == 0)
2574 last++;
2575 if (had & CEPH_CAP_FILE_CACHE)
2576 if (--ci->i_rdcache_ref == 0)
2577 last++;
2578 if (had & CEPH_CAP_FILE_BUFFER) {
Henry C Changd3d07202011-05-11 10:29:54 +00002579 if (--ci->i_wb_ref == 0) {
Sage Weila8599bd2009-10-06 11:31:12 -07002580 last++;
2581 put++;
2582 }
Henry C Changd3d07202011-05-11 10:29:54 +00002583 dout("put_cap_refs %p wb %d -> %d (?)\n",
2584 inode, ci->i_wb_ref+1, ci->i_wb_ref);
Sage Weila8599bd2009-10-06 11:31:12 -07002585 }
2586 if (had & CEPH_CAP_FILE_WR)
2587 if (--ci->i_wr_ref == 0) {
2588 last++;
Yan, Zheng86056092015-05-01 16:57:16 +08002589 if (__ceph_have_pending_cap_snap(ci)) {
2590 struct ceph_cap_snap *capsnap =
2591 list_last_entry(&ci->i_cap_snaps,
2592 struct ceph_cap_snap,
2593 ci_item);
2594 capsnap->writing = 0;
2595 if (ceph_try_drop_cap_snap(capsnap))
2596 put++;
2597 else if (__ceph_finish_cap_snap(ci, capsnap))
2598 flushsnaps = 1;
2599 wake = 1;
Sage Weila8599bd2009-10-06 11:31:12 -07002600 }
Yan, Zheng5dda377c2015-04-30 14:40:54 +08002601 if (ci->i_wrbuffer_ref_head == 0 &&
2602 ci->i_dirty_caps == 0 &&
2603 ci->i_flushing_caps == 0) {
2604 BUG_ON(!ci->i_head_snapc);
2605 ceph_put_snap_context(ci->i_head_snapc);
2606 ci->i_head_snapc = NULL;
2607 }
Yan, Zhengdb40cc12015-03-23 20:12:20 +08002608 /* see comment in __ceph_remove_cap() */
2609 if (!__ceph_is_any_caps(ci) && ci->i_snap_realm)
2610 drop_inode_snap_realm(ci);
Sage Weila8599bd2009-10-06 11:31:12 -07002611 }
Sage Weilbe655592011-11-30 09:47:09 -08002612 spin_unlock(&ci->i_ceph_lock);
Sage Weila8599bd2009-10-06 11:31:12 -07002613
Sage Weil819ccbf2010-04-01 09:33:46 -07002614 dout("put_cap_refs %p had %s%s%s\n", inode, ceph_cap_string(had),
2615 last ? " last" : "", put ? " put" : "");
Sage Weila8599bd2009-10-06 11:31:12 -07002616
2617 if (last && !flushsnaps)
2618 ceph_check_caps(ci, 0, NULL);
2619 else if (flushsnaps)
2620 ceph_flush_snaps(ci);
2621 if (wake)
Yehuda Sadeh03066f22010-07-27 13:11:08 -07002622 wake_up_all(&ci->i_cap_wq);
Yan, Zheng86056092015-05-01 16:57:16 +08002623 while (put-- > 0)
Sage Weila8599bd2009-10-06 11:31:12 -07002624 iput(inode);
2625}
2626
2627/*
2628 * Release @nr WRBUFFER refs on dirty pages for the given @snapc snap
2629 * context. Adjust per-snap dirty page accounting as appropriate.
2630 * Once all dirty data for a cap_snap is flushed, flush snapped file
2631 * metadata back to the MDS. If we dropped the last ref, call
2632 * ceph_check_caps.
2633 */
2634void ceph_put_wrbuffer_cap_refs(struct ceph_inode_info *ci, int nr,
2635 struct ceph_snap_context *snapc)
2636{
2637 struct inode *inode = &ci->vfs_inode;
2638 int last = 0;
Sage Weil819ccbf2010-04-01 09:33:46 -07002639 int complete_capsnap = 0;
2640 int drop_capsnap = 0;
Sage Weila8599bd2009-10-06 11:31:12 -07002641 int found = 0;
2642 struct ceph_cap_snap *capsnap = NULL;
2643
Sage Weilbe655592011-11-30 09:47:09 -08002644 spin_lock(&ci->i_ceph_lock);
Sage Weila8599bd2009-10-06 11:31:12 -07002645 ci->i_wrbuffer_ref -= nr;
2646 last = !ci->i_wrbuffer_ref;
2647
2648 if (ci->i_head_snapc == snapc) {
2649 ci->i_wrbuffer_ref_head -= nr;
Sage Weil7d8cb262010-08-24 08:44:16 -07002650 if (ci->i_wrbuffer_ref_head == 0 &&
Yan, Zheng5dda377c2015-04-30 14:40:54 +08002651 ci->i_wr_ref == 0 &&
2652 ci->i_dirty_caps == 0 &&
2653 ci->i_flushing_caps == 0) {
Sage Weil7d8cb262010-08-24 08:44:16 -07002654 BUG_ON(!ci->i_head_snapc);
Sage Weila8599bd2009-10-06 11:31:12 -07002655 ceph_put_snap_context(ci->i_head_snapc);
2656 ci->i_head_snapc = NULL;
2657 }
2658 dout("put_wrbuffer_cap_refs on %p head %d/%d -> %d/%d %s\n",
2659 inode,
2660 ci->i_wrbuffer_ref+nr, ci->i_wrbuffer_ref_head+nr,
2661 ci->i_wrbuffer_ref, ci->i_wrbuffer_ref_head,
2662 last ? " LAST" : "");
2663 } else {
2664 list_for_each_entry(capsnap, &ci->i_cap_snaps, ci_item) {
2665 if (capsnap->context == snapc) {
2666 found = 1;
Sage Weila8599bd2009-10-06 11:31:12 -07002667 break;
2668 }
2669 }
2670 BUG_ON(!found);
Sage Weil819ccbf2010-04-01 09:33:46 -07002671 capsnap->dirty_pages -= nr;
2672 if (capsnap->dirty_pages == 0) {
2673 complete_capsnap = 1;
Yan, Zheng86056092015-05-01 16:57:16 +08002674 drop_capsnap = ceph_try_drop_cap_snap(capsnap);
Sage Weil819ccbf2010-04-01 09:33:46 -07002675 }
Sage Weila8599bd2009-10-06 11:31:12 -07002676 dout("put_wrbuffer_cap_refs on %p cap_snap %p "
Yan, Zheng86056092015-05-01 16:57:16 +08002677 " snap %lld %d/%d -> %d/%d %s%s\n",
Sage Weila8599bd2009-10-06 11:31:12 -07002678 inode, capsnap, capsnap->context->seq,
2679 ci->i_wrbuffer_ref+nr, capsnap->dirty_pages + nr,
2680 ci->i_wrbuffer_ref, capsnap->dirty_pages,
2681 last ? " (wrbuffer last)" : "",
Yan, Zheng86056092015-05-01 16:57:16 +08002682 complete_capsnap ? " (complete capsnap)" : "");
Sage Weila8599bd2009-10-06 11:31:12 -07002683 }
2684
Sage Weilbe655592011-11-30 09:47:09 -08002685 spin_unlock(&ci->i_ceph_lock);
Sage Weila8599bd2009-10-06 11:31:12 -07002686
2687 if (last) {
2688 ceph_check_caps(ci, CHECK_CAPS_AUTHONLY, NULL);
2689 iput(inode);
Sage Weil819ccbf2010-04-01 09:33:46 -07002690 } else if (complete_capsnap) {
Sage Weila8599bd2009-10-06 11:31:12 -07002691 ceph_flush_snaps(ci);
Yehuda Sadeh03066f22010-07-27 13:11:08 -07002692 wake_up_all(&ci->i_cap_wq);
Sage Weila8599bd2009-10-06 11:31:12 -07002693 }
Sage Weil819ccbf2010-04-01 09:33:46 -07002694 if (drop_capsnap)
2695 iput(inode);
Sage Weila8599bd2009-10-06 11:31:12 -07002696}
2697
2698/*
Yan, Zhengca20c992013-07-21 10:07:51 +08002699 * Invalidate unlinked inode's aliases, so we can drop the inode ASAP.
2700 */
2701static void invalidate_aliases(struct inode *inode)
2702{
2703 struct dentry *dn, *prev = NULL;
2704
2705 dout("invalidate_aliases inode %p\n", inode);
2706 d_prune_aliases(inode);
2707 /*
2708 * For non-directory inode, d_find_alias() only returns
J. Bruce Fieldsfc12c802014-01-16 17:42:53 -05002709 * hashed dentry. After calling d_invalidate(), the
2710 * dentry becomes unhashed.
Yan, Zhengca20c992013-07-21 10:07:51 +08002711 *
Yan, Zhenga8d436f2013-09-02 15:19:54 +08002712 * For directory inode, d_find_alias() can return
J. Bruce Fieldsfc12c802014-01-16 17:42:53 -05002713 * unhashed dentry. But directory inode should have
Yan, Zhengca20c992013-07-21 10:07:51 +08002714 * one alias at most.
2715 */
2716 while ((dn = d_find_alias(inode))) {
2717 if (dn == prev) {
2718 dput(dn);
2719 break;
2720 }
Yan, Zhenga8d436f2013-09-02 15:19:54 +08002721 d_invalidate(dn);
Yan, Zhengca20c992013-07-21 10:07:51 +08002722 if (prev)
2723 dput(prev);
2724 prev = dn;
2725 }
2726 if (prev)
2727 dput(prev);
2728}
2729
2730/*
Sage Weila8599bd2009-10-06 11:31:12 -07002731 * Handle a cap GRANT message from the MDS. (Note that a GRANT may
2732 * actually be a revocation if it specifies a smaller cap set.)
2733 *
Sage Weilbe655592011-11-30 09:47:09 -08002734 * caller holds s_mutex and i_ceph_lock, we drop both.
Sage Weila8599bd2009-10-06 11:31:12 -07002735 */
Yan, Zheng2cd698b2014-04-18 13:20:27 +08002736static void handle_cap_grant(struct ceph_mds_client *mdsc,
2737 struct inode *inode, struct ceph_mds_caps *grant,
Yan, Zheng779fe0f2016-03-07 09:35:06 +08002738 struct ceph_string **pns, u64 inline_version,
2739 void *inline_data, u32 inline_len,
Yan, Zheng2cd698b2014-04-18 13:20:27 +08002740 struct ceph_buffer *xattr_buf,
Sage Weil15637c82010-03-16 13:42:00 -07002741 struct ceph_mds_session *session,
Yan, Zheng779fe0f2016-03-07 09:35:06 +08002742 struct ceph_cap *cap, int issued)
Yan, Zheng2cd698b2014-04-18 13:20:27 +08002743 __releases(ci->i_ceph_lock)
Yan, Zheng982d6012014-12-23 15:30:54 +08002744 __releases(mdsc->snap_rwsem)
Sage Weila8599bd2009-10-06 11:31:12 -07002745{
2746 struct ceph_inode_info *ci = ceph_inode(inode);
2747 int mds = session->s_mds;
Sage Weil2f56f562010-10-27 20:59:49 -07002748 int seq = le32_to_cpu(grant->seq);
Sage Weila8599bd2009-10-06 11:31:12 -07002749 int newcaps = le32_to_cpu(grant->caps);
Yan, Zheng2cd698b2014-04-18 13:20:27 +08002750 int used, wanted, dirty;
Sage Weila8599bd2009-10-06 11:31:12 -07002751 u64 size = le64_to_cpu(grant->size);
2752 u64 max_size = le64_to_cpu(grant->max_size);
2753 struct timespec mtime, atime, ctime;
Sage Weil15637c82010-03-16 13:42:00 -07002754 int check_caps = 0;
Fabian Frederickab6c2c32014-10-09 23:16:35 +02002755 bool wake = false;
2756 bool writeback = false;
2757 bool queue_trunc = false;
2758 bool queue_invalidate = false;
Fabian Frederickab6c2c32014-10-09 23:16:35 +02002759 bool deleted_inode = false;
Yan, Zheng31c542a2014-11-14 21:41:55 +08002760 bool fill_inline = false;
Sage Weila8599bd2009-10-06 11:31:12 -07002761
Sage Weil2f56f562010-10-27 20:59:49 -07002762 dout("handle_cap_grant inode %p cap %p mds%d seq %d %s\n",
2763 inode, cap, mds, seq, ceph_cap_string(newcaps));
Sage Weila8599bd2009-10-06 11:31:12 -07002764 dout(" size %llu max_size %llu, i_size %llu\n", size, max_size,
2765 inode->i_size);
2766
Yan, Zheng11df2df2013-11-24 14:44:38 +08002767
2768 /*
2769 * auth mds of the inode changed. we received the cap export message,
2770 * but still haven't received the cap import message. handle_cap_export
2771 * updated the new auth MDS' cap.
2772 *
2773 * "ceph_seq_cmp(seq, cap->seq) <= 0" means we are processing a message
2774 * that was sent before the cap import message. So don't remove caps.
2775 */
2776 if (ceph_seq_cmp(seq, cap->seq) <= 0) {
2777 WARN_ON(cap != ci->i_auth_cap);
2778 WARN_ON(cap->cap_id != le64_to_cpu(grant->cap_id));
2779 seq = cap->seq;
2780 newcaps |= cap->issued;
2781 }
2782
Sage Weila8599bd2009-10-06 11:31:12 -07002783 /*
2784 * If CACHE is being revoked, and we have no dirty buffers,
2785 * try to invalidate (once). (If there are dirty buffers, we
2786 * will invalidate _after_ writeback.)
2787 */
Yan, Zhengfdd4e152015-06-16 20:48:56 +08002788 if (!S_ISDIR(inode->i_mode) && /* don't invalidate readdir cache */
2789 ((cap->issued & ~newcaps) & CEPH_CAP_FILE_CACHE) &&
Sage Weil3b454c42010-06-10 13:20:33 -07002790 (newcaps & CEPH_CAP_FILE_LAZYIO) == 0 &&
Yan, Zheng9abd4db2016-05-18 20:58:26 +08002791 !(ci->i_wrbuffer_ref || ci->i_wb_ref)) {
Li Wange9075742013-08-15 22:00:25 -07002792 if (try_nonblocking_invalidate(inode)) {
Sage Weila8599bd2009-10-06 11:31:12 -07002793 /* there were locked pages.. invalidate later
2794 in a separate thread. */
2795 if (ci->i_rdcache_revoking != ci->i_rdcache_gen) {
Fabian Frederickab6c2c32014-10-09 23:16:35 +02002796 queue_invalidate = true;
Sage Weila8599bd2009-10-06 11:31:12 -07002797 ci->i_rdcache_revoking = ci->i_rdcache_gen;
2798 }
Sage Weila8599bd2009-10-06 11:31:12 -07002799 }
Sage Weila8599bd2009-10-06 11:31:12 -07002800 }
2801
2802 /* side effects now are allowed */
Sage Weil685f9a5d2009-11-09 12:05:48 -08002803 cap->cap_gen = session->s_cap_gen;
Yan, Zheng11df2df2013-11-24 14:44:38 +08002804 cap->seq = seq;
Sage Weila8599bd2009-10-06 11:31:12 -07002805
2806 __check_cap_issue(ci, cap, newcaps);
2807
Yan, Zhengf98a1282014-04-17 08:55:50 +08002808 if ((newcaps & CEPH_CAP_AUTH_SHARED) &&
2809 (issued & CEPH_CAP_AUTH_EXCL) == 0) {
Sage Weila8599bd2009-10-06 11:31:12 -07002810 inode->i_mode = le32_to_cpu(grant->mode);
Eric W. Biederman05cb11c2013-01-31 02:56:19 -08002811 inode->i_uid = make_kuid(&init_user_ns, le32_to_cpu(grant->uid));
2812 inode->i_gid = make_kgid(&init_user_ns, le32_to_cpu(grant->gid));
Sage Weila8599bd2009-10-06 11:31:12 -07002813 dout("%p mode 0%o uid.gid %d.%d\n", inode, inode->i_mode,
Eric W. Biedermanbd2bae62013-01-31 04:05:39 -08002814 from_kuid(&init_user_ns, inode->i_uid),
2815 from_kgid(&init_user_ns, inode->i_gid));
Sage Weila8599bd2009-10-06 11:31:12 -07002816 }
2817
Yan, Zhengf98a1282014-04-17 08:55:50 +08002818 if ((newcaps & CEPH_CAP_AUTH_SHARED) &&
2819 (issued & CEPH_CAP_LINK_EXCL) == 0) {
Miklos Szeredibfe86842011-10-28 14:13:29 +02002820 set_nlink(inode, le32_to_cpu(grant->nlink));
Yan, Zhengca20c992013-07-21 10:07:51 +08002821 if (inode->i_nlink == 0 &&
2822 (newcaps & (CEPH_CAP_LINK_SHARED | CEPH_CAP_LINK_EXCL)))
Fabian Frederickab6c2c32014-10-09 23:16:35 +02002823 deleted_inode = true;
Yan, Zhengca20c992013-07-21 10:07:51 +08002824 }
Sage Weila8599bd2009-10-06 11:31:12 -07002825
2826 if ((issued & CEPH_CAP_XATTR_EXCL) == 0 && grant->xattr_len) {
2827 int len = le32_to_cpu(grant->xattr_len);
2828 u64 version = le64_to_cpu(grant->xattr_version);
2829
2830 if (version > ci->i_xattrs.version) {
2831 dout(" got new xattrs v%llu on %p len %d\n",
2832 version, inode, len);
2833 if (ci->i_xattrs.blob)
2834 ceph_buffer_put(ci->i_xattrs.blob);
2835 ci->i_xattrs.blob = ceph_buffer_get(xattr_buf);
2836 ci->i_xattrs.version = version;
Guangliang Zhao7221fe42013-11-11 15:18:03 +08002837 ceph_forget_all_cached_acls(inode);
Sage Weila8599bd2009-10-06 11:31:12 -07002838 }
2839 }
2840
Yan, Zhengf98a1282014-04-17 08:55:50 +08002841 if (newcaps & CEPH_CAP_ANY_RD) {
2842 /* ctime/mtime/atime? */
2843 ceph_decode_timespec(&mtime, &grant->mtime);
2844 ceph_decode_timespec(&atime, &grant->atime);
2845 ceph_decode_timespec(&ctime, &grant->ctime);
2846 ceph_fill_file_time(inode, issued,
2847 le32_to_cpu(grant->time_warp_seq),
2848 &ctime, &mtime, &atime);
2849 }
Sage Weila8599bd2009-10-06 11:31:12 -07002850
Yan, Zhengf98a1282014-04-17 08:55:50 +08002851 if (newcaps & (CEPH_CAP_ANY_FILE_RD | CEPH_CAP_ANY_FILE_WR)) {
2852 /* file layout may have changed */
Yan, Zheng76271512016-02-03 21:24:49 +08002853 s64 old_pool = ci->i_layout.pool_id;
Yan, Zheng779fe0f2016-03-07 09:35:06 +08002854 struct ceph_string *old_ns;
2855
Yan, Zheng76271512016-02-03 21:24:49 +08002856 ceph_file_layout_from_legacy(&ci->i_layout, &grant->layout);
Yan, Zheng779fe0f2016-03-07 09:35:06 +08002857 old_ns = rcu_dereference_protected(ci->i_layout.pool_ns,
2858 lockdep_is_held(&ci->i_ceph_lock));
2859 rcu_assign_pointer(ci->i_layout.pool_ns, *pns);
2860
2861 if (ci->i_layout.pool_id != old_pool || *pns != old_ns)
Yan, Zheng76271512016-02-03 21:24:49 +08002862 ci->i_ceph_flags &= ~CEPH_I_POOL_PERM;
Yan, Zheng5ea5c5e2016-02-14 18:06:41 +08002863
Yan, Zheng779fe0f2016-03-07 09:35:06 +08002864 *pns = old_ns;
2865
Yan, Zhengf98a1282014-04-17 08:55:50 +08002866 /* size/truncate_seq? */
2867 queue_trunc = ceph_fill_file_size(inode, issued,
2868 le32_to_cpu(grant->truncate_seq),
2869 le64_to_cpu(grant->truncate_size),
2870 size);
2871 /* max size increase? */
2872 if (ci->i_auth_cap == cap && max_size != ci->i_max_size) {
2873 dout("max_size %lld -> %llu\n",
2874 ci->i_max_size, max_size);
2875 ci->i_max_size = max_size;
2876 if (max_size >= ci->i_wanted_max_size) {
2877 ci->i_wanted_max_size = 0; /* reset */
2878 ci->i_requested_max_size = 0;
2879 }
Fabian Frederickab6c2c32014-10-09 23:16:35 +02002880 wake = true;
Sage Weila8599bd2009-10-06 11:31:12 -07002881 }
Sage Weila8599bd2009-10-06 11:31:12 -07002882 }
2883
2884 /* check cap bits */
2885 wanted = __ceph_caps_wanted(ci);
2886 used = __ceph_caps_used(ci);
2887 dirty = __ceph_caps_dirty(ci);
2888 dout(" my wanted = %s, used = %s, dirty %s\n",
2889 ceph_cap_string(wanted),
2890 ceph_cap_string(used),
2891 ceph_cap_string(dirty));
2892 if (wanted != le32_to_cpu(grant->wanted)) {
2893 dout("mds wanted %s -> %s\n",
2894 ceph_cap_string(le32_to_cpu(grant->wanted)),
2895 ceph_cap_string(wanted));
Yan, Zheng390306c2013-01-04 15:30:10 +08002896 /* imported cap may not have correct mds_wanted */
2897 if (le32_to_cpu(grant->op) == CEPH_CAP_OP_IMPORT)
2898 check_caps = 1;
Sage Weila8599bd2009-10-06 11:31:12 -07002899 }
2900
Sage Weila8599bd2009-10-06 11:31:12 -07002901 /* revocation, grant, or no-op? */
2902 if (cap->issued & ~newcaps) {
Sage Weil3b454c42010-06-10 13:20:33 -07002903 int revoking = cap->issued & ~newcaps;
2904
2905 dout("revocation: %s -> %s (revoking %s)\n",
2906 ceph_cap_string(cap->issued),
2907 ceph_cap_string(newcaps),
2908 ceph_cap_string(revoking));
Sage Weil0eb6cd42010-08-05 13:53:18 -07002909 if (revoking & used & CEPH_CAP_FILE_BUFFER)
Fabian Frederickab6c2c32014-10-09 23:16:35 +02002910 writeback = true; /* initiate writeback; will delay ack */
Sage Weil3b454c42010-06-10 13:20:33 -07002911 else if (revoking == CEPH_CAP_FILE_CACHE &&
2912 (newcaps & CEPH_CAP_FILE_LAZYIO) == 0 &&
2913 queue_invalidate)
2914 ; /* do nothing yet, invalidation will be queued */
2915 else if (cap == ci->i_auth_cap)
2916 check_caps = 1; /* check auth cap only */
2917 else
2918 check_caps = 2; /* check all caps */
Sage Weila8599bd2009-10-06 11:31:12 -07002919 cap->issued = newcaps;
Sage Weil978097c2010-03-08 15:27:53 -08002920 cap->implemented |= newcaps;
Sage Weila8599bd2009-10-06 11:31:12 -07002921 } else if (cap->issued == newcaps) {
2922 dout("caps unchanged: %s -> %s\n",
2923 ceph_cap_string(cap->issued), ceph_cap_string(newcaps));
2924 } else {
2925 dout("grant: %s -> %s\n", ceph_cap_string(cap->issued),
2926 ceph_cap_string(newcaps));
Yan, Zheng6ee6b9532013-07-02 12:40:21 +08002927 /* non-auth MDS is revoking the newly grant caps ? */
2928 if (cap == ci->i_auth_cap &&
2929 __ceph_caps_revoking_other(ci, cap, newcaps))
2930 check_caps = 2;
2931
Sage Weila8599bd2009-10-06 11:31:12 -07002932 cap->issued = newcaps;
2933 cap->implemented |= newcaps; /* add bits only, to
2934 * avoid stepping on a
2935 * pending revocation */
Fabian Frederickab6c2c32014-10-09 23:16:35 +02002936 wake = true;
Sage Weila8599bd2009-10-06 11:31:12 -07002937 }
Sage Weil978097c2010-03-08 15:27:53 -08002938 BUG_ON(cap->issued & ~cap->implemented);
Sage Weila8599bd2009-10-06 11:31:12 -07002939
Yan, Zheng31c542a2014-11-14 21:41:55 +08002940 if (inline_version > 0 && inline_version >= ci->i_inline_version) {
2941 ci->i_inline_version = inline_version;
2942 if (ci->i_inline_version != CEPH_INLINE_NONE &&
2943 (newcaps & (CEPH_CAP_FILE_CACHE|CEPH_CAP_FILE_LAZYIO)))
2944 fill_inline = true;
2945 }
2946
Sage Weilbe655592011-11-30 09:47:09 -08002947 spin_unlock(&ci->i_ceph_lock);
Milosz Tanski99ccbd22013-08-21 17:29:54 -04002948
Yan, Zheng2cd698b2014-04-18 13:20:27 +08002949 if (le32_to_cpu(grant->op) == CEPH_CAP_OP_IMPORT) {
Yan, Zheng2cd698b2014-04-18 13:20:27 +08002950 kick_flushing_inode_caps(mdsc, session, inode);
2951 up_read(&mdsc->snap_rwsem);
2952 if (newcaps & ~issued)
Fabian Frederickab6c2c32014-10-09 23:16:35 +02002953 wake = true;
Yan, Zheng2cd698b2014-04-18 13:20:27 +08002954 }
2955
Yan, Zheng31c542a2014-11-14 21:41:55 +08002956 if (fill_inline)
2957 ceph_fill_inline_data(inode, NULL, inline_data, inline_len);
2958
Yan, Zheng14649752016-05-20 15:41:20 +08002959 if (queue_trunc)
Yan, Zhengc6bcda62014-04-11 10:18:07 +08002960 ceph_queue_vmtruncate(inode);
Yan, Zhengc6bcda62014-04-11 10:18:07 +08002961
Sage Weil3c6f6b72010-02-09 15:24:44 -08002962 if (writeback)
Sage Weila8599bd2009-10-06 11:31:12 -07002963 /*
2964 * queue inode for writeback: we can't actually call
2965 * filemap_write_and_wait, etc. from message handler
2966 * context.
2967 */
Sage Weil3c6f6b72010-02-09 15:24:44 -08002968 ceph_queue_writeback(inode);
2969 if (queue_invalidate)
2970 ceph_queue_invalidate(inode);
Yan, Zhengca20c992013-07-21 10:07:51 +08002971 if (deleted_inode)
2972 invalidate_aliases(inode);
Sage Weila8599bd2009-10-06 11:31:12 -07002973 if (wake)
Yehuda Sadeh03066f22010-07-27 13:11:08 -07002974 wake_up_all(&ci->i_cap_wq);
Sage Weil15637c82010-03-16 13:42:00 -07002975
2976 if (check_caps == 1)
2977 ceph_check_caps(ci, CHECK_CAPS_NODELAY|CHECK_CAPS_AUTHONLY,
2978 session);
2979 else if (check_caps == 2)
2980 ceph_check_caps(ci, CHECK_CAPS_NODELAY, session);
2981 else
2982 mutex_unlock(&session->s_mutex);
Sage Weila8599bd2009-10-06 11:31:12 -07002983}
2984
2985/*
2986 * Handle FLUSH_ACK from MDS, indicating that metadata we sent to the
2987 * MDS has been safely committed.
2988 */
Sage Weil6df058c2009-12-22 11:24:33 -08002989static void handle_cap_flush_ack(struct inode *inode, u64 flush_tid,
Sage Weila8599bd2009-10-06 11:31:12 -07002990 struct ceph_mds_caps *m,
2991 struct ceph_mds_session *session,
2992 struct ceph_cap *cap)
Sage Weilbe655592011-11-30 09:47:09 -08002993 __releases(ci->i_ceph_lock)
Sage Weila8599bd2009-10-06 11:31:12 -07002994{
2995 struct ceph_inode_info *ci = ceph_inode(inode);
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -07002996 struct ceph_mds_client *mdsc = ceph_sb_to_client(inode->i_sb)->mdsc;
Yan, Zheng553adfd2015-06-09 15:48:57 +08002997 struct ceph_cap_flush *cf;
2998 struct rb_node *n;
2999 LIST_HEAD(to_remove);
Sage Weila8599bd2009-10-06 11:31:12 -07003000 unsigned seq = le32_to_cpu(m->seq);
3001 int dirty = le32_to_cpu(m->dirty);
3002 int cleaned = 0;
Sage Weilafcdaea2009-10-14 14:27:38 -07003003 int drop = 0;
Sage Weila8599bd2009-10-06 11:31:12 -07003004
Yan, Zheng553adfd2015-06-09 15:48:57 +08003005 n = rb_first(&ci->i_cap_flush_tree);
3006 while (n) {
3007 cf = rb_entry(n, struct ceph_cap_flush, i_node);
3008 n = rb_next(&cf->i_node);
3009 if (cf->tid == flush_tid)
3010 cleaned = cf->caps;
3011 if (cf->tid <= flush_tid) {
3012 rb_erase(&cf->i_node, &ci->i_cap_flush_tree);
3013 list_add_tail(&cf->list, &to_remove);
3014 } else {
3015 cleaned &= ~cf->caps;
3016 if (!cleaned)
3017 break;
3018 }
3019 }
Sage Weila8599bd2009-10-06 11:31:12 -07003020
3021 dout("handle_cap_flush_ack inode %p mds%d seq %d on %s cleaned %s,"
3022 " flushing %s -> %s\n",
3023 inode, session->s_mds, seq, ceph_cap_string(dirty),
3024 ceph_cap_string(cleaned), ceph_cap_string(ci->i_flushing_caps),
3025 ceph_cap_string(ci->i_flushing_caps & ~cleaned));
3026
Yan, Zheng8310b082015-06-09 17:20:12 +08003027 if (list_empty(&to_remove) && !cleaned)
Sage Weila8599bd2009-10-06 11:31:12 -07003028 goto out;
3029
Sage Weila8599bd2009-10-06 11:31:12 -07003030 ci->i_flushing_caps &= ~cleaned;
Sage Weila8599bd2009-10-06 11:31:12 -07003031
3032 spin_lock(&mdsc->cap_dirty_lock);
Yan, Zheng8310b082015-06-09 17:20:12 +08003033
3034 if (!list_empty(&to_remove)) {
3035 list_for_each_entry(cf, &to_remove, list)
3036 rb_erase(&cf->g_node, &mdsc->cap_flush_tree);
3037
3038 n = rb_first(&mdsc->cap_flush_tree);
3039 cf = n ? rb_entry(n, struct ceph_cap_flush, g_node) : NULL;
3040 if (!cf || cf->tid > flush_tid)
3041 wake_up_all(&mdsc->cap_flushing_wq);
3042 }
3043
Sage Weila8599bd2009-10-06 11:31:12 -07003044 if (ci->i_flushing_caps == 0) {
3045 list_del_init(&ci->i_flushing_item);
3046 if (!list_empty(&session->s_cap_flushing))
3047 dout(" mds%d still flushing cap on %p\n",
3048 session->s_mds,
3049 &list_entry(session->s_cap_flushing.next,
3050 struct ceph_inode_info,
3051 i_flushing_item)->vfs_inode);
3052 mdsc->num_cap_flushing--;
Sage Weila8599bd2009-10-06 11:31:12 -07003053 dout(" inode %p now !flushing\n", inode);
Sage Weilafcdaea2009-10-14 14:27:38 -07003054
3055 if (ci->i_dirty_caps == 0) {
3056 dout(" inode %p now clean\n", inode);
3057 BUG_ON(!list_empty(&ci->i_dirty_item));
3058 drop = 1;
Yan, Zheng5dda377c2015-04-30 14:40:54 +08003059 if (ci->i_wr_ref == 0 &&
3060 ci->i_wrbuffer_ref_head == 0) {
Sage Weil7d8cb262010-08-24 08:44:16 -07003061 BUG_ON(!ci->i_head_snapc);
3062 ceph_put_snap_context(ci->i_head_snapc);
3063 ci->i_head_snapc = NULL;
3064 }
Sage Weil76e3b392009-10-15 18:13:53 -07003065 } else {
3066 BUG_ON(list_empty(&ci->i_dirty_item));
Sage Weilafcdaea2009-10-14 14:27:38 -07003067 }
Sage Weila8599bd2009-10-06 11:31:12 -07003068 }
3069 spin_unlock(&mdsc->cap_dirty_lock);
Yehuda Sadeh03066f22010-07-27 13:11:08 -07003070 wake_up_all(&ci->i_cap_wq);
Sage Weila8599bd2009-10-06 11:31:12 -07003071
3072out:
Sage Weilbe655592011-11-30 09:47:09 -08003073 spin_unlock(&ci->i_ceph_lock);
Yan, Zheng553adfd2015-06-09 15:48:57 +08003074
3075 while (!list_empty(&to_remove)) {
3076 cf = list_first_entry(&to_remove,
3077 struct ceph_cap_flush, list);
3078 list_del(&cf->list);
Yan, Zhengf66fd9f2015-06-10 17:26:13 +08003079 ceph_free_cap_flush(cf);
Yan, Zheng553adfd2015-06-09 15:48:57 +08003080 }
Sage Weilafcdaea2009-10-14 14:27:38 -07003081 if (drop)
Sage Weila8599bd2009-10-06 11:31:12 -07003082 iput(inode);
3083}
3084
3085/*
3086 * Handle FLUSHSNAP_ACK. MDS has flushed snap data to disk and we can
3087 * throw away our cap_snap.
3088 *
3089 * Caller hold s_mutex.
3090 */
Sage Weil6df058c2009-12-22 11:24:33 -08003091static void handle_cap_flushsnap_ack(struct inode *inode, u64 flush_tid,
Sage Weila8599bd2009-10-06 11:31:12 -07003092 struct ceph_mds_caps *m,
3093 struct ceph_mds_session *session)
3094{
3095 struct ceph_inode_info *ci = ceph_inode(inode);
Yan, Zhengaffbc192015-05-05 21:22:13 +08003096 struct ceph_mds_client *mdsc = ceph_sb_to_client(inode->i_sb)->mdsc;
Sage Weila8599bd2009-10-06 11:31:12 -07003097 u64 follows = le64_to_cpu(m->snap_follows);
Sage Weila8599bd2009-10-06 11:31:12 -07003098 struct ceph_cap_snap *capsnap;
3099 int drop = 0;
3100
3101 dout("handle_cap_flushsnap_ack inode %p ci %p mds%d follows %lld\n",
3102 inode, ci, session->s_mds, follows);
3103
Sage Weilbe655592011-11-30 09:47:09 -08003104 spin_lock(&ci->i_ceph_lock);
Sage Weila8599bd2009-10-06 11:31:12 -07003105 list_for_each_entry(capsnap, &ci->i_cap_snaps, ci_item) {
3106 if (capsnap->follows == follows) {
3107 if (capsnap->flush_tid != flush_tid) {
3108 dout(" cap_snap %p follows %lld tid %lld !="
3109 " %lld\n", capsnap, follows,
3110 flush_tid, capsnap->flush_tid);
3111 break;
3112 }
3113 WARN_ON(capsnap->dirty_pages || capsnap->writing);
Sage Weil819ccbf2010-04-01 09:33:46 -07003114 dout(" removing %p cap_snap %p follows %lld\n",
3115 inode, capsnap, follows);
Sage Weila8599bd2009-10-06 11:31:12 -07003116 ceph_put_snap_context(capsnap->context);
3117 list_del(&capsnap->ci_item);
3118 list_del(&capsnap->flushing_item);
3119 ceph_put_cap_snap(capsnap);
Yan, Zhengaffbc192015-05-05 21:22:13 +08003120 wake_up_all(&mdsc->cap_flushing_wq);
Sage Weila8599bd2009-10-06 11:31:12 -07003121 drop = 1;
3122 break;
3123 } else {
3124 dout(" skipping cap_snap %p follows %lld\n",
3125 capsnap, capsnap->follows);
3126 }
3127 }
Sage Weilbe655592011-11-30 09:47:09 -08003128 spin_unlock(&ci->i_ceph_lock);
Sage Weila8599bd2009-10-06 11:31:12 -07003129 if (drop)
3130 iput(inode);
3131}
3132
3133/*
3134 * Handle TRUNC from MDS, indicating file truncation.
3135 *
3136 * caller hold s_mutex.
3137 */
3138static void handle_cap_trunc(struct inode *inode,
3139 struct ceph_mds_caps *trunc,
3140 struct ceph_mds_session *session)
Sage Weilbe655592011-11-30 09:47:09 -08003141 __releases(ci->i_ceph_lock)
Sage Weila8599bd2009-10-06 11:31:12 -07003142{
3143 struct ceph_inode_info *ci = ceph_inode(inode);
3144 int mds = session->s_mds;
3145 int seq = le32_to_cpu(trunc->seq);
3146 u32 truncate_seq = le32_to_cpu(trunc->truncate_seq);
3147 u64 truncate_size = le64_to_cpu(trunc->truncate_size);
3148 u64 size = le64_to_cpu(trunc->size);
3149 int implemented = 0;
3150 int dirty = __ceph_caps_dirty(ci);
3151 int issued = __ceph_caps_issued(ceph_inode(inode), &implemented);
3152 int queue_trunc = 0;
3153
3154 issued |= implemented | dirty;
3155
3156 dout("handle_cap_trunc inode %p mds%d seq %d to %lld seq %d\n",
3157 inode, mds, seq, truncate_size, truncate_seq);
3158 queue_trunc = ceph_fill_file_size(inode, issued,
3159 truncate_seq, truncate_size, size);
Sage Weilbe655592011-11-30 09:47:09 -08003160 spin_unlock(&ci->i_ceph_lock);
Sage Weila8599bd2009-10-06 11:31:12 -07003161
Yan, Zheng14649752016-05-20 15:41:20 +08003162 if (queue_trunc)
Sage Weil3c6f6b72010-02-09 15:24:44 -08003163 ceph_queue_vmtruncate(inode);
Sage Weila8599bd2009-10-06 11:31:12 -07003164}
3165
3166/*
3167 * Handle EXPORT from MDS. Cap is being migrated _from_ this mds to a
3168 * different one. If we are the most recent migration we've seen (as
3169 * indicated by mseq), make note of the migrating cap bits for the
3170 * duration (until we see the corresponding IMPORT).
3171 *
3172 * caller holds s_mutex
3173 */
3174static void handle_cap_export(struct inode *inode, struct ceph_mds_caps *ex,
Yan, Zheng11df2df2013-11-24 14:44:38 +08003175 struct ceph_mds_cap_peer *ph,
3176 struct ceph_mds_session *session)
Sage Weila8599bd2009-10-06 11:31:12 -07003177{
Sage Weildb354052011-05-24 11:46:31 -07003178 struct ceph_mds_client *mdsc = ceph_inode_to_client(inode)->mdsc;
Yan, Zheng11df2df2013-11-24 14:44:38 +08003179 struct ceph_mds_session *tsession = NULL;
Yan, Zhengd9df2782014-04-18 09:57:11 +08003180 struct ceph_cap *cap, *tcap, *new_cap = NULL;
Sage Weila8599bd2009-10-06 11:31:12 -07003181 struct ceph_inode_info *ci = ceph_inode(inode);
Yan, Zheng11df2df2013-11-24 14:44:38 +08003182 u64 t_cap_id;
Sage Weila8599bd2009-10-06 11:31:12 -07003183 unsigned mseq = le32_to_cpu(ex->migrate_seq);
Yan, Zheng11df2df2013-11-24 14:44:38 +08003184 unsigned t_seq, t_mseq;
3185 int target, issued;
3186 int mds = session->s_mds;
Sage Weila8599bd2009-10-06 11:31:12 -07003187
Yan, Zheng11df2df2013-11-24 14:44:38 +08003188 if (ph) {
3189 t_cap_id = le64_to_cpu(ph->cap_id);
3190 t_seq = le32_to_cpu(ph->seq);
3191 t_mseq = le32_to_cpu(ph->mseq);
3192 target = le32_to_cpu(ph->mds);
3193 } else {
3194 t_cap_id = t_seq = t_mseq = 0;
3195 target = -1;
Sage Weila8599bd2009-10-06 11:31:12 -07003196 }
3197
Yan, Zheng11df2df2013-11-24 14:44:38 +08003198 dout("handle_cap_export inode %p ci %p mds%d mseq %d target %d\n",
3199 inode, ci, mds, mseq, target);
3200retry:
3201 spin_lock(&ci->i_ceph_lock);
3202 cap = __get_cap_for_mds(ci, mds);
Yan, Zhengca665e02014-04-21 15:46:37 +08003203 if (!cap || cap->cap_id != le64_to_cpu(ex->cap_id))
Yan, Zheng11df2df2013-11-24 14:44:38 +08003204 goto out_unlock;
Sage Weil154f42c2010-06-21 13:45:04 -07003205
Yan, Zheng11df2df2013-11-24 14:44:38 +08003206 if (target < 0) {
3207 __ceph_remove_cap(cap, false);
Yan, Zheng77310322016-04-08 15:27:16 +08003208 if (!ci->i_auth_cap)
3209 ci->i_ceph_flags |= CEPH_I_CAP_DROPPED;
Yan, Zheng11df2df2013-11-24 14:44:38 +08003210 goto out_unlock;
3211 }
Sage Weildb354052011-05-24 11:46:31 -07003212
Yan, Zheng11df2df2013-11-24 14:44:38 +08003213 /*
3214 * now we know we haven't received the cap import message yet
3215 * because the exported cap still exist.
3216 */
3217
3218 issued = cap->issued;
3219 WARN_ON(issued != cap->implemented);
3220
3221 tcap = __get_cap_for_mds(ci, target);
3222 if (tcap) {
3223 /* already have caps from the target */
3224 if (tcap->cap_id != t_cap_id ||
3225 ceph_seq_cmp(tcap->seq, t_seq) < 0) {
3226 dout(" updating import cap %p mds%d\n", tcap, target);
3227 tcap->cap_id = t_cap_id;
3228 tcap->seq = t_seq - 1;
3229 tcap->issue_seq = t_seq - 1;
3230 tcap->mseq = t_mseq;
3231 tcap->issued |= issued;
3232 tcap->implemented |= issued;
3233 if (cap == ci->i_auth_cap)
3234 ci->i_auth_cap = tcap;
3235 if (ci->i_flushing_caps && ci->i_auth_cap == tcap) {
3236 spin_lock(&mdsc->cap_dirty_lock);
3237 list_move_tail(&ci->i_flushing_item,
3238 &tcap->session->s_cap_flushing);
3239 spin_unlock(&mdsc->cap_dirty_lock);
Sage Weildb354052011-05-24 11:46:31 -07003240 }
Sage Weila8599bd2009-10-06 11:31:12 -07003241 }
Yan, Zhenga096b092013-09-22 10:15:58 +08003242 __ceph_remove_cap(cap, false);
Yan, Zheng11df2df2013-11-24 14:44:38 +08003243 goto out_unlock;
Yan, Zhengd9df2782014-04-18 09:57:11 +08003244 } else if (tsession) {
Yan, Zheng11df2df2013-11-24 14:44:38 +08003245 /* add placeholder for the export tagert */
Yan, Zhengd9df2782014-04-18 09:57:11 +08003246 int flag = (cap == ci->i_auth_cap) ? CEPH_CAP_FLAG_AUTH : 0;
Yan, Zheng11df2df2013-11-24 14:44:38 +08003247 ceph_add_cap(inode, tsession, t_cap_id, -1, issued, 0,
Yan, Zhengd9df2782014-04-18 09:57:11 +08003248 t_seq - 1, t_mseq, (u64)-1, flag, &new_cap);
3249
3250 __ceph_remove_cap(cap, false);
3251 goto out_unlock;
Yan, Zheng11df2df2013-11-24 14:44:38 +08003252 }
Sage Weila8599bd2009-10-06 11:31:12 -07003253
Sage Weilbe655592011-11-30 09:47:09 -08003254 spin_unlock(&ci->i_ceph_lock);
Yan, Zheng11df2df2013-11-24 14:44:38 +08003255 mutex_unlock(&session->s_mutex);
3256
3257 /* open target session */
3258 tsession = ceph_mdsc_open_export_target_session(mdsc, target);
3259 if (!IS_ERR(tsession)) {
3260 if (mds > target) {
3261 mutex_lock(&session->s_mutex);
3262 mutex_lock_nested(&tsession->s_mutex,
3263 SINGLE_DEPTH_NESTING);
3264 } else {
3265 mutex_lock(&tsession->s_mutex);
3266 mutex_lock_nested(&session->s_mutex,
3267 SINGLE_DEPTH_NESTING);
3268 }
Yan, Zhengd9df2782014-04-18 09:57:11 +08003269 new_cap = ceph_get_cap(mdsc, NULL);
Yan, Zheng11df2df2013-11-24 14:44:38 +08003270 } else {
3271 WARN_ON(1);
3272 tsession = NULL;
3273 target = -1;
3274 }
3275 goto retry;
3276
3277out_unlock:
3278 spin_unlock(&ci->i_ceph_lock);
3279 mutex_unlock(&session->s_mutex);
3280 if (tsession) {
3281 mutex_unlock(&tsession->s_mutex);
3282 ceph_put_mds_session(tsession);
3283 }
Yan, Zhengd9df2782014-04-18 09:57:11 +08003284 if (new_cap)
3285 ceph_put_cap(mdsc, new_cap);
Sage Weila8599bd2009-10-06 11:31:12 -07003286}
3287
3288/*
Yan, Zheng2cd698b2014-04-18 13:20:27 +08003289 * Handle cap IMPORT.
Sage Weila8599bd2009-10-06 11:31:12 -07003290 *
Yan, Zheng2cd698b2014-04-18 13:20:27 +08003291 * caller holds s_mutex. acquires i_ceph_lock
Sage Weila8599bd2009-10-06 11:31:12 -07003292 */
3293static void handle_cap_import(struct ceph_mds_client *mdsc,
3294 struct inode *inode, struct ceph_mds_caps *im,
Yan, Zheng4ee6a912013-11-24 14:43:46 +08003295 struct ceph_mds_cap_peer *ph,
Sage Weila8599bd2009-10-06 11:31:12 -07003296 struct ceph_mds_session *session,
Yan, Zheng2cd698b2014-04-18 13:20:27 +08003297 struct ceph_cap **target_cap, int *old_issued)
3298 __acquires(ci->i_ceph_lock)
Sage Weila8599bd2009-10-06 11:31:12 -07003299{
3300 struct ceph_inode_info *ci = ceph_inode(inode);
Yan, Zheng2cd698b2014-04-18 13:20:27 +08003301 struct ceph_cap *cap, *ocap, *new_cap = NULL;
Sage Weila8599bd2009-10-06 11:31:12 -07003302 int mds = session->s_mds;
Yan, Zheng2cd698b2014-04-18 13:20:27 +08003303 int issued;
3304 unsigned caps = le32_to_cpu(im->caps);
Sage Weila8599bd2009-10-06 11:31:12 -07003305 unsigned wanted = le32_to_cpu(im->wanted);
3306 unsigned seq = le32_to_cpu(im->seq);
3307 unsigned mseq = le32_to_cpu(im->migrate_seq);
3308 u64 realmino = le64_to_cpu(im->realm);
3309 u64 cap_id = le64_to_cpu(im->cap_id);
Yan, Zheng4ee6a912013-11-24 14:43:46 +08003310 u64 p_cap_id;
3311 int peer;
Sage Weila8599bd2009-10-06 11:31:12 -07003312
Yan, Zheng4ee6a912013-11-24 14:43:46 +08003313 if (ph) {
3314 p_cap_id = le64_to_cpu(ph->cap_id);
3315 peer = le32_to_cpu(ph->mds);
Sage Weila8599bd2009-10-06 11:31:12 -07003316 } else {
Yan, Zheng4ee6a912013-11-24 14:43:46 +08003317 p_cap_id = 0;
3318 peer = -1;
Sage Weila8599bd2009-10-06 11:31:12 -07003319 }
3320
Yan, Zheng4ee6a912013-11-24 14:43:46 +08003321 dout("handle_cap_import inode %p ci %p mds%d mseq %d peer %d\n",
3322 inode, ci, mds, mseq, peer);
3323
Yan, Zhengd9df2782014-04-18 09:57:11 +08003324retry:
Yan, Zheng4ee6a912013-11-24 14:43:46 +08003325 spin_lock(&ci->i_ceph_lock);
Yan, Zhengd9df2782014-04-18 09:57:11 +08003326 cap = __get_cap_for_mds(ci, mds);
3327 if (!cap) {
3328 if (!new_cap) {
3329 spin_unlock(&ci->i_ceph_lock);
3330 new_cap = ceph_get_cap(mdsc, NULL);
3331 goto retry;
3332 }
Yan, Zheng2cd698b2014-04-18 13:20:27 +08003333 cap = new_cap;
3334 } else {
3335 if (new_cap) {
3336 ceph_put_cap(mdsc, new_cap);
3337 new_cap = NULL;
3338 }
Yan, Zhengd9df2782014-04-18 09:57:11 +08003339 }
3340
Yan, Zheng2cd698b2014-04-18 13:20:27 +08003341 __ceph_caps_issued(ci, &issued);
3342 issued |= __ceph_caps_dirty(ci);
3343
3344 ceph_add_cap(inode, session, cap_id, -1, caps, wanted, seq, mseq,
Yan, Zhengd9df2782014-04-18 09:57:11 +08003345 realmino, CEPH_CAP_FLAG_AUTH, &new_cap);
3346
Yan, Zheng2cd698b2014-04-18 13:20:27 +08003347 ocap = peer >= 0 ? __get_cap_for_mds(ci, peer) : NULL;
3348 if (ocap && ocap->cap_id == p_cap_id) {
Yan, Zheng4ee6a912013-11-24 14:43:46 +08003349 dout(" remove export cap %p mds%d flags %d\n",
Yan, Zheng2cd698b2014-04-18 13:20:27 +08003350 ocap, peer, ph->flags);
Yan, Zheng4ee6a912013-11-24 14:43:46 +08003351 if ((ph->flags & CEPH_CAP_FLAG_AUTH) &&
Yan, Zheng2cd698b2014-04-18 13:20:27 +08003352 (ocap->seq != le32_to_cpu(ph->seq) ||
3353 ocap->mseq != le32_to_cpu(ph->mseq))) {
Yan, Zheng4ee6a912013-11-24 14:43:46 +08003354 pr_err("handle_cap_import: mismatched seq/mseq: "
3355 "ino (%llx.%llx) mds%d seq %d mseq %d "
3356 "importer mds%d has peer seq %d mseq %d\n",
Yan, Zheng2cd698b2014-04-18 13:20:27 +08003357 ceph_vinop(inode), peer, ocap->seq,
3358 ocap->mseq, mds, le32_to_cpu(ph->seq),
Yan, Zheng4ee6a912013-11-24 14:43:46 +08003359 le32_to_cpu(ph->mseq));
3360 }
Yan, Zheng2cd698b2014-04-18 13:20:27 +08003361 __ceph_remove_cap(ocap, (ph->flags & CEPH_CAP_FLAG_RELEASE));
Yan, Zheng4ee6a912013-11-24 14:43:46 +08003362 }
3363
3364 /* make sure we re-request max_size, if necessary */
3365 ci->i_wanted_max_size = 0;
3366 ci->i_requested_max_size = 0;
Yan, Zheng4ee6a912013-11-24 14:43:46 +08003367
Yan, Zheng2cd698b2014-04-18 13:20:27 +08003368 *old_issued = issued;
3369 *target_cap = cap;
Sage Weila8599bd2009-10-06 11:31:12 -07003370}
3371
3372/*
3373 * Handle a caps message from the MDS.
3374 *
3375 * Identify the appropriate session, inode, and call the right handler
3376 * based on the cap op.
3377 */
3378void ceph_handle_caps(struct ceph_mds_session *session,
3379 struct ceph_msg *msg)
3380{
3381 struct ceph_mds_client *mdsc = session->s_mdsc;
Yehuda Sadeh3d14c5d2010-04-06 15:14:15 -07003382 struct super_block *sb = mdsc->fsc->sb;
Sage Weila8599bd2009-10-06 11:31:12 -07003383 struct inode *inode;
Sage Weilbe655592011-11-30 09:47:09 -08003384 struct ceph_inode_info *ci;
Sage Weila8599bd2009-10-06 11:31:12 -07003385 struct ceph_cap *cap;
3386 struct ceph_mds_caps *h;
Yan, Zheng4ee6a912013-11-24 14:43:46 +08003387 struct ceph_mds_cap_peer *peer = NULL;
Yan, Zheng779fe0f2016-03-07 09:35:06 +08003388 struct ceph_snap_realm *realm = NULL;
3389 struct ceph_string *pool_ns = NULL;
Sage Weil2600d2d2010-02-22 15:12:16 -08003390 int mds = session->s_mds;
Yan, Zheng2cd698b2014-04-18 13:20:27 +08003391 int op, issued;
Sage Weil3d7ded42010-06-09 16:47:10 -07003392 u32 seq, mseq;
Sage Weila8599bd2009-10-06 11:31:12 -07003393 struct ceph_vino vino;
Sage Weil6df058c2009-12-22 11:24:33 -08003394 u64 tid;
Yan, Zhengfb01d1f2014-11-14 21:29:55 +08003395 u64 inline_version = 0;
3396 void *inline_data = NULL;
3397 u32 inline_len = 0;
Sage Weil70edb552010-03-01 13:20:50 -08003398 void *snaptrace;
Sage Weilce1fbc82010-08-02 15:09:39 -07003399 size_t snaptrace_len;
Yan, Zhengfb01d1f2014-11-14 21:29:55 +08003400 void *p, *end;
Sage Weila8599bd2009-10-06 11:31:12 -07003401
3402 dout("handle_caps from mds%d\n", mds);
3403
3404 /* decode */
Yan, Zheng4ee6a912013-11-24 14:43:46 +08003405 end = msg->front.iov_base + msg->front.iov_len;
Sage Weil6df058c2009-12-22 11:24:33 -08003406 tid = le64_to_cpu(msg->hdr.tid);
Sage Weila8599bd2009-10-06 11:31:12 -07003407 if (msg->front.iov_len < sizeof(*h))
3408 goto bad;
3409 h = msg->front.iov_base;
3410 op = le32_to_cpu(h->op);
3411 vino.ino = le64_to_cpu(h->ino);
3412 vino.snap = CEPH_NOSNAP;
Sage Weila8599bd2009-10-06 11:31:12 -07003413 seq = le32_to_cpu(h->seq);
Sage Weil3d7ded42010-06-09 16:47:10 -07003414 mseq = le32_to_cpu(h->migrate_seq);
Sage Weila8599bd2009-10-06 11:31:12 -07003415
Sage Weilce1fbc82010-08-02 15:09:39 -07003416 snaptrace = h + 1;
3417 snaptrace_len = le32_to_cpu(h->snap_trace_len);
Yan, Zhengfb01d1f2014-11-14 21:29:55 +08003418 p = snaptrace + snaptrace_len;
Sage Weilce1fbc82010-08-02 15:09:39 -07003419
3420 if (le16_to_cpu(msg->hdr.version) >= 2) {
Yan, Zhengfb01d1f2014-11-14 21:29:55 +08003421 u32 flock_len;
Sage Weilce1fbc82010-08-02 15:09:39 -07003422 ceph_decode_32_safe(&p, end, flock_len, bad);
Yan, Zheng4ee6a912013-11-24 14:43:46 +08003423 if (p + flock_len > end)
3424 goto bad;
Yan, Zhengfb01d1f2014-11-14 21:29:55 +08003425 p += flock_len;
Sage Weilce1fbc82010-08-02 15:09:39 -07003426 }
3427
Yan, Zheng4ee6a912013-11-24 14:43:46 +08003428 if (le16_to_cpu(msg->hdr.version) >= 3) {
3429 if (op == CEPH_CAP_OP_IMPORT) {
Yan, Zheng4ee6a912013-11-24 14:43:46 +08003430 if (p + sizeof(*peer) > end)
3431 goto bad;
3432 peer = p;
Yan, Zhengfb01d1f2014-11-14 21:29:55 +08003433 p += sizeof(*peer);
Yan, Zheng11df2df2013-11-24 14:44:38 +08003434 } else if (op == CEPH_CAP_OP_EXPORT) {
3435 /* recorded in unused fields */
3436 peer = (void *)&h->size;
Yan, Zheng4ee6a912013-11-24 14:43:46 +08003437 }
3438 }
3439
Yan, Zhengfb01d1f2014-11-14 21:29:55 +08003440 if (le16_to_cpu(msg->hdr.version) >= 4) {
3441 ceph_decode_64_safe(&p, end, inline_version, bad);
3442 ceph_decode_32_safe(&p, end, inline_len, bad);
3443 if (p + inline_len > end)
3444 goto bad;
3445 inline_data = p;
3446 p += inline_len;
3447 }
3448
Yan, Zheng5ea5c5e2016-02-14 18:06:41 +08003449 if (le16_to_cpu(msg->hdr.version) >= 8) {
3450 u64 flush_tid;
3451 u32 caller_uid, caller_gid;
3452 u32 osd_epoch_barrier;
Yan, Zheng779fe0f2016-03-07 09:35:06 +08003453 u32 pool_ns_len;
Yan, Zheng5ea5c5e2016-02-14 18:06:41 +08003454 /* version >= 5 */
3455 ceph_decode_32_safe(&p, end, osd_epoch_barrier, bad);
3456 /* version >= 6 */
3457 ceph_decode_64_safe(&p, end, flush_tid, bad);
3458 /* version >= 7 */
3459 ceph_decode_32_safe(&p, end, caller_uid, bad);
3460 ceph_decode_32_safe(&p, end, caller_gid, bad);
3461 /* version >= 8 */
3462 ceph_decode_32_safe(&p, end, pool_ns_len, bad);
Yan, Zheng779fe0f2016-03-07 09:35:06 +08003463 if (pool_ns_len > 0) {
3464 ceph_decode_need(&p, end, pool_ns_len, bad);
3465 pool_ns = ceph_find_or_create_string(p, pool_ns_len);
3466 p += pool_ns_len;
3467 }
Yan, Zheng5ea5c5e2016-02-14 18:06:41 +08003468 }
3469
Yan, Zheng6cd3bca2014-09-17 07:45:12 +08003470 /* lookup ino */
3471 inode = ceph_find_inode(sb, vino);
3472 ci = ceph_inode(inode);
3473 dout(" op %s ino %llx.%llx inode %p\n", ceph_cap_op_name(op), vino.ino,
3474 vino.snap, inode);
3475
Sage Weila8599bd2009-10-06 11:31:12 -07003476 mutex_lock(&session->s_mutex);
3477 session->s_seq++;
3478 dout(" mds%d seq %lld cap seq %u\n", session->s_mds, session->s_seq,
3479 (unsigned)seq);
3480
Sage Weila8599bd2009-10-06 11:31:12 -07003481 if (!inode) {
3482 dout(" i don't have ino %llx\n", vino.ino);
Sage Weil3d7ded42010-06-09 16:47:10 -07003483
Yan, Zhenga096b092013-09-22 10:15:58 +08003484 if (op == CEPH_CAP_OP_IMPORT) {
Yan, Zheng745a8e32015-05-14 17:22:42 +08003485 cap = ceph_get_cap(mdsc, NULL);
3486 cap->cap_ino = vino.ino;
3487 cap->queue_release = 1;
Yan, Zheng779fe0f2016-03-07 09:35:06 +08003488 cap->cap_id = le64_to_cpu(h->cap_id);
Yan, Zheng745a8e32015-05-14 17:22:42 +08003489 cap->mseq = mseq;
3490 cap->seq = seq;
Yan, Zhenga096b092013-09-22 10:15:58 +08003491 spin_lock(&session->s_cap_lock);
Yan, Zheng745a8e32015-05-14 17:22:42 +08003492 list_add_tail(&cap->session_caps,
3493 &session->s_cap_releases);
3494 session->s_num_cap_releases++;
Yan, Zhenga096b092013-09-22 10:15:58 +08003495 spin_unlock(&session->s_cap_lock);
3496 }
Greg Farnum21b559d2010-10-06 15:46:30 -07003497 goto flush_cap_releases;
Sage Weila8599bd2009-10-06 11:31:12 -07003498 }
3499
3500 /* these will work even if we don't have a cap yet */
3501 switch (op) {
3502 case CEPH_CAP_OP_FLUSHSNAP_ACK:
Sage Weil6df058c2009-12-22 11:24:33 -08003503 handle_cap_flushsnap_ack(inode, tid, h, session);
Sage Weila8599bd2009-10-06 11:31:12 -07003504 goto done;
3505
3506 case CEPH_CAP_OP_EXPORT:
Yan, Zheng11df2df2013-11-24 14:44:38 +08003507 handle_cap_export(inode, h, peer, session);
3508 goto done_unlocked;
Sage Weila8599bd2009-10-06 11:31:12 -07003509
3510 case CEPH_CAP_OP_IMPORT:
Yan, Zheng982d6012014-12-23 15:30:54 +08003511 realm = NULL;
3512 if (snaptrace_len) {
3513 down_write(&mdsc->snap_rwsem);
3514 ceph_update_snap_trace(mdsc, snaptrace,
3515 snaptrace + snaptrace_len,
3516 false, &realm);
3517 downgrade_write(&mdsc->snap_rwsem);
3518 } else {
3519 down_read(&mdsc->snap_rwsem);
3520 }
Yan, Zheng4ee6a912013-11-24 14:43:46 +08003521 handle_cap_import(mdsc, inode, h, peer, session,
Yan, Zheng2cd698b2014-04-18 13:20:27 +08003522 &cap, &issued);
Yan, Zheng779fe0f2016-03-07 09:35:06 +08003523 handle_cap_grant(mdsc, inode, h, &pool_ns,
Yan, Zhengfb01d1f2014-11-14 21:29:55 +08003524 inline_version, inline_data, inline_len,
Yan, Zheng779fe0f2016-03-07 09:35:06 +08003525 msg->middle, session, cap, issued);
Yan, Zheng982d6012014-12-23 15:30:54 +08003526 if (realm)
3527 ceph_put_snap_realm(mdsc, realm);
Yan, Zheng2cd698b2014-04-18 13:20:27 +08003528 goto done_unlocked;
Sage Weila8599bd2009-10-06 11:31:12 -07003529 }
3530
3531 /* the rest require a cap */
Sage Weilbe655592011-11-30 09:47:09 -08003532 spin_lock(&ci->i_ceph_lock);
Sage Weila8599bd2009-10-06 11:31:12 -07003533 cap = __get_cap_for_mds(ceph_inode(inode), mds);
3534 if (!cap) {
Sage Weil9dbd4122010-06-10 13:21:20 -07003535 dout(" no cap on %p ino %llx.%llx from mds%d\n",
Sage Weila8599bd2009-10-06 11:31:12 -07003536 inode, ceph_ino(inode), ceph_snap(inode), mds);
Sage Weilbe655592011-11-30 09:47:09 -08003537 spin_unlock(&ci->i_ceph_lock);
Greg Farnum21b559d2010-10-06 15:46:30 -07003538 goto flush_cap_releases;
Sage Weila8599bd2009-10-06 11:31:12 -07003539 }
3540
Sage Weilbe655592011-11-30 09:47:09 -08003541 /* note that each of these drops i_ceph_lock for us */
Sage Weila8599bd2009-10-06 11:31:12 -07003542 switch (op) {
3543 case CEPH_CAP_OP_REVOKE:
3544 case CEPH_CAP_OP_GRANT:
Yan, Zheng2cd698b2014-04-18 13:20:27 +08003545 __ceph_caps_issued(ci, &issued);
3546 issued |= __ceph_caps_dirty(ci);
Yan, Zheng779fe0f2016-03-07 09:35:06 +08003547 handle_cap_grant(mdsc, inode, h, &pool_ns,
Yan, Zhengfb01d1f2014-11-14 21:29:55 +08003548 inline_version, inline_data, inline_len,
Yan, Zheng779fe0f2016-03-07 09:35:06 +08003549 msg->middle, session, cap, issued);
Sage Weil15637c82010-03-16 13:42:00 -07003550 goto done_unlocked;
Sage Weila8599bd2009-10-06 11:31:12 -07003551
3552 case CEPH_CAP_OP_FLUSH_ACK:
Sage Weil6df058c2009-12-22 11:24:33 -08003553 handle_cap_flush_ack(inode, tid, h, session, cap);
Sage Weila8599bd2009-10-06 11:31:12 -07003554 break;
3555
3556 case CEPH_CAP_OP_TRUNC:
3557 handle_cap_trunc(inode, h, session);
3558 break;
3559
3560 default:
Sage Weilbe655592011-11-30 09:47:09 -08003561 spin_unlock(&ci->i_ceph_lock);
Sage Weila8599bd2009-10-06 11:31:12 -07003562 pr_err("ceph_handle_caps: unknown cap op %d %s\n", op,
3563 ceph_cap_op_name(op));
3564 }
3565
Greg Farnum21b559d2010-10-06 15:46:30 -07003566 goto done;
3567
3568flush_cap_releases:
3569 /*
Yan, Zheng745a8e32015-05-14 17:22:42 +08003570 * send any cap release message to try to move things
Greg Farnum21b559d2010-10-06 15:46:30 -07003571 * along for the mds (who clearly thinks we still have this
3572 * cap).
3573 */
Greg Farnum21b559d2010-10-06 15:46:30 -07003574 ceph_send_cap_releases(mdsc, session);
3575
Sage Weila8599bd2009-10-06 11:31:12 -07003576done:
Sage Weil15637c82010-03-16 13:42:00 -07003577 mutex_unlock(&session->s_mutex);
3578done_unlocked:
SF Markus Elfringe96a6502014-11-02 15:20:59 +01003579 iput(inode);
Yan, Zheng779fe0f2016-03-07 09:35:06 +08003580 ceph_put_string(pool_ns);
Sage Weila8599bd2009-10-06 11:31:12 -07003581 return;
3582
3583bad:
3584 pr_err("ceph_handle_caps: corrupt message\n");
Sage Weil9ec7cab2009-12-14 15:13:47 -08003585 ceph_msg_dump(msg);
Sage Weila8599bd2009-10-06 11:31:12 -07003586 return;
3587}
3588
3589/*
3590 * Delayed work handler to process end of delayed cap release LRU list.
3591 */
Sage Weilafcdaea2009-10-14 14:27:38 -07003592void ceph_check_delayed_caps(struct ceph_mds_client *mdsc)
Sage Weila8599bd2009-10-06 11:31:12 -07003593{
3594 struct ceph_inode_info *ci;
3595 int flags = CHECK_CAPS_NODELAY;
3596
Sage Weila8599bd2009-10-06 11:31:12 -07003597 dout("check_delayed_caps\n");
3598 while (1) {
3599 spin_lock(&mdsc->cap_delay_lock);
3600 if (list_empty(&mdsc->cap_delay_list))
3601 break;
3602 ci = list_first_entry(&mdsc->cap_delay_list,
3603 struct ceph_inode_info,
3604 i_cap_delay_list);
3605 if ((ci->i_ceph_flags & CEPH_I_FLUSH) == 0 &&
3606 time_before(jiffies, ci->i_hold_caps_max))
3607 break;
3608 list_del_init(&ci->i_cap_delay_list);
3609 spin_unlock(&mdsc->cap_delay_lock);
3610 dout("check_delayed_caps on %p\n", &ci->vfs_inode);
3611 ceph_check_caps(ci, flags, NULL);
3612 }
3613 spin_unlock(&mdsc->cap_delay_lock);
3614}
3615
3616/*
Sage Weilafcdaea2009-10-14 14:27:38 -07003617 * Flush all dirty caps to the mds
3618 */
3619void ceph_flush_dirty_caps(struct ceph_mds_client *mdsc)
3620{
Sage Weildb354052011-05-24 11:46:31 -07003621 struct ceph_inode_info *ci;
3622 struct inode *inode;
Sage Weilafcdaea2009-10-14 14:27:38 -07003623
3624 dout("flush_dirty_caps\n");
3625 spin_lock(&mdsc->cap_dirty_lock);
Sage Weildb354052011-05-24 11:46:31 -07003626 while (!list_empty(&mdsc->cap_dirty)) {
3627 ci = list_first_entry(&mdsc->cap_dirty, struct ceph_inode_info,
3628 i_dirty_item);
Sage Weil70b666c2011-05-27 09:24:26 -07003629 inode = &ci->vfs_inode;
3630 ihold(inode);
Sage Weildb354052011-05-24 11:46:31 -07003631 dout("flush_dirty_caps %p\n", inode);
Sage Weilafcdaea2009-10-14 14:27:38 -07003632 spin_unlock(&mdsc->cap_dirty_lock);
Sage Weil70b666c2011-05-27 09:24:26 -07003633 ceph_check_caps(ci, CHECK_CAPS_NODELAY|CHECK_CAPS_FLUSH, NULL);
3634 iput(inode);
Sage Weilafcdaea2009-10-14 14:27:38 -07003635 spin_lock(&mdsc->cap_dirty_lock);
3636 }
3637 spin_unlock(&mdsc->cap_dirty_lock);
Sage Weildb354052011-05-24 11:46:31 -07003638 dout("flush_dirty_caps done\n");
Sage Weilafcdaea2009-10-14 14:27:38 -07003639}
3640
Yan, Zheng774a6a12016-06-06 16:01:39 +08003641void __ceph_get_fmode(struct ceph_inode_info *ci, int fmode)
3642{
3643 int i;
3644 int bits = (fmode << 1) | 1;
3645 for (i = 0; i < CEPH_FILE_MODE_BITS; i++) {
3646 if (bits & (1 << i))
3647 ci->i_nr_by_mode[i]++;
3648 }
3649}
3650
Sage Weilafcdaea2009-10-14 14:27:38 -07003651/*
Sage Weila8599bd2009-10-06 11:31:12 -07003652 * Drop open file reference. If we were the last open file,
3653 * we may need to release capabilities to the MDS (or schedule
3654 * their delayed release).
3655 */
3656void ceph_put_fmode(struct ceph_inode_info *ci, int fmode)
3657{
Yan, Zheng774a6a12016-06-06 16:01:39 +08003658 int i, last = 0;
3659 int bits = (fmode << 1) | 1;
Sage Weilbe655592011-11-30 09:47:09 -08003660 spin_lock(&ci->i_ceph_lock);
Yan, Zheng774a6a12016-06-06 16:01:39 +08003661 for (i = 0; i < CEPH_FILE_MODE_BITS; i++) {
3662 if (bits & (1 << i)) {
3663 BUG_ON(ci->i_nr_by_mode[i] == 0);
3664 if (--ci->i_nr_by_mode[i] == 0)
3665 last++;
3666 }
3667 }
3668 dout("put_fmode %p fmode %d {%d,%d,%d,%d}\n",
3669 &ci->vfs_inode, fmode,
3670 ci->i_nr_by_mode[0], ci->i_nr_by_mode[1],
3671 ci->i_nr_by_mode[2], ci->i_nr_by_mode[3]);
Sage Weilbe655592011-11-30 09:47:09 -08003672 spin_unlock(&ci->i_ceph_lock);
Sage Weila8599bd2009-10-06 11:31:12 -07003673
3674 if (last && ci->i_vino.snap == CEPH_NOSNAP)
3675 ceph_check_caps(ci, 0, NULL);
3676}
3677
3678/*
3679 * Helpers for embedding cap and dentry lease releases into mds
3680 * requests.
3681 *
3682 * @force is used by dentry_release (below) to force inclusion of a
3683 * record for the directory inode, even when there aren't any caps to
3684 * drop.
3685 */
3686int ceph_encode_inode_release(void **p, struct inode *inode,
3687 int mds, int drop, int unless, int force)
3688{
3689 struct ceph_inode_info *ci = ceph_inode(inode);
3690 struct ceph_cap *cap;
3691 struct ceph_mds_request_release *rel = *p;
Sage Weilec97f882010-06-24 15:12:37 -07003692 int used, dirty;
Sage Weila8599bd2009-10-06 11:31:12 -07003693 int ret = 0;
Sage Weila8599bd2009-10-06 11:31:12 -07003694
Sage Weilbe655592011-11-30 09:47:09 -08003695 spin_lock(&ci->i_ceph_lock);
Sage Weil916623d2010-03-16 15:01:07 -07003696 used = __ceph_caps_used(ci);
Sage Weilec97f882010-06-24 15:12:37 -07003697 dirty = __ceph_caps_dirty(ci);
Sage Weil916623d2010-03-16 15:01:07 -07003698
Sage Weilec97f882010-06-24 15:12:37 -07003699 dout("encode_inode_release %p mds%d used|dirty %s drop %s unless %s\n",
3700 inode, mds, ceph_cap_string(used|dirty), ceph_cap_string(drop),
Sage Weil916623d2010-03-16 15:01:07 -07003701 ceph_cap_string(unless));
3702
Sage Weilec97f882010-06-24 15:12:37 -07003703 /* only drop unused, clean caps */
3704 drop &= ~(used | dirty);
Sage Weil916623d2010-03-16 15:01:07 -07003705
Sage Weila8599bd2009-10-06 11:31:12 -07003706 cap = __get_cap_for_mds(ci, mds);
3707 if (cap && __cap_is_valid(cap)) {
3708 if (force ||
3709 ((cap->issued & drop) &&
3710 (cap->issued & unless) == 0)) {
3711 if ((cap->issued & drop) &&
3712 (cap->issued & unless) == 0) {
Yan, Zhengbb137f82013-06-03 18:22:17 +08003713 int wanted = __ceph_caps_wanted(ci);
3714 if ((ci->i_ceph_flags & CEPH_I_NODELAY) == 0)
3715 wanted |= cap->mds_wanted;
3716 dout("encode_inode_release %p cap %p "
3717 "%s -> %s, wanted %s -> %s\n", inode, cap,
Sage Weila8599bd2009-10-06 11:31:12 -07003718 ceph_cap_string(cap->issued),
Yan, Zhengbb137f82013-06-03 18:22:17 +08003719 ceph_cap_string(cap->issued & ~drop),
3720 ceph_cap_string(cap->mds_wanted),
3721 ceph_cap_string(wanted));
3722
Sage Weila8599bd2009-10-06 11:31:12 -07003723 cap->issued &= ~drop;
3724 cap->implemented &= ~drop;
Yan, Zhengbb137f82013-06-03 18:22:17 +08003725 cap->mds_wanted = wanted;
Sage Weila8599bd2009-10-06 11:31:12 -07003726 } else {
3727 dout("encode_inode_release %p cap %p %s"
3728 " (force)\n", inode, cap,
3729 ceph_cap_string(cap->issued));
3730 }
3731
3732 rel->ino = cpu_to_le64(ceph_ino(inode));
3733 rel->cap_id = cpu_to_le64(cap->cap_id);
3734 rel->seq = cpu_to_le32(cap->seq);
Himangi Saraogi08a0f242014-07-23 20:11:11 +05303735 rel->issue_seq = cpu_to_le32(cap->issue_seq);
Sage Weila8599bd2009-10-06 11:31:12 -07003736 rel->mseq = cpu_to_le32(cap->mseq);
Yan, Zhengfd7b95c2014-04-17 08:02:02 +08003737 rel->caps = cpu_to_le32(cap->implemented);
Sage Weila8599bd2009-10-06 11:31:12 -07003738 rel->wanted = cpu_to_le32(cap->mds_wanted);
3739 rel->dname_len = 0;
3740 rel->dname_seq = 0;
3741 *p += sizeof(*rel);
3742 ret = 1;
3743 } else {
3744 dout("encode_inode_release %p cap %p %s\n",
3745 inode, cap, ceph_cap_string(cap->issued));
3746 }
3747 }
Sage Weilbe655592011-11-30 09:47:09 -08003748 spin_unlock(&ci->i_ceph_lock);
Sage Weila8599bd2009-10-06 11:31:12 -07003749 return ret;
3750}
3751
3752int ceph_encode_dentry_release(void **p, struct dentry *dentry,
3753 int mds, int drop, int unless)
3754{
David Howells2b0143b2015-03-17 22:25:59 +00003755 struct inode *dir = d_inode(dentry->d_parent);
Sage Weila8599bd2009-10-06 11:31:12 -07003756 struct ceph_mds_request_release *rel = *p;
3757 struct ceph_dentry_info *di = ceph_dentry(dentry);
3758 int force = 0;
3759 int ret;
3760
3761 /*
3762 * force an record for the directory caps if we have a dentry lease.
Sage Weilbe655592011-11-30 09:47:09 -08003763 * this is racy (can't take i_ceph_lock and d_lock together), but it
Sage Weila8599bd2009-10-06 11:31:12 -07003764 * doesn't have to be perfect; the mds will revoke anything we don't
3765 * release.
3766 */
3767 spin_lock(&dentry->d_lock);
3768 if (di->lease_session && di->lease_session->s_mds == mds)
3769 force = 1;
3770 spin_unlock(&dentry->d_lock);
3771
3772 ret = ceph_encode_inode_release(p, dir, mds, drop, unless, force);
3773
3774 spin_lock(&dentry->d_lock);
3775 if (ret && di->lease_session && di->lease_session->s_mds == mds) {
3776 dout("encode_dentry_release %p mds%d seq %d\n",
3777 dentry, mds, (int)di->lease_seq);
3778 rel->dname_len = cpu_to_le32(dentry->d_name.len);
3779 memcpy(*p, dentry->d_name.name, dentry->d_name.len);
3780 *p += dentry->d_name.len;
3781 rel->dname_seq = cpu_to_le32(di->lease_seq);
Sage Weil1dadcce2010-07-23 13:54:21 -07003782 __ceph_mdsc_drop_dentry_lease(dentry);
Sage Weila8599bd2009-10-06 11:31:12 -07003783 }
3784 spin_unlock(&dentry->d_lock);
3785 return ret;
3786}