1 #include <linux/ceph/ceph_debug.h>
3 #include <linux/file.h>
4 #include <linux/namei.h>
5 #include <linux/random.h>
8 #include "mds_client.h"
9 #include <linux/ceph/pagelist.h>
11 static u64 lock_secret
;
12 static int ceph_lock_wait_for_completion(struct ceph_mds_client
*mdsc
,
13 struct ceph_mds_request
*req
);
15 static inline u64
secure_addr(void *addr
)
17 u64 v
= lock_secret
^ (u64
)(unsigned long)addr
;
19 * Set the most significant bit, so that MDS knows the 'owner'
20 * is sufficient to identify the owner of lock. (old code uses
21 * both 'owner' and 'pid')
27 void __init
ceph_flock_init(void)
29 get_random_bytes(&lock_secret
, sizeof(lock_secret
));
33 * Implement fcntl and flock locking functions.
35 static int ceph_lock_message(u8 lock_type
, u16 operation
, struct file
*file
,
36 int cmd
, u8 wait
, struct file_lock
*fl
)
38 struct inode
*inode
= file_inode(file
);
39 struct ceph_mds_client
*mdsc
= ceph_sb_to_client(inode
->i_sb
)->mdsc
;
40 struct ceph_mds_request
*req
;
45 if (operation
!= CEPH_MDS_OP_SETFILELOCK
|| cmd
== CEPH_LOCK_UNLOCK
)
48 req
= ceph_mdsc_create_request(mdsc
, operation
, USE_AUTH_MDS
);
55 /* mds requires start and length rather than start and end */
56 if (LLONG_MAX
== fl
->fl_end
)
59 length
= fl
->fl_end
- fl
->fl_start
+ 1;
61 owner
= secure_addr(fl
->fl_owner
);
63 dout("ceph_lock_message: rule: %d, op: %d, owner: %llx, pid: %llu, "
64 "start: %llu, length: %llu, wait: %d, type: %d", (int)lock_type
,
65 (int)operation
, owner
, (u64
)fl
->fl_pid
, fl
->fl_start
, length
,
68 req
->r_args
.filelock_change
.rule
= lock_type
;
69 req
->r_args
.filelock_change
.type
= cmd
;
70 req
->r_args
.filelock_change
.owner
= cpu_to_le64(owner
);
71 req
->r_args
.filelock_change
.pid
= cpu_to_le64((u64
)fl
->fl_pid
);
72 req
->r_args
.filelock_change
.start
= cpu_to_le64(fl
->fl_start
);
73 req
->r_args
.filelock_change
.length
= cpu_to_le64(length
);
74 req
->r_args
.filelock_change
.wait
= wait
;
77 req
->r_wait_for_completion
= ceph_lock_wait_for_completion
;
79 err
= ceph_mdsc_do_request(mdsc
, inode
, req
);
81 if (operation
== CEPH_MDS_OP_GETFILELOCK
) {
82 fl
->fl_pid
= le64_to_cpu(req
->r_reply_info
.filelock_reply
->pid
);
83 if (CEPH_LOCK_SHARED
== req
->r_reply_info
.filelock_reply
->type
)
84 fl
->fl_type
= F_RDLCK
;
85 else if (CEPH_LOCK_EXCL
== req
->r_reply_info
.filelock_reply
->type
)
86 fl
->fl_type
= F_WRLCK
;
88 fl
->fl_type
= F_UNLCK
;
90 fl
->fl_start
= le64_to_cpu(req
->r_reply_info
.filelock_reply
->start
);
91 length
= le64_to_cpu(req
->r_reply_info
.filelock_reply
->start
) +
92 le64_to_cpu(req
->r_reply_info
.filelock_reply
->length
);
94 fl
->fl_end
= length
-1;
99 ceph_mdsc_put_request(req
);
100 dout("ceph_lock_message: rule: %d, op: %d, pid: %llu, start: %llu, "
101 "length: %llu, wait: %d, type: %d, err code %d", (int)lock_type
,
102 (int)operation
, (u64
)fl
->fl_pid
, fl
->fl_start
,
103 length
, wait
, fl
->fl_type
, err
);
107 static int ceph_lock_wait_for_completion(struct ceph_mds_client
*mdsc
,
108 struct ceph_mds_request
*req
)
110 struct ceph_mds_request
*intr_req
;
111 struct inode
*inode
= req
->r_inode
;
114 BUG_ON(req
->r_op
!= CEPH_MDS_OP_SETFILELOCK
);
115 if (req
->r_args
.filelock_change
.rule
== CEPH_LOCK_FCNTL
)
116 lock_type
= CEPH_LOCK_FCNTL_INTR
;
117 else if (req
->r_args
.filelock_change
.rule
== CEPH_LOCK_FLOCK
)
118 lock_type
= CEPH_LOCK_FLOCK_INTR
;
121 BUG_ON(req
->r_args
.filelock_change
.type
== CEPH_LOCK_UNLOCK
);
123 err
= wait_for_completion_interruptible(&req
->r_completion
);
127 dout("ceph_lock_wait_for_completion: request %llu was interrupted\n",
130 intr_req
= ceph_mdsc_create_request(mdsc
, CEPH_MDS_OP_SETFILELOCK
,
132 if (IS_ERR(intr_req
))
133 return PTR_ERR(intr_req
);
135 intr_req
->r_inode
= inode
;
137 intr_req
->r_num_caps
= 1;
139 intr_req
->r_args
.filelock_change
= req
->r_args
.filelock_change
;
140 intr_req
->r_args
.filelock_change
.rule
= lock_type
;
141 intr_req
->r_args
.filelock_change
.type
= CEPH_LOCK_UNLOCK
;
143 err
= ceph_mdsc_do_request(mdsc
, inode
, intr_req
);
144 ceph_mdsc_put_request(intr_req
);
146 if (err
&& err
!= -ERESTARTSYS
)
149 wait_for_completion(&req
->r_completion
);
154 * Attempt to set an fcntl lock.
155 * For now, this just goes away to the server. Later it may be more awesome.
157 int ceph_lock(struct file
*file
, int cmd
, struct file_lock
*fl
)
162 u16 op
= CEPH_MDS_OP_SETFILELOCK
;
164 if (!(fl
->fl_flags
& FL_POSIX
))
166 /* No mandatory locks */
167 if (__mandatory_lock(file
->f_mapping
->host
) && fl
->fl_type
!= F_UNLCK
)
170 dout("ceph_lock, fl_owner: %p", fl
->fl_owner
);
172 /* set wait bit as appropriate, then make command as Ceph expects it*/
174 op
= CEPH_MDS_OP_GETFILELOCK
;
175 else if (IS_SETLKW(cmd
))
178 if (F_RDLCK
== fl
->fl_type
)
179 lock_cmd
= CEPH_LOCK_SHARED
;
180 else if (F_WRLCK
== fl
->fl_type
)
181 lock_cmd
= CEPH_LOCK_EXCL
;
183 lock_cmd
= CEPH_LOCK_UNLOCK
;
185 err
= ceph_lock_message(CEPH_LOCK_FCNTL
, op
, file
, lock_cmd
, wait
, fl
);
187 if (op
!= CEPH_MDS_OP_GETFILELOCK
) {
188 dout("mds locked, locking locally");
189 err
= posix_lock_file(file
, fl
, NULL
);
190 if (err
&& (CEPH_MDS_OP_SETFILELOCK
== op
)) {
191 /* undo! This should only happen if
192 * the kernel detects local
194 ceph_lock_message(CEPH_LOCK_FCNTL
, op
, file
,
195 CEPH_LOCK_UNLOCK
, 0, fl
);
196 dout("got %d on posix_lock_file, undid lock",
204 int ceph_flock(struct file
*file
, int cmd
, struct file_lock
*fl
)
210 if (!(fl
->fl_flags
& FL_FLOCK
))
212 /* No mandatory locks */
213 if (__mandatory_lock(file
->f_mapping
->host
) && fl
->fl_type
!= F_UNLCK
)
216 dout("ceph_flock, fl_file: %p", fl
->fl_file
);
221 if (F_RDLCK
== fl
->fl_type
)
222 lock_cmd
= CEPH_LOCK_SHARED
;
223 else if (F_WRLCK
== fl
->fl_type
)
224 lock_cmd
= CEPH_LOCK_EXCL
;
226 lock_cmd
= CEPH_LOCK_UNLOCK
;
228 err
= ceph_lock_message(CEPH_LOCK_FLOCK
, CEPH_MDS_OP_SETFILELOCK
,
229 file
, lock_cmd
, wait
, fl
);
231 err
= flock_lock_file_wait(file
, fl
);
233 ceph_lock_message(CEPH_LOCK_FLOCK
,
234 CEPH_MDS_OP_SETFILELOCK
,
235 file
, CEPH_LOCK_UNLOCK
, 0, fl
);
236 dout("got %d on flock_lock_file_wait, undid lock", err
);
243 * Fills in the passed counter variables, so you can prepare pagelist metadata
244 * before calling ceph_encode_locks.
246 void ceph_count_locks(struct inode
*inode
, int *fcntl_count
, int *flock_count
)
248 struct file_lock
*lock
;
249 struct file_lock_context
*ctx
;
254 ctx
= inode
->i_flctx
;
256 spin_lock(&ctx
->flc_lock
);
257 list_for_each_entry(lock
, &ctx
->flc_posix
, fl_list
)
259 list_for_each_entry(lock
, &ctx
->flc_flock
, fl_list
)
261 spin_unlock(&ctx
->flc_lock
);
263 dout("counted %d flock locks and %d fcntl locks",
264 *flock_count
, *fcntl_count
);
268 * Encode the flock and fcntl locks for the given inode into the ceph_filelock
269 * array. Must be called with inode->i_lock already held.
270 * If we encounter more of a specific lock type than expected, return -ENOSPC.
272 int ceph_encode_locks_to_buffer(struct inode
*inode
,
273 struct ceph_filelock
*flocks
,
274 int num_fcntl_locks
, int num_flock_locks
)
276 struct file_lock
*lock
;
277 struct file_lock_context
*ctx
= inode
->i_flctx
;
283 dout("encoding %d flock and %d fcntl locks", num_flock_locks
,
289 spin_lock(&ctx
->flc_lock
);
290 list_for_each_entry(lock
, &ctx
->flc_flock
, fl_list
) {
292 if (seen_fcntl
> num_fcntl_locks
) {
296 err
= lock_to_ceph_filelock(lock
, &flocks
[l
]);
301 list_for_each_entry(lock
, &ctx
->flc_flock
, fl_list
) {
303 if (seen_flock
> num_flock_locks
) {
307 err
= lock_to_ceph_filelock(lock
, &flocks
[l
]);
313 spin_unlock(&ctx
->flc_lock
);
318 * Copy the encoded flock and fcntl locks into the pagelist.
319 * Format is: #fcntl locks, sequential fcntl locks, #flock locks,
320 * sequential flock locks.
321 * Returns zero on success.
323 int ceph_locks_to_pagelist(struct ceph_filelock
*flocks
,
324 struct ceph_pagelist
*pagelist
,
325 int num_fcntl_locks
, int num_flock_locks
)
330 nlocks
= cpu_to_le32(num_fcntl_locks
);
331 err
= ceph_pagelist_append(pagelist
, &nlocks
, sizeof(nlocks
));
335 err
= ceph_pagelist_append(pagelist
, flocks
,
336 num_fcntl_locks
* sizeof(*flocks
));
340 nlocks
= cpu_to_le32(num_flock_locks
);
341 err
= ceph_pagelist_append(pagelist
, &nlocks
, sizeof(nlocks
));
345 err
= ceph_pagelist_append(pagelist
,
346 &flocks
[num_fcntl_locks
],
347 num_flock_locks
* sizeof(*flocks
));
353 * Given a pointer to a lock, convert it to a ceph filelock
355 int lock_to_ceph_filelock(struct file_lock
*lock
,
356 struct ceph_filelock
*cephlock
)
359 cephlock
->start
= cpu_to_le64(lock
->fl_start
);
360 cephlock
->length
= cpu_to_le64(lock
->fl_end
- lock
->fl_start
+ 1);
361 cephlock
->client
= cpu_to_le64(0);
362 cephlock
->pid
= cpu_to_le64((u64
)lock
->fl_pid
);
363 cephlock
->owner
= cpu_to_le64(secure_addr(lock
->fl_owner
));
365 switch (lock
->fl_type
) {
367 cephlock
->type
= CEPH_LOCK_SHARED
;
370 cephlock
->type
= CEPH_LOCK_EXCL
;
373 cephlock
->type
= CEPH_LOCK_UNLOCK
;
376 dout("Have unknown lock type %d", lock
->fl_type
);