~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/ceph/locks.c

Version: ~ [ linux-5.3 ] ~ [ linux-5.2.15 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.73 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.144 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.193 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.193 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.73 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 #include <linux/ceph/ceph_debug.h>
  2 
  3 #include <linux/file.h>
  4 #include <linux/namei.h>
  5 #include <linux/random.h>
  6 
  7 #include "super.h"
  8 #include "mds_client.h"
  9 #include <linux/ceph/pagelist.h>
 10 
 11 static u64 lock_secret;
 12 static int ceph_lock_wait_for_completion(struct ceph_mds_client *mdsc,
 13                                          struct ceph_mds_request *req);
 14 
 15 static inline u64 secure_addr(void *addr)
 16 {
 17         u64 v = lock_secret ^ (u64)(unsigned long)addr;
 18         /*
 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')
 22          */
 23         v |= (1ULL << 63);
 24         return v;
 25 }
 26 
 27 void __init ceph_flock_init(void)
 28 {
 29         get_random_bytes(&lock_secret, sizeof(lock_secret));
 30 }
 31 
 32 /**
 33  * Implement fcntl and flock locking functions.
 34  */
 35 static int ceph_lock_message(u8 lock_type, u16 operation, struct file *file,
 36                              int cmd, u8 wait, struct file_lock *fl)
 37 {
 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;
 41         int err;
 42         u64 length = 0;
 43         u64 owner;
 44 
 45         if (operation != CEPH_MDS_OP_SETFILELOCK || cmd == CEPH_LOCK_UNLOCK)
 46                 wait = 0;
 47 
 48         req = ceph_mdsc_create_request(mdsc, operation, USE_AUTH_MDS);
 49         if (IS_ERR(req))
 50                 return PTR_ERR(req);
 51         req->r_inode = inode;
 52         ihold(inode);
 53         req->r_num_caps = 1;
 54 
 55         /* mds requires start and length rather than start and end */
 56         if (LLONG_MAX == fl->fl_end)
 57                 length = 0;
 58         else
 59                 length = fl->fl_end - fl->fl_start + 1;
 60 
 61         owner = secure_addr(fl->fl_owner);
 62 
 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,
 66              wait, fl->fl_type);
 67 
 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;
 75 
 76         if (wait)
 77                 req->r_wait_for_completion = ceph_lock_wait_for_completion;
 78 
 79         err = ceph_mdsc_do_request(mdsc, inode, req);
 80 
 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;
 87                 else
 88                         fl->fl_type = F_UNLCK;
 89 
 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);
 93                 if (length >= 1)
 94                         fl->fl_end = length -1;
 95                 else
 96                         fl->fl_end = 0;
 97 
 98         }
 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);
