Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/sage/ceph-client
* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/sage/ceph-client:
ceph: use complete_all and wake_up_all
ceph: Correct obvious typo of Kconfig variable "CRYPTO_AES"
ceph: fix dentry lease release
ceph: fix leak of dentry in ceph_init_dentry() error path
ceph: fix pg_mapping leak on pg_temp updates
ceph: fix d_release dop for snapdir, snapped dentries
ceph: avoid dcache readdir for snapdir
+50
-36
+1
-1
fs/ceph/Kconfig
+1
-1
fs/ceph/Kconfig
···
2
2
tristate "Ceph distributed file system (EXPERIMENTAL)"
3
3
depends on INET && EXPERIMENTAL
4
4
select LIBCRC32C
5
-
select CONFIG_CRYPTO_AES
5
+
select CRYPTO_AES
6
6
help
7
7
Choose Y or M here to include support for mounting the
8
8
experimental Ceph distributed file system. Ceph is an extremely
+8
-7
fs/ceph/caps.c
+8
-7
fs/ceph/caps.c
···
627
627
if (fmode >= 0)
628
628
__ceph_get_fmode(ci, fmode);
629
629
spin_unlock(&inode->i_lock);
630
-
wake_up(&ci->i_cap_wq);
630
+
wake_up_all(&ci->i_cap_wq);
631
631
return 0;
632
632
}
633
633
···
1181
1181
}
1182
1182
1183
1183
if (wake)
1184
-
wake_up(&ci->i_cap_wq);
1184
+
wake_up_all(&ci->i_cap_wq);
1185
1185
1186
1186
return delayed;
1187
1187
}
···
2153
2153
else if (flushsnaps)
2154
2154
ceph_flush_snaps(ci);
2155
2155
if (wake)
2156
-
wake_up(&ci->i_cap_wq);
2156
+
wake_up_all(&ci->i_cap_wq);
2157
2157
if (put)
2158
2158
iput(inode);
2159
2159
}
···
2229
2229
iput(inode);
2230
2230
} else if (complete_capsnap) {
2231
2231
ceph_flush_snaps(ci);
2232
-
wake_up(&ci->i_cap_wq);
2232
+
wake_up_all(&ci->i_cap_wq);
2233
2233
}
2234
2234
if (drop_capsnap)
2235
2235
iput(inode);
···
2405
2405
if (queue_invalidate)
2406
2406
ceph_queue_invalidate(inode);
2407
2407
if (wake)
2408
-
wake_up(&ci->i_cap_wq);
2408
+
wake_up_all(&ci->i_cap_wq);
2409
2409
2410
2410
if (check_caps == 1)
2411
2411
ceph_check_caps(ci, CHECK_CAPS_NODELAY|CHECK_CAPS_AUTHONLY,
···
2460
2460
struct ceph_inode_info,
2461
2461
i_flushing_item)->vfs_inode);
2462
2462
mdsc->num_cap_flushing--;
2463
-
wake_up(&mdsc->cap_flushing_wq);
2463
+
wake_up_all(&mdsc->cap_flushing_wq);
2464
2464
dout(" inode %p now !flushing\n", inode);
2465
2465
2466
2466
if (ci->i_dirty_caps == 0) {
···
2472
2472
}
2473
2473
}
2474
2474
spin_unlock(&mdsc->cap_dirty_lock);
2475
-
wake_up(&ci->i_cap_wq);
2475
+
wake_up_all(&ci->i_cap_wq);
2476
2476
2477
2477
out:
2478
2478
spin_unlock(&inode->i_lock);
···
2984
2984
memcpy(*p, dentry->d_name.name, dentry->d_name.len);
2985
2985
*p += dentry->d_name.len;
2986
2986
rel->dname_seq = cpu_to_le32(di->lease_seq);
2987
+
__ceph_mdsc_drop_dentry_lease(dentry);
2987
2988
}
2988
2989
spin_unlock(&dentry->d_lock);
2989
2990
return ret;
+10
-3
fs/ceph/dir.c
+10
-3
fs/ceph/dir.c
···
266
266
spin_lock(&inode->i_lock);
267
267
if ((filp->f_pos == 2 || fi->dentry) &&
268
268
!ceph_test_opt(client, NOASYNCREADDIR) &&
269
+
ceph_snap(inode) != CEPH_SNAPDIR &&
269
270
(ci->i_ceph_flags & CEPH_I_COMPLETE) &&
270
271
__ceph_caps_issued_mask(ci, CEPH_CAP_FILE_SHARED, 1)) {
271
272
err = __dcache_readdir(filp, dirent, filldir);
···
1014
1013
1015
1014
/*
1016
1015
* When a dentry is released, clear the dir I_COMPLETE if it was part
1017
-
* of the current dir gen.
1016
+
* of the current dir gen or if this is in the snapshot namespace.
1018
1017
*/
1019
1018
static void ceph_dentry_release(struct dentry *dentry)
1020
1019
{
1021
1020
struct ceph_dentry_info *di = ceph_dentry(dentry);
1022
1021
struct inode *parent_inode = dentry->d_parent->d_inode;
1022
+
u64 snapid = ceph_snap(parent_inode);
1023
1023
1024
-
if (parent_inode) {
1024
+
dout("dentry_release %p parent %p\n", dentry, parent_inode);
1025
+
1026
+
if (parent_inode && snapid != CEPH_SNAPDIR) {
1025
1027
struct ceph_inode_info *ci = ceph_inode(parent_inode);
1026
1028
1027
1029
spin_lock(&parent_inode->i_lock);
1028
-
if (ci->i_shared_gen == di->lease_shared_gen) {
1030
+
if (ci->i_shared_gen == di->lease_shared_gen ||
1031
+
snapid <= CEPH_MAXSNAP) {
1029
1032
dout(" clearing %p complete (d_release)\n",
1030
1033
parent_inode);
1031
1034
ci->i_ceph_flags &= ~CEPH_I_COMPLETE;
···
1246
1241
1247
1242
struct dentry_operations ceph_snapdir_dentry_ops = {
1248
1243
.d_revalidate = ceph_snapdir_d_revalidate,
1244
+
.d_release = ceph_dentry_release,
1249
1245
};
1250
1246
1251
1247
struct dentry_operations ceph_snap_dentry_ops = {
1248
+
.d_release = ceph_dentry_release,
1252
1249
};
+1
-1
fs/ceph/file.c
+1
-1
fs/ceph/file.c
+4
-2
fs/ceph/inode.c
+4
-2
fs/ceph/inode.c
···
1199
1199
goto out;
1200
1200
}
1201
1201
err = ceph_init_dentry(dn);
1202
-
if (err < 0)
1202
+
if (err < 0) {
1203
+
dput(dn);
1203
1204
goto out;
1205
+
}
1204
1206
} else if (dn->d_inode &&
1205
1207
(ceph_ino(dn->d_inode) != vino.ino ||
1206
1208
ceph_snap(dn->d_inode) != vino.snap)) {
···
1501
1499
if (wrbuffer_refs == 0)
1502
1500
ceph_check_caps(ci, CHECK_CAPS_AUTHONLY, NULL);
1503
1501
if (wake)
1504
-
wake_up(&ci->i_cap_wq);
1502
+
wake_up_all(&ci->i_cap_wq);
1505
1503
}
1506
1504
1507
1505
+5
-5
fs/ceph/mds_client.c
+5
-5
fs/ceph/mds_client.c
···
868
868
{
869
869
struct ceph_inode_info *ci = ceph_inode(inode);
870
870
871
-
wake_up(&ci->i_cap_wq);
871
+
wake_up_all(&ci->i_cap_wq);
872
872
if (arg) {
873
873
spin_lock(&inode->i_lock);
874
874
ci->i_wanted_max_size = 0;
···
1564
1564
if (req->r_callback)
1565
1565
req->r_callback(mdsc, req);
1566
1566
else
1567
-
complete(&req->r_completion);
1567
+
complete_all(&req->r_completion);
1568
1568
}
1569
1569
1570
1570
/*
···
1932
1932
if (head->safe) {
1933
1933
req->r_got_safe = true;
1934
1934
__unregister_request(mdsc, req);
1935
-
complete(&req->r_safe_completion);
1935
+
complete_all(&req->r_safe_completion);
1936
1936
1937
1937
if (req->r_got_unsafe) {
1938
1938
/*
···
1947
1947
1948
1948
/* last unsafe request during umount? */
1949
1949
if (mdsc->stopping && !__get_oldest_req(mdsc))
1950
-
complete(&mdsc->safe_umount_waiters);
1950
+
complete_all(&mdsc->safe_umount_waiters);
1951
1951
mutex_unlock(&mdsc->mutex);
1952
1952
goto out;
1953
1953
}
···
2126
2126
pr_info("mds%d reconnect denied\n", session->s_mds);
2127
2127
remove_session_caps(session);
2128
2128
wake = 1; /* for good measure */
2129
-
complete(&mdsc->session_close_waiters);
2129
+
complete_all(&mdsc->session_close_waiters);
2130
2130
kick_requests(mdsc, mds);
2131
2131
break;
2132
2132
+3
-3
fs/ceph/mon_client.c
+3
-3
fs/ceph/mon_client.c
···
345
345
346
346
out:
347
347
mutex_unlock(&monc->mutex);
348
-
wake_up(&client->auth_wq);
348
+
wake_up_all(&client->auth_wq);
349
349
}
350
350
351
351
/*
···
462
462
}
463
463
mutex_unlock(&monc->mutex);
464
464
if (req) {
465
-
complete(&req->completion);
465
+
complete_all(&req->completion);
466
466
put_generic_request(req);
467
467
}
468
468
return;
···
718
718
monc->m_auth->front_max);
719
719
if (ret < 0) {
720
720
monc->client->auth_err = ret;
721
-
wake_up(&monc->client->auth_wq);
721
+
wake_up_all(&monc->client->auth_wq);
722
722
} else if (ret > 0) {
723
723
__send_prepared_auth_request(monc, ret);
724
724
} else if (!was_auth && monc->auth->ops->is_authenticated(monc->auth)) {
+3
-3
fs/ceph/osd_client.c
+3
-3
fs/ceph/osd_client.c
···
862
862
if (req->r_callback)
863
863
req->r_callback(req, msg);
864
864
else
865
-
complete(&req->r_completion);
865
+
complete_all(&req->r_completion);
866
866
867
867
if (flags & CEPH_OSD_FLAG_ONDISK) {
868
868
if (req->r_safe_callback)
869
869
req->r_safe_callback(req, msg);
870
-
complete(&req->r_safe_completion); /* fsync waiter */
870
+
complete_all(&req->r_safe_completion); /* fsync waiter */
871
871
}
872
872
873
873
done:
···
1083
1083
if (newmap)
1084
1084
kick_requests(osdc, NULL);
1085
1085
up_read(&osdc->map_sem);
1086
-
wake_up(&osdc->client->auth_wq);
1086
+
wake_up_all(&osdc->client->auth_wq);
1087
1087
return;
1088
1088
1089
1089
bad:
+15
-11
fs/ceph/osdmap.c
+15
-11
fs/ceph/osdmap.c
···
831
831
/* remove any? */
832
832
while (rbp && pgid_cmp(rb_entry(rbp, struct ceph_pg_mapping,
833
833
node)->pgid, pgid) <= 0) {
834
-
struct rb_node *cur = rbp;
834
+
struct ceph_pg_mapping *cur =
835
+
rb_entry(rbp, struct ceph_pg_mapping, node);
836
+
835
837
rbp = rb_next(rbp);
836
-
dout(" removed pg_temp %llx\n",
837
-
*(u64 *)&rb_entry(cur, struct ceph_pg_mapping,
838
-
node)->pgid);
839
-
rb_erase(cur, &map->pg_temp);
838
+
dout(" removed pg_temp %llx\n", *(u64 *)&cur->pgid);
839
+
rb_erase(&cur->node, &map->pg_temp);
840
+
kfree(cur);
840
841
}
841
842
842
843
if (pglen) {
···
853
852
for (j = 0; j < pglen; j++)
854
853
pg->osds[j] = ceph_decode_32(p);
855
854
err = __insert_pg_mapping(pg, &map->pg_temp);
856
-
if (err)
855
+
if (err) {
856
+
kfree(pg);
857
857
goto bad;
858
+
}
858
859
dout(" added pg_temp %llx len %d\n", *(u64 *)&pgid,
859
860
pglen);
860
861
}
861
862
}
862
863
while (rbp) {
863
-
struct rb_node *cur = rbp;
864
+
struct ceph_pg_mapping *cur =
865
+
rb_entry(rbp, struct ceph_pg_mapping, node);
866
+
864
867
rbp = rb_next(rbp);
865
-
dout(" removed pg_temp %llx\n",
866
-
*(u64 *)&rb_entry(cur, struct ceph_pg_mapping,
867
-
node)->pgid);
868
-
rb_erase(cur, &map->pg_temp);
868
+
dout(" removed pg_temp %llx\n", *(u64 *)&cur->pgid);
869
+
rb_erase(&cur->node, &map->pg_temp);
870
+
kfree(cur);
869
871
}
870
872
871
873
/* ignore the rest */