![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to locks.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Early Linux] / linux / fs|
Return to locks.c CVS log | Up to [Early Linux] / linux / fs |
1.1 root 1: /*
2: * linux/fs/locks.c
3: *
4: * Provide support for fcntl()'s F_GETLK, F_SETLK, and F_SETLKW calls.
5: * Doug Evans, 92Aug07, [email protected].
6: *
7: * FIXME: two things aren't handled yet:
8: * - deadlock detection/avoidance (of dubious merit, but since it's in
9: * the definition, I guess it should be provided eventually)
10: * - mandatory locks (requires lots of changes elsewhere)
11: */
12:
13: #include <asm/segment.h>
14:
15: #include <linux/sched.h>
16: #include <linux/kernel.h>
17: #include <linux/errno.h>
18: #include <linux/stat.h>
19: #include <linux/fcntl.h>
20:
21: #define OFFSET_MAX 0x7fffffff /* FIXME: move elsewhere? */
22:
23: static int copy_flock(struct file *filp, struct file_lock *fl, struct flock *l);
24: static int conflict(struct file_lock *caller_fl, struct file_lock *sys_fl);
25: static int overlap(struct file_lock *fl1, struct file_lock *fl2);
26: static int lock_it(struct file *filp, struct file_lock *caller);
27: static int unlock_it(struct file *filp, struct file_lock *caller);
28: static struct file_lock *alloc_lock(struct file *filp, struct file_lock *template);
29: static void free_lock(struct file *filp, struct file_lock *fl);
30:
31: static struct file_lock file_lock_table[NR_FILE_LOCKS];
32: static struct file_lock *file_lock_free_list;
33:
34: /*
35: * Called at boot time to initialize the lock table ...
36: */
37:
38: void fcntl_init_locks(void)
39: {
40: struct file_lock *fl;
41:
42: for (fl = &file_lock_table[0]; fl < file_lock_table + NR_FILE_LOCKS - 1; fl++) {
43: fl->fl_next = fl + 1;
44: fl->fl_owner = NULL;
45: }
46: file_lock_table[NR_FILE_LOCKS - 1].fl_next = NULL;
47: file_lock_table[NR_FILE_LOCKS - 1].fl_owner = NULL;
48: file_lock_free_list = &file_lock_table[0];
49: }
50:
51: int fcntl_getlk(unsigned int fd, struct flock *l)
52: {
53: struct flock flock;
54: struct file *filp;
55: struct file_lock *fl,file_lock;
56:
57: if (fd >= NR_OPEN || !(filp = current->filp[fd]))
58: return -EBADF;
59: verify_area(l, sizeof(*l));
60: memcpy_fromfs(&flock, l, sizeof(flock));
61: if (flock.l_type == F_UNLCK)
62: return -EINVAL;
63: if (!copy_flock(filp, &file_lock, &flock))
64: return -EINVAL;
65:
66: for (fl = filp->f_inode->i_flock; fl != NULL; fl = fl->fl_next) {
67: if (conflict(&file_lock, fl)) {
68: flock.l_pid = fl->fl_owner->pid;
69: flock.l_start = fl->fl_start;
70: flock.l_len = fl->fl_end == OFFSET_MAX ? 0 :
71: fl->fl_end - fl->fl_start + 1;
72: flock.l_whence = fl->fl_whence;
73: flock.l_type = fl->fl_type;
74: memcpy_tofs(l, &flock, sizeof(flock));
75: return 0;
76: }
77: }
78:
79: flock.l_type = F_UNLCK; /* no conflict found */
80: memcpy_tofs(l, &flock, sizeof(flock));
81: return 0;
82: }
83:
84: /*
85: * This function implements both F_SETLK and F_SETLKW.
86: */
87:
88: int fcntl_setlk(unsigned int fd, unsigned int cmd, struct flock *l)
89: {
90: struct file *filp;
91: struct file_lock *fl,file_lock;
92: struct flock flock;
93:
94: /*
95: * Get arguments and validate them ...
96: */
97:
98: if (fd >= NR_OPEN || !(filp = current->filp[fd]))
99: return -EBADF;
100: verify_area(l, sizeof(*l));
101: memcpy_fromfs(&flock, l, sizeof(flock));
102: if (!copy_flock(filp, &file_lock, &flock))
103: return -EINVAL;
104: switch (file_lock.fl_type) {
105: case F_RDLCK :
106: if (!(filp->f_mode & 1))
107: return -EBADF;
108: break;
109: case F_WRLCK :
110: if (!(filp->f_mode & 2))
111: return -EBADF;
112: break;
113: case F_UNLCK :
114: break;
115: }
116:
117: /*
118: * F_UNLCK needs to be handled differently ...
119: */
120:
121: if (file_lock.fl_type == F_UNLCK)
122: return unlock_it(filp, &file_lock);
123:
124: /*
125: * Scan for a conflicting lock ...
126: */
127:
128: repeat:
129: for (fl = filp->f_inode->i_flock; fl != NULL; fl = fl->fl_next) {
130: if (!conflict(&file_lock, fl))
131: continue;
132: /*
133: * File is locked by another process. If this is F_SETLKW
134: * wait for the lock to be released.
135: * FIXME: We need to check for deadlocks here.
136: */
137: if (cmd == F_SETLKW) {
138: interruptible_sleep_on(&fl->fl_wait);
139: goto repeat;
140: }
141: return -EAGAIN;
142: }
143:
144: /*
145: * Lock doesn't conflict with any other lock ...
146: */
147:
148: return lock_it(filp, &file_lock);
149: }
150:
151: /*
152: * This function is called when the file is closed.
153: */
154:
155: void fcntl_remove_locks(struct task_struct *task, struct file *filp)
156: {
157: struct file_lock *fl,*next;
158:
159: for (fl = filp->f_inode->i_flock; fl != NULL; ) {
160: /*
161: * If this one is freed, {fl_next} gets clobbered when the
162: * entry is moved to the free list, so grab it now ...
163: */
164: next = fl->fl_next;
165: if (fl->fl_owner == task)
166: free_lock(filp, fl);
167: fl = next;
168: }
169: }
170:
171: /*
172: * Verify a "struct flock" and copy it to a "struct file_lock" ...
173: * Result is a boolean indicating success.
174: */
175:
176: static int copy_flock(struct file *filp, struct file_lock *fl, struct flock *l)
177: {
178: off_t start;
179:
180: if (!filp->f_inode) /* just in case */
181: return 0;
182: if (!S_ISREG(filp->f_inode->i_mode))
183: return 0;
184: if (l->l_type != F_UNLCK && l->l_type != F_RDLCK && l->l_type != F_WRLCK)
185: return 0;
186: switch (l->l_whence) {
187: case 0 /*SEEK_SET*/ : start = 0; break;
188: case 1 /*SEEK_CUR*/ : start = filp->f_pos; break;
189: case 2 /*SEEK_END*/ : start = filp->f_inode->i_size; break;
190: default : return 0;
191: }
192: if ((start += l->l_start) < 0 || l->l_len < 0)
193: return 0;
194: fl->fl_type = l->l_type;
195: fl->fl_start = start; /* we record the absolute position */
196: fl->fl_whence = 0; /* FIXME: do we record {l_start} as passed? */
197: if (l->l_len == 0 || (fl->fl_end = start + l->l_len - 1) < 0)
198: fl->fl_end = OFFSET_MAX;
199: fl->fl_owner = current;
200: fl->fl_wait = NULL; /* just for cleanliness */
201: return 1;
202: }
203:
204: /*
205: * Determine if lock {sys_fl} blocks lock {caller_fl} ...
206: */
207:
208: static int conflict(struct file_lock *caller_fl, struct file_lock *sys_fl)
209: {
210: if (caller_fl->fl_owner == sys_fl->fl_owner)
211: return 0;
212: if (!overlap(caller_fl, sys_fl))
213: return 0;
214: switch (caller_fl->fl_type) {
215: case F_RDLCK :
216: return sys_fl->fl_type != F_RDLCK;
217: case F_WRLCK :
218: return 1; /* overlapping region not owned by caller */
219: }
220: return 0; /* shouldn't get here, but just in case */
221: }
222:
223: static int overlap(struct file_lock *fl1, struct file_lock *fl2)
224: {
225: if (fl1->fl_start <= fl2->fl_start) {
226: return fl1->fl_end >= fl2->fl_start;
227: } else {
228: return fl2->fl_end >= fl1->fl_start;
229: }
230: }
231:
232: /*
233: * Add a lock to a file ...
234: * Result is 0 for success or -ENOLCK.
235: *
236: * We try to be real clever here and always minimize the number of table
237: * entries we use. For example we merge adjacent locks whenever possible. This
238: * consumes a bit of cpu and code space, is it really worth it? Beats me.
239: *
240: * I've tried to keep the following as small and simple as possible. If you can
241: * make it smaller or simpler, please do. /dje 92Aug11
242: *
243: * WARNING: We assume the lock doesn't conflict with any other lock.
244: */
245:
246: static int lock_it(struct file *filp, struct file_lock *caller)
247: {
248: struct file_lock *fl,*new;
249:
250: /*
251: * It's easier if we allocate a slot for the lock first, and then
252: * release it later if we have to (IE: if it can be merged with
253: * another). This way the for() loop always knows that {caller} is an
254: * existing entry. This will cause the routine to fail unnecessarily
255: * in rare cases, but perfection can be pushed too far. :-)
256: */
257:
258: if ((caller = alloc_lock(filp, caller)) == NULL)
259: return -ENOLCK;
260:
261: /*
262: * First scan to see if we are changing/augmenting an existing lock ...
263: */
264:
265: for (fl = filp->f_inode->i_flock; fl != NULL; fl = fl->fl_next) {
266: if (caller->fl_owner != fl->fl_owner)
267: continue;
268: if (caller == fl)
269: continue;
270: if (!overlap(caller, fl)) {
271: /*
272: * Detect adjacent regions (if same lock type) ...
273: */
274: if (caller->fl_type != fl->fl_type)
275: continue;
276: if (caller->fl_end + 1 == fl->fl_start) {
277: fl->fl_start = caller->fl_start;
278: free_lock(filp, caller);
279: caller = fl;
280: /* must continue, may overlap others now */
281: } else if (caller->fl_start - 1 == fl->fl_end) {
282: fl->fl_end = caller->fl_end;
283: free_lock(filp, caller);
284: caller = fl;
285: /* must continue, may overlap others now */
286: }
287: continue;
288: }
289: /*
290: * We've found an overlapping region. Is it a change of lock
291: * type, or are we changing the size of the locked space?
292: */
293: if (caller->fl_type != fl->fl_type) {
294: if (caller->fl_start > fl->fl_start && caller->fl_end < fl->fl_end) {
295: /*
296: * The new lock splits the old one in two ...
297: * {fl} is the bottom piece, {caller} is the
298: * new lock, and {new} is the top piece.
299: */
300: if ((new = alloc_lock(filp, fl)) == NULL) {
301: free_lock(filp, caller);
302: return -ENOLCK;
303: }
304: fl->fl_end = caller->fl_start - 1;
305: new->fl_start = caller->fl_end + 1;
306: return 0;
307: }
308: if (caller->fl_start <= fl->fl_start && caller->fl_end >= fl->fl_end) {
309: /*
310: * The new lock completely replaces old one ...
311: */
312: free_lock(filp, fl);
313: return 0;
314: }
315: if (caller->fl_end < fl->fl_end) {
316: fl->fl_start = caller->fl_end + 1;
317: /* must continue, may be more overlaps */
318: } else if (caller->fl_start > fl->fl_start) {
319: fl->fl_end = caller->fl_start - 1;
320: /* must continue, may be more overlaps */
321: } else {
322: printk("lock_it: program bug: unanticipated overlap\n");
323: free_lock(filp, caller);
324: return -ENOLCK;
325: }
326: } else { /* The new lock augments an existing lock ... */
327: int grew = 0;
328:
329: if (caller->fl_start < fl->fl_start) {
330: fl->fl_start = caller->fl_start;
331: grew = 1;
332: }
333: if (caller->fl_end > fl->fl_end) {
334: fl->fl_end = caller->fl_end;
335: grew = 1;
336: }
337: free_lock(filp, caller);
338: caller = fl;
339: if (!grew)
340: return 0;
341: /* must continue, may be more overlaps */
342: }
343: }
344:
345: /*
346: * New lock doesn't overlap any regions ...
347: * alloc_lock() has already been called, so we're done!
348: */
349:
350: return 0;
351: }
352:
353: /*
354: * Handle F_UNLCK ...
355: * Result is 0 for success, or -EINVAL or -ENOLCK.
356: * ENOLCK can happen when a lock is split into two.
357: */
358:
359: static int unlock_it(struct file *filp, struct file_lock *caller)
360: {
361: int one_unlocked = 0;
362: struct file_lock *fl,*next;
363:
364: for (fl = filp->f_inode->i_flock; fl != NULL; ) {
365: if (caller->fl_owner != fl->fl_owner || !overlap(caller, fl)) {
366: fl = fl->fl_next;
367: continue;
368: }
369: one_unlocked = 1;
370: if (caller->fl_start > fl->fl_start && caller->fl_end < fl->fl_end) {
371: /*
372: * Lock is split in two ...
373: * {fl} is the bottom piece, {next} is the top piece.
374: */
375: if ((next = alloc_lock(filp, fl)) == NULL)
376: return -ENOLCK;
377: fl->fl_end = caller->fl_start - 1;
378: next->fl_start = caller->fl_end + 1;
379: return 0;
380: }
381: /*
382: * At this point we know there is an overlap and we know the
383: * lock isn't split into two ...
384: *
385: * Unless the lock table is broken, entries will not overlap.
386: * IE: User X won't have an entry locking bytes 1-3 and another
387: * entry locking bytes 3-5. Therefore, if the area being
388: * unlocked is a subset of the total area, we don't need to
389: * traverse any more of the list. The code is a tad more
390: * complicated by this optimization. Perhaps it's not worth it.
391: *
392: * WARNING: We assume free_lock() does not alter
393: * {fl_start, fl_end}.
394: *
395: * {fl_next} gets clobbered when the entry is moved to
396: * the free list, so grab it now ...
397: */
398: next = fl->fl_next;
399: if (caller->fl_start <= fl->fl_start && caller->fl_end >= fl->fl_end) {
400: free_lock(filp, fl);
401: } else if (caller->fl_start > fl->fl_start) {
402: fl->fl_end = caller->fl_start - 1;
403: } else {
404: /* caller->fl_end < fl->fl_end */
405: fl->fl_start = caller->fl_end + 1;
406: }
407: if (caller->fl_start >= fl->fl_start && caller->fl_end <= fl->fl_end)
408: return 0; /* no more to be found */
409: fl = next;
410: /* must continue, there may be more to unlock */
411: }
412:
413: return one_unlocked ? 0 : -EINVAL;
414: }
415:
416: static struct file_lock *alloc_lock(struct file *filp, struct file_lock *template)
417: {
418: struct file_lock *new;
419:
420: if (file_lock_free_list == NULL)
421: return NULL; /* no available entry */
422: if (file_lock_free_list->fl_owner != NULL)
423: panic("alloc_lock: broken free list\n");
424:
425: new = file_lock_free_list; /* remove from free list */
426: file_lock_free_list = file_lock_free_list->fl_next;
427:
428: *new = *template;
429:
430: new->fl_next = filp->f_inode->i_flock; /* insert into file's list */
431: filp->f_inode->i_flock = new;
432:
433: new->fl_owner = current; /* FIXME: needed? */
434: new->fl_wait = NULL;
435: return new;
436: }
437:
438: /*
439: * Add a lock to the free list ...
440: *
441: * WARNING: We must not alter {fl_start, fl_end}. See unlock_it().
442: */
443:
444: static void free_lock(struct file *filp, struct file_lock *fl)
445: {
446: struct file_lock **fl_p;
447:
448: if (fl->fl_owner == NULL) /* sanity check */
449: panic("free_lock: broken lock list\n");
450:
451: /*
452: * We only use a singly linked list to save some memory space
453: * (the only place we'd use a doubly linked list is here).
454: */
455:
456: for (fl_p = &filp->f_inode->i_flock; *fl_p != NULL; fl_p = &(*fl_p)->fl_next) {
457: if (*fl_p == fl)
458: break;
459: }
460: if (*fl_p == NULL) {
461: printk("free_lock: lock is not in file's lock list\n");
462: } else {
463: *fl_p = (*fl_p)->fl_next;
464: }
465:
466: fl->fl_next = file_lock_free_list; /* add to free list */
467: file_lock_free_list = fl;
468: fl->fl_owner = NULL; /* for sanity checks */
469:
470: wake_up(&fl->fl_wait);
471: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.