104         return err;
105 }
106 
107 static int ceph_lock_wait_for_completion(struct ceph_mds_client *mdsc,
108                                          struct ceph_mds_request *req)
109 {
110         struct ceph_mds_request *intr_req;
111         struct inode *inode = req->r_inode;
112         int err, lock_type;
113 
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;
119         else
120                 BUG_ON(1);
121         BUG_ON(req->r_args.filelock_change.type == CEPH_LOCK_UNLOCK);
122 
123         err = wait_for_completion_interruptible(&req->r_completion);
124         if (!err)
125                 return 0;
126 
127         dout("ceph_lock_wait_for_completion: request %llu was interrupted\n",
128              req->r_tid);
129 
130         intr_req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_SETFILELOCK,
131                                             USE_AUTH_MDS);
132         if (IS_ERR(intr_req))
133                 return PTR_ERR(intr_req);
134 
135         intr_req->r_inode = inode;
136         ihold(inode);
137         intr_req->r_num_caps = 1;
138 
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;
142 
143         err = ceph_mdsc_do_request(mdsc, inode, intr_req);
144         ceph_mdsc_put_request(intr_req);
145 
146         if (err && err != -ERESTARTSYS)
147                 return err;
148 
149         wait_for_completion(&req->r_completion);
150         return 0;
151 }
152 
153 /**
154  * Attempt to set an fcntl lock.
155  * For now, this just goes away to the server. Later it may be more awesome.
156  */
157 int ceph_lock(struct file *file, int cmd, struct file_lock *fl)
158 {
159         u8 lock_cmd;
160         int err;
161         u8 wait = 0;
162         u16 op = CEPH_MDS_OP_SETFILELOCK;
163 
164         if (!(fl->fl_flags & FL_POSIX))
165                 return -ENOLCK;
166         /* No mandatory locks */
167         if (__mandatory_lock(file->f_mapping->host) && fl->fl_type != F_UNLCK)
168                 return -ENOLCK;
169 
170         dout("ceph_lock, fl_owner: %p", fl->fl_owner);
171 
172         /* set wait bit as appropriate, then make command as Ceph expects it*/
173         if (IS_GETLK(cmd))
174                 op = CEPH_MDS_OP_GETFILELOCK;
175         else if (IS_SETLKW(cmd))
176                 wait = 1;
177 
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;
182         else
183                 lock_cmd = CEPH_LOCK_UNLOCK;
184 
185         err = ceph_lock_message(CEPH_LOCK_FCNTL, op, file, lock_cmd, wait, fl);
186         if (!err) {
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
193                                  * deadlock. */
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",
197                                      err);
198                         }
199                 }
200         }
201         return err;
202 }
203 
204 int ceph_flock(struct file *file, int cmd, struct file_lock *fl)
205 {
206         u8 lock_cmd;
207         int err;
208         u8 wait = 0;
209 
210         if (!(fl->fl_flags & FL_FLOCK))
211                 return -ENOLCK;
212         /* No mandatory locks */
213         if (__mandatory_lock(file->f_mapping->host) && fl->fl_type != F_UNLCK)
214                 return -ENOLCK;
215 
216         dout("ceph_flock, fl_file: %p", fl->fl_file);
217 
218         if (IS_SETLKW(cmd))
219                 wait = 1;
220 
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;
225         else
226                 lock_cmd = CEPH_LOCK_UNLOCK;
227 
228         err = ceph_lock_message(CEPH_LOCK_FLOCK, CEPH_MDS_OP_SETFILELOCK,
229                                 file, lock_cmd, wait, fl);
230         if (!err) {
231                 err = flock_lock_file_wait(file, fl);
232                 if (err) {
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);
237                 }
238         }
239         return err;
240 }
241 
242 /*
243  * Fills in the passed counter variables, so you can prepare pagelist metadata
244  * before calling ceph_encode_locks.
245  */
246 void ceph_count_locks(struct inode *inode, int *fcntl_count, int *flock_count)
247 {
248         struct file_lock *lock;
249         struct file_lock_context *ctx;
250 
251         *fcntl_count = 0;
252         *flock_count = 0;
253 
254         ctx = inode->i_flctx;
255         if (ctx) {
256                 spin_lock(&ctx->flc_lock);
257                 list_for_each_entry(lock, &ctx->flc_posix, fl_list)
258                         ++(*fcntl_count);
259                 list_for_each_entry(lock, &ctx->flc_flock, fl_list)
260                         ++(*flock_count);
261                 spin_unlock(&ctx->flc_lock);
262         }
263         dout("counted %d flock locks and %d fcntl locks",
264              *flock_count, *fcntl_count);
265 }
266 
267 /**
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.
271  */
272 int ceph_encode_locks_to_buffer(struct inode *inode,
273                                 struct ceph_filelock *flocks,
274                                 int num_fcntl_locks, int num_flock_locks)
275 {
276         struct file_lock *lock;
277         struct file_lock_context *ctx = inode->i_flctx;
278         int err = 0;
279         int seen_fcntl = 0;
280         int seen_flock = 0;
281         int l = 0;
282 
283         dout("encoding %d flock and %d fcntl locks", num_flock_locks,
284              num_fcntl_locks);
285 
286         if (!ctx)
287                 return 0;
288 
289         spin_lock(&ctx->flc_lock);
290         list_for_each_entry(lock, &ctx->flc_posix, fl_list) {
291                 ++seen_fcntl;
292                 if (seen_fcntl > num_fcntl_locks) {
293                         err = -ENOSPC;
294                         goto fail;
295                 }
296                 err = lock_to_ceph_filelock(lock, &flocks[l]);
297                 if (err)
298                         goto fail;
299                 ++l;
300         }
301         list_for_each_entry(lock, &ctx->flc_flock, fl_list) {
302                 ++seen_flock;
303                 if (seen_flock > num_flock_locks) {
304                         err = -ENOSPC;
305                         goto fail;
306                 }
307                 err = lock_to_ceph_filelock(lock, &flocks[l]);
308                 if (err)
309                         goto fail;
310                 ++l;
311         }
312 fail:
313         spin_unlock(&ctx->flc_lock);
314         return err;
315 }
316 
317 /**
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.
322  */
323 int ceph_locks_to_pagelist(struct ceph_filelock *flocks,
324                            struct ceph_pagelist *pagelist,
325                            int num_fcntl_locks, int num_flock_locks)
326 {
327         int err = 0;
328         __le32 nlocks;
329 
330         nlocks = cpu_to_le32(num_fcntl_locks);
331         err = ceph_pagelist_append(pagelist, &nlocks, sizeof(nlocks));
332         if (err)
333                 goto out_fail;
334 
335         err = ceph_pagelist_append(pagelist, flocks,
336                                    num_fcntl_locks * sizeof(*flocks));
337         if (err)
338                 goto out_fail;
339 
340         nlocks = cpu_to_le32(num_flock_locks);
341         err = ceph_pagelist_append(pagelist, &nlocks, sizeof(nlocks));
342         if (err)
343                 goto out_fail;
344 
345         err = ceph_pagelist_append(pagelist,
346                                    &flocks[num_fcntl_locks],
347                                    num_flock_locks * sizeof(*flocks));
348 out_fail:
349         return err;
350 }
351 
352 /*
353  * Given a pointer to a lock, convert it to a ceph filelock
354  */
355 int lock_to_ceph_filelock(struct file_lock *lock,
356                           struct ceph_filelock *cephlock)
357 {
358         int err = 0;
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));
364 
365         switch (lock->fl_type) {
366         case F_RDLCK:
367                 cephlock->type = CEPH_LOCK_SHARED;
368                 break;
369         case F_WRLCK:
370                 cephlock->type = CEPH_LOCK_EXCL;
371                 break;
372         case F_UNLCK:
373                 cephlock->type = CEPH_LOCK_UNLOCK;
374                 break;
375         default:
376                 dout("Have unknown lock type %d", lock->fl_type);
377                 err = -EINVAL;
378         }
379 
380         return err;
381 }
382 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp