1 #include <linux/ceph/ceph_debug.h>
3 #include <linux/file.h>
4 #include <linux/namei.h>
7 #include "mds_client.h"
8 #include <linux/ceph/pagelist.h>
11 * Implement fcntl and flock locking functions.
13 static int ceph_lock_message(u8 lock_type
, u16 operation
, struct file
*file
,
14 int cmd
, u8 wait
, struct file_lock
*fl
)
16 struct inode
*inode
= file
->f_dentry
->d_inode
;
17 struct ceph_mds_client
*mdsc
=
18 ceph_sb_to_client(inode
->i_sb
)->mdsc
;
19 struct ceph_mds_request
*req
;
23 req
= ceph_mdsc_create_request(mdsc
, operation
, USE_AUTH_MDS
);
29 /* mds requires start and length rather than start and end */
30 if (LLONG_MAX
== fl
->fl_end
)
33 length
= fl
->fl_end
- fl
->fl_start
+ 1;
35 dout("ceph_lock_message: rule: %d, op: %d, pid: %llu, start: %llu, "
36 "length: %llu, wait: %d, type`: %d", (int)lock_type
,
37 (int)operation
, (u64
)fl
->fl_pid
, fl
->fl_start
,
38 length
, wait
, fl
->fl_type
);
41 req
->r_args
.filelock_change
.rule
= lock_type
;
42 req
->r_args
.filelock_change
.type
= cmd
;
43 req
->r_args
.filelock_change
.pid
= cpu_to_le64((u64
)fl
->fl_pid
);
44 /* This should be adjusted, but I'm not sure if
45 namespaces actually get id numbers*/
46 req
->r_args
.filelock_change
.pid_namespace
=
47 cpu_to_le64((u64
)(unsigned long)fl
->fl_nspid
);
48 req
->r_args
.filelock_change
.start
= cpu_to_le64(fl
->fl_start
);
49 req
->r_args
.filelock_change
.length
= cpu_to_le64(length
);
50 req
->r_args
.filelock_change
.wait
= wait
;
52 err
= ceph_mdsc_do_request(mdsc
, inode
, req
);
54 if ( operation
== CEPH_MDS_OP_GETFILELOCK
){
55 fl
->fl_pid
= le64_to_cpu(req
->r_reply_info
.filelock_reply
->pid
);
56 if (CEPH_LOCK_SHARED
== req
->r_reply_info
.filelock_reply
->type
)
57 fl
->fl_type
= F_RDLCK
;
58 else if (CEPH_LOCK_EXCL
== req
->r_reply_info
.filelock_reply
->type
)
59 fl
->fl_type
= F_WRLCK
;
61 fl
->fl_type
= F_UNLCK
;
63 fl
->fl_start
= le64_to_cpu(req
->r_reply_info
.filelock_reply
->start
);
64 length
= le64_to_cpu(req
->r_reply_info
.filelock_reply
->start
) +
65 le64_to_cpu(req
->r_reply_info
.filelock_reply
->length
);
67 fl
->fl_end
= length
-1;
72 ceph_mdsc_put_request(req
);
73 dout("ceph_lock_message: rule: %d, op: %d, pid: %llu, start: %llu, "
74 "length: %llu, wait: %d, type`: %d, err code %d", (int)lock_type
,
75 (int)operation
, (u64
)fl
->fl_pid
, fl
->fl_start
,
76 length
, wait
, fl
->fl_type
, err
);
81 * Attempt to set an fcntl lock.
82 * For now, this just goes away to the server. Later it may be more awesome.
84 int ceph_lock(struct file
*file
, int cmd
, struct file_lock
*fl
)
89 u16 op
= CEPH_MDS_OP_SETFILELOCK
;
91 fl
->fl_nspid
= get_pid(task_tgid(current
));
92 dout("ceph_lock, fl_pid:%d", fl
->fl_pid
);
94 /* set wait bit as appropriate, then make command as Ceph expects it*/
98 op
= CEPH_MDS_OP_GETFILELOCK
;
100 if (F_RDLCK
== fl
->fl_type
)
101 lock_cmd
= CEPH_LOCK_SHARED
;
102 else if (F_WRLCK
== fl
->fl_type
)
103 lock_cmd
= CEPH_LOCK_EXCL
;
105 lock_cmd
= CEPH_LOCK_UNLOCK
;
107 err
= ceph_lock_message(CEPH_LOCK_FCNTL
, op
, file
, lock_cmd
, wait
, fl
);
109 if ( op
!= CEPH_MDS_OP_GETFILELOCK
){
110 dout("mds locked, locking locally");
111 err
= posix_lock_file(file
, fl
, NULL
);
112 if (err
&& (CEPH_MDS_OP_SETFILELOCK
== op
)) {
113 /* undo! This should only happen if the kernel detects
115 ceph_lock_message(CEPH_LOCK_FCNTL
, op
, file
,
116 CEPH_LOCK_UNLOCK
, 0, fl
);
117 dout("got %d on posix_lock_file, undid lock", err
);
122 dout("mds returned error code %d", err
);
127 int ceph_flock(struct file
*file
, int cmd
, struct file_lock
*fl
)
133 fl
->fl_nspid
= get_pid(task_tgid(current
));
134 dout("ceph_flock, fl_pid:%d", fl
->fl_pid
);
136 /* set wait bit, then clear it out of cmd*/
139 cmd
= cmd
& (LOCK_SH
| LOCK_EX
| LOCK_UN
);
140 /* set command sequence that Ceph wants to see:
141 shared lock, exclusive lock, or unlock */
143 lock_cmd
= CEPH_LOCK_SHARED
;
144 else if (LOCK_EX
== cmd
)
145 lock_cmd
= CEPH_LOCK_EXCL
;
147 lock_cmd
= CEPH_LOCK_UNLOCK
;
149 err
= ceph_lock_message(CEPH_LOCK_FLOCK
, CEPH_MDS_OP_SETFILELOCK
,
150 file
, lock_cmd
, wait
, fl
);
152 err
= flock_lock_file_wait(file
, fl
);
154 ceph_lock_message(CEPH_LOCK_FLOCK
,
155 CEPH_MDS_OP_SETFILELOCK
,
156 file
, CEPH_LOCK_UNLOCK
, 0, fl
);
157 dout("got %d on flock_lock_file_wait, undid lock", err
);
160 dout("mds error code %d", err
);
166 * Must be called with BKL already held. Fills in the passed
167 * counter variables, so you can prepare pagelist metadata before calling
170 void ceph_count_locks(struct inode
*inode
, int *fcntl_count
, int *flock_count
)
172 struct file_lock
*lock
;
177 for (lock
= inode
->i_flock
; lock
!= NULL
; lock
= lock
->fl_next
) {
178 if (lock
->fl_flags
& FL_POSIX
)
180 else if (lock
->fl_flags
& FL_FLOCK
)
183 dout("counted %d flock locks and %d fcntl locks",
184 *flock_count
, *fcntl_count
);
188 * Encode the flock and fcntl locks for the given inode into the pagelist.
189 * Format is: #fcntl locks, sequential fcntl locks, #flock locks,
190 * sequential flock locks.
191 * Must be called with lock_flocks() already held.
192 * If we encounter more of a specific lock type than expected,
193 * we return the value 1.
195 int ceph_encode_locks(struct inode
*inode
, struct ceph_pagelist
*pagelist
,
196 int num_fcntl_locks
, int num_flock_locks
)
198 struct file_lock
*lock
;
199 struct ceph_filelock cephlock
;
204 dout("encoding %d flock and %d fcntl locks", num_flock_locks
,
206 err
= ceph_pagelist_append(pagelist
, &num_fcntl_locks
, sizeof(u32
));
209 for (lock
= inode
->i_flock
; lock
!= NULL
; lock
= lock
->fl_next
) {
210 if (lock
->fl_flags
& FL_POSIX
) {
212 if (seen_fcntl
> num_fcntl_locks
) {
216 err
= lock_to_ceph_filelock(lock
, &cephlock
);
219 err
= ceph_pagelist_append(pagelist
, &cephlock
,
220 sizeof(struct ceph_filelock
));
226 err
= ceph_pagelist_append(pagelist
, &num_flock_locks
, sizeof(u32
));
229 for (lock
= inode
->i_flock
; lock
!= NULL
; lock
= lock
->fl_next
) {
230 if (lock
->fl_flags
& FL_FLOCK
) {
232 if (seen_flock
> num_flock_locks
) {
236 err
= lock_to_ceph_filelock(lock
, &cephlock
);
239 err
= ceph_pagelist_append(pagelist
, &cephlock
,
240 sizeof(struct ceph_filelock
));
250 * Given a pointer to a lock, convert it to a ceph filelock
252 int lock_to_ceph_filelock(struct file_lock
*lock
,
253 struct ceph_filelock
*cephlock
)
257 cephlock
->start
= cpu_to_le64(lock
->fl_start
);
258 cephlock
->length
= cpu_to_le64(lock
->fl_end
- lock
->fl_start
+ 1);
259 cephlock
->client
= cpu_to_le64(0);
260 cephlock
->pid
= cpu_to_le64(lock
->fl_pid
);
261 cephlock
->pid_namespace
=
262 cpu_to_le64((u64
)(unsigned long)lock
->fl_nspid
);
264 switch (lock
->fl_type
) {
266 cephlock
->type
= CEPH_LOCK_SHARED
;
269 cephlock
->type
= CEPH_LOCK_EXCL
;
272 cephlock
->type
= CEPH_LOCK_UNLOCK
;
275 dout("Have unknown lock type %d", lock
->fl_type
);
This page took 0.047602 seconds and 5 git commands to generate.