locks.c 55 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236
  1. /*
  2. * linux/fs/locks.c
  3. *
  4. * Provide support for fcntl()'s F_GETLK, F_SETLK, and F_SETLKW calls.
  5. * Doug Evans (dje@spiff.uucp), August 07, 1992
  6. *
  7. * Deadlock detection added.
  8. * FIXME: one thing isn't handled yet:
  9. * - mandatory locks (requires lots of changes elsewhere)
  10. * Kelly Carmichael (kelly@[142.24.8.65]), September 17, 1994.
  11. *
  12. * Miscellaneous edits, and a total rewrite of posix_lock_file() code.
  13. * Kai Petzke (wpp@marie.physik.tu-berlin.de), 1994
  14. *
  15. * Converted file_lock_table to a linked list from an array, which eliminates
  16. * the limits on how many active file locks are open.
  17. * Chad Page (pageone@netcom.com), November 27, 1994
  18. *
  19. * Removed dependency on file descriptors. dup()'ed file descriptors now
  20. * get the same locks as the original file descriptors, and a close() on
  21. * any file descriptor removes ALL the locks on the file for the current
  22. * process. Since locks still depend on the process id, locks are inherited
  23. * after an exec() but not after a fork(). This agrees with POSIX, and both
  24. * BSD and SVR4 practice.
  25. * Andy Walker (andy@lysaker.kvaerner.no), February 14, 1995
  26. *
  27. * Scrapped free list which is redundant now that we allocate locks
  28. * dynamically with kmalloc()/kfree().
  29. * Andy Walker (andy@lysaker.kvaerner.no), February 21, 1995
  30. *
  31. * Implemented two lock personalities - FL_FLOCK and FL_POSIX.
  32. *
  33. * FL_POSIX locks are created with calls to fcntl() and lockf() through the
  34. * fcntl() system call. They have the semantics described above.
  35. *
  36. * FL_FLOCK locks are created with calls to flock(), through the flock()
  37. * system call, which is new. Old C libraries implement flock() via fcntl()
  38. * and will continue to use the old, broken implementation.
  39. *
  40. * FL_FLOCK locks follow the 4.4 BSD flock() semantics. They are associated
  41. * with a file pointer (filp). As a result they can be shared by a parent
  42. * process and its children after a fork(). They are removed when the last
  43. * file descriptor referring to the file pointer is closed (unless explicitly
  44. * unlocked).
  45. *
  46. * FL_FLOCK locks never deadlock, an existing lock is always removed before
  47. * upgrading from shared to exclusive (or vice versa). When this happens
  48. * any processes blocked by the current lock are woken up and allowed to
  49. * run before the new lock is applied.
  50. * Andy Walker (andy@lysaker.kvaerner.no), June 09, 1995
  51. *
  52. * Removed some race conditions in flock_lock_file(), marked other possible
  53. * races. Just grep for FIXME to see them.
  54. * Dmitry Gorodchanin (pgmdsg@ibi.com), February 09, 1996.
  55. *
  56. * Addressed Dmitry's concerns. Deadlock checking no longer recursive.
  57. * Lock allocation changed to GFP_ATOMIC as we can't afford to sleep
  58. * once we've checked for blocking and deadlocking.
  59. * Andy Walker (andy@lysaker.kvaerner.no), April 03, 1996.
  60. *
  61. * Initial implementation of mandatory locks. SunOS turned out to be
  62. * a rotten model, so I implemented the "obvious" semantics.
  63. * See 'Documentation/mandatory.txt' for details.
  64. * Andy Walker (andy@lysaker.kvaerner.no), April 06, 1996.
  65. *
  66. * Don't allow mandatory locks on mmap()'ed files. Added simple functions to
  67. * check if a file has mandatory locks, used by mmap(), open() and creat() to
  68. * see if system call should be rejected. Ref. HP-UX/SunOS/Solaris Reference
  69. * Manual, Section 2.
  70. * Andy Walker (andy@lysaker.kvaerner.no), April 09, 1996.
  71. *
  72. * Tidied up block list handling. Added '/proc/locks' interface.
  73. * Andy Walker (andy@lysaker.kvaerner.no), April 24, 1996.
  74. *
  75. * Fixed deadlock condition for pathological code that mixes calls to
  76. * flock() and fcntl().
  77. * Andy Walker (andy@lysaker.kvaerner.no), April 29, 1996.
  78. *
  79. * Allow only one type of locking scheme (FL_POSIX or FL_FLOCK) to be in use
  80. * for a given file at a time. Changed the CONFIG_LOCK_MANDATORY scheme to
  81. * guarantee sensible behaviour in the case where file system modules might
  82. * be compiled with different options than the kernel itself.
  83. * Andy Walker (andy@lysaker.kvaerner.no), May 15, 1996.
  84. *
  85. * Added a couple of missing wake_up() calls. Thanks to Thomas Meckel
  86. * (Thomas.Meckel@mni.fh-giessen.de) for spotting this.
  87. * Andy Walker (andy@lysaker.kvaerner.no), May 15, 1996.
  88. *
  89. * Changed FL_POSIX locks to use the block list in the same way as FL_FLOCK
  90. * locks. Changed process synchronisation to avoid dereferencing locks that
  91. * have already been freed.
  92. * Andy Walker (andy@lysaker.kvaerner.no), Sep 21, 1996.
  93. *
  94. * Made the block list a circular list to minimise searching in the list.
  95. * Andy Walker (andy@lysaker.kvaerner.no), Sep 25, 1996.
  96. *
  97. * Made mandatory locking a mount option. Default is not to allow mandatory
  98. * locking.
  99. * Andy Walker (andy@lysaker.kvaerner.no), Oct 04, 1996.
  100. *
  101. * Some adaptations for NFS support.
  102. * Olaf Kirch (okir@monad.swb.de), Dec 1996,
  103. *
  104. * Fixed /proc/locks interface so that we can't overrun the buffer we are handed.
  105. * Andy Walker (andy@lysaker.kvaerner.no), May 12, 1997.
  106. *
  107. * Use slab allocator instead of kmalloc/kfree.
  108. * Use generic list implementation from <linux/list.h>.
  109. * Sped up posix_locks_deadlock by only considering blocked locks.
  110. * Matthew Wilcox <willy@debian.org>, March, 2000.
  111. *
  112. * Leases and LOCK_MAND
  113. * Matthew Wilcox <willy@debian.org>, June, 2000.
  114. * Stephen Rothwell <sfr@canb.auug.org.au>, June, 2000.
  115. */
  116. #include <linux/capability.h>
  117. #include <linux/file.h>
  118. #include <linux/fs.h>
  119. #include <linux/init.h>
  120. #include <linux/module.h>
  121. #include <linux/security.h>
  122. #include <linux/slab.h>
  123. #include <linux/smp_lock.h>
  124. #include <linux/syscalls.h>
  125. #include <linux/time.h>
  126. #include <linux/rcupdate.h>
  127. #include <asm/semaphore.h>
  128. #include <asm/uaccess.h>
  129. #define IS_POSIX(fl) (fl->fl_flags & FL_POSIX)
  130. #define IS_FLOCK(fl) (fl->fl_flags & FL_FLOCK)
  131. #define IS_LEASE(fl) (fl->fl_flags & FL_LEASE)
  132. int leases_enable = 1;
  133. int lease_break_time = 45;
  134. #define for_each_lock(inode, lockp) \
  135. for (lockp = &inode->i_flock; *lockp != NULL; lockp = &(*lockp)->fl_next)
  136. static LIST_HEAD(file_lock_list);
  137. static LIST_HEAD(blocked_list);
  138. static struct kmem_cache *filelock_cache __read_mostly;
  139. /* Allocate an empty lock structure. */
  140. static struct file_lock *locks_alloc_lock(void)
  141. {
  142. return kmem_cache_alloc(filelock_cache, GFP_KERNEL);
  143. }
  144. static void locks_release_private(struct file_lock *fl)
  145. {
  146. if (fl->fl_ops) {
  147. if (fl->fl_ops->fl_release_private)
  148. fl->fl_ops->fl_release_private(fl);
  149. fl->fl_ops = NULL;
  150. }
  151. if (fl->fl_lmops) {
  152. if (fl->fl_lmops->fl_release_private)
  153. fl->fl_lmops->fl_release_private(fl);
  154. fl->fl_lmops = NULL;
  155. }
  156. }
  157. /* Free a lock which is not in use. */
  158. static void locks_free_lock(struct file_lock *fl)
  159. {
  160. BUG_ON(waitqueue_active(&fl->fl_wait));
  161. BUG_ON(!list_empty(&fl->fl_block));
  162. BUG_ON(!list_empty(&fl->fl_link));
  163. locks_release_private(fl);
  164. kmem_cache_free(filelock_cache, fl);
  165. }
  166. void locks_init_lock(struct file_lock *fl)
  167. {
  168. INIT_LIST_HEAD(&fl->fl_link);
  169. INIT_LIST_HEAD(&fl->fl_block);
  170. init_waitqueue_head(&fl->fl_wait);
  171. fl->fl_next = NULL;
  172. fl->fl_fasync = NULL;
  173. fl->fl_owner = NULL;
  174. fl->fl_pid = 0;
  175. fl->fl_file = NULL;
  176. fl->fl_flags = 0;
  177. fl->fl_type = 0;
  178. fl->fl_start = fl->fl_end = 0;
  179. fl->fl_ops = NULL;
  180. fl->fl_lmops = NULL;
  181. }
  182. EXPORT_SYMBOL(locks_init_lock);
  183. /*
  184. * Initialises the fields of the file lock which are invariant for
  185. * free file_locks.
  186. */
  187. static void init_once(void *foo, struct kmem_cache *cache, unsigned long flags)
  188. {
  189. struct file_lock *lock = (struct file_lock *) foo;
  190. if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) !=
  191. SLAB_CTOR_CONSTRUCTOR)
  192. return;
  193. locks_init_lock(lock);
  194. }
  195. static void locks_copy_private(struct file_lock *new, struct file_lock *fl)
  196. {
  197. if (fl->fl_ops) {
  198. if (fl->fl_ops->fl_copy_lock)
  199. fl->fl_ops->fl_copy_lock(new, fl);
  200. new->fl_ops = fl->fl_ops;
  201. }
  202. if (fl->fl_lmops) {
  203. if (fl->fl_lmops->fl_copy_lock)
  204. fl->fl_lmops->fl_copy_lock(new, fl);
  205. new->fl_lmops = fl->fl_lmops;
  206. }
  207. }
  208. /*
  209. * Initialize a new lock from an existing file_lock structure.
  210. */
  211. static void __locks_copy_lock(struct file_lock *new, const struct file_lock *fl)
  212. {
  213. new->fl_owner = fl->fl_owner;
  214. new->fl_pid = fl->fl_pid;
  215. new->fl_file = NULL;
  216. new->fl_flags = fl->fl_flags;
  217. new->fl_type = fl->fl_type;
  218. new->fl_start = fl->fl_start;
  219. new->fl_end = fl->fl_end;
  220. new->fl_ops = NULL;
  221. new->fl_lmops = NULL;
  222. }
  223. void locks_copy_lock(struct file_lock *new, struct file_lock *fl)
  224. {
  225. locks_release_private(new);
  226. __locks_copy_lock(new, fl);
  227. new->fl_file = fl->fl_file;
  228. new->fl_ops = fl->fl_ops;
  229. new->fl_lmops = fl->fl_lmops;
  230. locks_copy_private(new, fl);
  231. }
  232. EXPORT_SYMBOL(locks_copy_lock);
  233. static inline int flock_translate_cmd(int cmd) {
  234. if (cmd & LOCK_MAND)
  235. return cmd & (LOCK_MAND | LOCK_RW);
  236. switch (cmd) {
  237. case LOCK_SH:
  238. return F_RDLCK;
  239. case LOCK_EX:
  240. return F_WRLCK;
  241. case LOCK_UN:
  242. return F_UNLCK;
  243. }
  244. return -EINVAL;
  245. }
  246. /* Fill in a file_lock structure with an appropriate FLOCK lock. */
  247. static int flock_make_lock(struct file *filp, struct file_lock **lock,
  248. unsigned int cmd)
  249. {
  250. struct file_lock *fl;
  251. int type = flock_translate_cmd(cmd);
  252. if (type < 0)
  253. return type;
  254. fl = locks_alloc_lock();
  255. if (fl == NULL)
  256. return -ENOMEM;
  257. fl->fl_file = filp;
  258. fl->fl_pid = current->tgid;
  259. fl->fl_flags = FL_FLOCK;
  260. fl->fl_type = type;
  261. fl->fl_end = OFFSET_MAX;
  262. *lock = fl;
  263. return 0;
  264. }
  265. static int assign_type(struct file_lock *fl, int type)
  266. {
  267. switch (type) {
  268. case F_RDLCK:
  269. case F_WRLCK:
  270. case F_UNLCK:
  271. fl->fl_type = type;
  272. break;
  273. default:
  274. return -EINVAL;
  275. }
  276. return 0;
  277. }
  278. /* Verify a "struct flock" and copy it to a "struct file_lock" as a POSIX
  279. * style lock.
  280. */
  281. static int flock_to_posix_lock(struct file *filp, struct file_lock *fl,
  282. struct flock *l)
  283. {
  284. off_t start, end;
  285. switch (l->l_whence) {
  286. case SEEK_SET:
  287. start = 0;
  288. break;
  289. case SEEK_CUR:
  290. start = filp->f_pos;
  291. break;
  292. case SEEK_END:
  293. start = i_size_read(filp->f_path.dentry->d_inode);
  294. break;
  295. default:
  296. return -EINVAL;
  297. }
  298. /* POSIX-1996 leaves the case l->l_len < 0 undefined;
  299. POSIX-2001 defines it. */
  300. start += l->l_start;
  301. if (start < 0)
  302. return -EINVAL;
  303. fl->fl_end = OFFSET_MAX;
  304. if (l->l_len > 0) {
  305. end = start + l->l_len - 1;
  306. fl->fl_end = end;
  307. } else if (l->l_len < 0) {
  308. end = start - 1;
  309. fl->fl_end = end;
  310. start += l->l_len;
  311. if (start < 0)
  312. return -EINVAL;
  313. }
  314. fl->fl_start = start; /* we record the absolute position */
  315. if (fl->fl_end < fl->fl_start)
  316. return -EOVERFLOW;
  317. fl->fl_owner = current->files;
  318. fl->fl_pid = current->tgid;
  319. fl->fl_file = filp;
  320. fl->fl_flags = FL_POSIX;
  321. fl->fl_ops = NULL;
  322. fl->fl_lmops = NULL;
  323. return assign_type(fl, l->l_type);
  324. }
  325. #if BITS_PER_LONG == 32
  326. static int flock64_to_posix_lock(struct file *filp, struct file_lock *fl,
  327. struct flock64 *l)
  328. {
  329. loff_t start;
  330. switch (l->l_whence) {
  331. case SEEK_SET:
  332. start = 0;
  333. break;
  334. case SEEK_CUR:
  335. start = filp->f_pos;
  336. break;
  337. case SEEK_END:
  338. start = i_size_read(filp->f_path.dentry->d_inode);
  339. break;
  340. default:
  341. return -EINVAL;
  342. }
  343. start += l->l_start;
  344. if (start < 0)
  345. return -EINVAL;
  346. fl->fl_end = OFFSET_MAX;
  347. if (l->l_len > 0) {
  348. fl->fl_end = start + l->l_len - 1;
  349. } else if (l->l_len < 0) {
  350. fl->fl_end = start - 1;
  351. start += l->l_len;
  352. if (start < 0)
  353. return -EINVAL;
  354. }
  355. fl->fl_start = start; /* we record the absolute position */
  356. if (fl->fl_end < fl->fl_start)
  357. return -EOVERFLOW;
  358. fl->fl_owner = current->files;
  359. fl->fl_pid = current->tgid;
  360. fl->fl_file = filp;
  361. fl->fl_flags = FL_POSIX;
  362. fl->fl_ops = NULL;
  363. fl->fl_lmops = NULL;
  364. switch (l->l_type) {
  365. case F_RDLCK:
  366. case F_WRLCK:
  367. case F_UNLCK:
  368. fl->fl_type = l->l_type;
  369. break;
  370. default:
  371. return -EINVAL;
  372. }
  373. return (0);
  374. }
  375. #endif
  376. /* default lease lock manager operations */
  377. static void lease_break_callback(struct file_lock *fl)
  378. {
  379. kill_fasync(&fl->fl_fasync, SIGIO, POLL_MSG);
  380. }
  381. static void lease_release_private_callback(struct file_lock *fl)
  382. {
  383. if (!fl->fl_file)
  384. return;
  385. f_delown(fl->fl_file);
  386. fl->fl_file->f_owner.signum = 0;
  387. }
  388. static int lease_mylease_callback(struct file_lock *fl, struct file_lock *try)
  389. {
  390. return fl->fl_file == try->fl_file;
  391. }
  392. static struct lock_manager_operations lease_manager_ops = {
  393. .fl_break = lease_break_callback,
  394. .fl_release_private = lease_release_private_callback,
  395. .fl_mylease = lease_mylease_callback,
  396. .fl_change = lease_modify,
  397. };
  398. /*
  399. * Initialize a lease, use the default lock manager operations
  400. */
  401. static int lease_init(struct file *filp, int type, struct file_lock *fl)
  402. {
  403. if (assign_type(fl, type) != 0)
  404. return -EINVAL;
  405. fl->fl_owner = current->files;
  406. fl->fl_pid = current->tgid;
  407. fl->fl_file = filp;
  408. fl->fl_flags = FL_LEASE;
  409. fl->fl_start = 0;
  410. fl->fl_end = OFFSET_MAX;
  411. fl->fl_ops = NULL;
  412. fl->fl_lmops = &lease_manager_ops;
  413. return 0;
  414. }
  415. /* Allocate a file_lock initialised to this type of lease */
  416. static int lease_alloc(struct file *filp, int type, struct file_lock **flp)
  417. {
  418. struct file_lock *fl = locks_alloc_lock();
  419. int error = -ENOMEM;
  420. if (fl == NULL)
  421. goto out;
  422. error = lease_init(filp, type, fl);
  423. if (error) {
  424. locks_free_lock(fl);
  425. fl = NULL;
  426. }
  427. out:
  428. *flp = fl;
  429. return error;
  430. }
  431. /* Check if two locks overlap each other.
  432. */
  433. static inline int locks_overlap(struct file_lock *fl1, struct file_lock *fl2)
  434. {
  435. return ((fl1->fl_end >= fl2->fl_start) &&
  436. (fl2->fl_end >= fl1->fl_start));
  437. }
  438. /*
  439. * Check whether two locks have the same owner.
  440. */
  441. static int posix_same_owner(struct file_lock *fl1, struct file_lock *fl2)
  442. {
  443. if (fl1->fl_lmops && fl1->fl_lmops->fl_compare_owner)
  444. return fl2->fl_lmops == fl1->fl_lmops &&
  445. fl1->fl_lmops->fl_compare_owner(fl1, fl2);
  446. return fl1->fl_owner == fl2->fl_owner;
  447. }
  448. /* Remove waiter from blocker's block list.
  449. * When blocker ends up pointing to itself then the list is empty.
  450. */
  451. static void __locks_delete_block(struct file_lock *waiter)
  452. {
  453. list_del_init(&waiter->fl_block);
  454. list_del_init(&waiter->fl_link);
  455. waiter->fl_next = NULL;
  456. }
  457. /*
  458. */
  459. static void locks_delete_block(struct file_lock *waiter)
  460. {
  461. lock_kernel();
  462. __locks_delete_block(waiter);
  463. unlock_kernel();
  464. }
  465. /* Insert waiter into blocker's block list.
  466. * We use a circular list so that processes can be easily woken up in
  467. * the order they blocked. The documentation doesn't require this but
  468. * it seems like the reasonable thing to do.
  469. */
  470. static void locks_insert_block(struct file_lock *blocker,
  471. struct file_lock *waiter)
  472. {
  473. BUG_ON(!list_empty(&waiter->fl_block));
  474. list_add_tail(&waiter->fl_block, &blocker->fl_block);
  475. waiter->fl_next = blocker;
  476. if (IS_POSIX(blocker))
  477. list_add(&waiter->fl_link, &blocked_list);
  478. }
  479. /* Wake up processes blocked waiting for blocker.
  480. * If told to wait then schedule the processes until the block list
  481. * is empty, otherwise empty the block list ourselves.
  482. */
  483. static void locks_wake_up_blocks(struct file_lock *blocker)
  484. {
  485. while (!list_empty(&blocker->fl_block)) {
  486. struct file_lock *waiter = list_entry(blocker->fl_block.next,
  487. struct file_lock, fl_block);
  488. __locks_delete_block(waiter);
  489. if (waiter->fl_lmops && waiter->fl_lmops->fl_notify)
  490. waiter->fl_lmops->fl_notify(waiter);
  491. else
  492. wake_up(&waiter->fl_wait);
  493. }
  494. }
  495. /* Insert file lock fl into an inode's lock list at the position indicated
  496. * by pos. At the same time add the lock to the global file lock list.
  497. */
  498. static void locks_insert_lock(struct file_lock **pos, struct file_lock *fl)
  499. {
  500. list_add(&fl->fl_link, &file_lock_list);
  501. /* insert into file's list */
  502. fl->fl_next = *pos;
  503. *pos = fl;
  504. if (fl->fl_ops && fl->fl_ops->fl_insert)
  505. fl->fl_ops->fl_insert(fl);
  506. }
  507. /*
  508. * Delete a lock and then free it.
  509. * Wake up processes that are blocked waiting for this lock,
  510. * notify the FS that the lock has been cleared and
  511. * finally free the lock.
  512. */
  513. static void locks_delete_lock(struct file_lock **thisfl_p)
  514. {
  515. struct file_lock *fl = *thisfl_p;
  516. *thisfl_p = fl->fl_next;
  517. fl->fl_next = NULL;
  518. list_del_init(&fl->fl_link);
  519. fasync_helper(0, fl->fl_file, 0, &fl->fl_fasync);
  520. if (fl->fl_fasync != NULL) {
  521. printk(KERN_ERR "locks_delete_lock: fasync == %p\n", fl->fl_fasync);
  522. fl->fl_fasync = NULL;
  523. }
  524. if (fl->fl_ops && fl->fl_ops->fl_remove)
  525. fl->fl_ops->fl_remove(fl);
  526. locks_wake_up_blocks(fl);
  527. locks_free_lock(fl);
  528. }
  529. /* Determine if lock sys_fl blocks lock caller_fl. Common functionality
  530. * checks for shared/exclusive status of overlapping locks.
  531. */
  532. static int locks_conflict(struct file_lock *caller_fl, struct file_lock *sys_fl)
  533. {
  534. if (sys_fl->fl_type == F_WRLCK)
  535. return 1;
  536. if (caller_fl->fl_type == F_WRLCK)
  537. return 1;
  538. return 0;
  539. }
  540. /* Determine if lock sys_fl blocks lock caller_fl. POSIX specific
  541. * checking before calling the locks_conflict().
  542. */
  543. static int posix_locks_conflict(struct file_lock *caller_fl, struct file_lock *sys_fl)
  544. {
  545. /* POSIX locks owned by the same process do not conflict with
  546. * each other.
  547. */
  548. if (!IS_POSIX(sys_fl) || posix_same_owner(caller_fl, sys_fl))
  549. return (0);
  550. /* Check whether they overlap */
  551. if (!locks_overlap(caller_fl, sys_fl))
  552. return 0;
  553. return (locks_conflict(caller_fl, sys_fl));
  554. }
  555. /* Determine if lock sys_fl blocks lock caller_fl. FLOCK specific
  556. * checking before calling the locks_conflict().
  557. */
  558. static int flock_locks_conflict(struct file_lock *caller_fl, struct file_lock *sys_fl)
  559. {
  560. /* FLOCK locks referring to the same filp do not conflict with
  561. * each other.
  562. */
  563. if (!IS_FLOCK(sys_fl) || (caller_fl->fl_file == sys_fl->fl_file))
  564. return (0);
  565. if ((caller_fl->fl_type & LOCK_MAND) || (sys_fl->fl_type & LOCK_MAND))
  566. return 0;
  567. return (locks_conflict(caller_fl, sys_fl));
  568. }
  569. static int interruptible_sleep_on_locked(wait_queue_head_t *fl_wait, int timeout)
  570. {
  571. int result = 0;
  572. DECLARE_WAITQUEUE(wait, current);
  573. __set_current_state(TASK_INTERRUPTIBLE);
  574. add_wait_queue(fl_wait, &wait);
  575. if (timeout == 0)
  576. schedule();
  577. else
  578. result = schedule_timeout(timeout);
  579. if (signal_pending(current))
  580. result = -ERESTARTSYS;
  581. remove_wait_queue(fl_wait, &wait);
  582. __set_current_state(TASK_RUNNING);
  583. return result;
  584. }
  585. static int locks_block_on_timeout(struct file_lock *blocker, struct file_lock *waiter, int time)
  586. {
  587. int result;
  588. locks_insert_block(blocker, waiter);
  589. result = interruptible_sleep_on_locked(&waiter->fl_wait, time);
  590. __locks_delete_block(waiter);
  591. return result;
  592. }
  593. int
  594. posix_test_lock(struct file *filp, struct file_lock *fl,
  595. struct file_lock *conflock)
  596. {
  597. struct file_lock *cfl;
  598. lock_kernel();
  599. for (cfl = filp->f_path.dentry->d_inode->i_flock; cfl; cfl = cfl->fl_next) {
  600. if (!IS_POSIX(cfl))
  601. continue;
  602. if (posix_locks_conflict(cfl, fl))
  603. break;
  604. }
  605. if (cfl) {
  606. __locks_copy_lock(conflock, cfl);
  607. unlock_kernel();
  608. return 1;
  609. }
  610. unlock_kernel();
  611. return 0;
  612. }
  613. EXPORT_SYMBOL(posix_test_lock);
  614. /* This function tests for deadlock condition before putting a process to
  615. * sleep. The detection scheme is no longer recursive. Recursive was neat,
  616. * but dangerous - we risked stack corruption if the lock data was bad, or
  617. * if the recursion was too deep for any other reason.
  618. *
  619. * We rely on the fact that a task can only be on one lock's wait queue
  620. * at a time. When we find blocked_task on a wait queue we can re-search
  621. * with blocked_task equal to that queue's owner, until either blocked_task
  622. * isn't found, or blocked_task is found on a queue owned by my_task.
  623. *
  624. * Note: the above assumption may not be true when handling lock requests
  625. * from a broken NFS client. But broken NFS clients have a lot more to
  626. * worry about than proper deadlock detection anyway... --okir
  627. */
  628. static int posix_locks_deadlock(struct file_lock *caller_fl,
  629. struct file_lock *block_fl)
  630. {
  631. struct list_head *tmp;
  632. next_task:
  633. if (posix_same_owner(caller_fl, block_fl))
  634. return 1;
  635. list_for_each(tmp, &blocked_list) {
  636. struct file_lock *fl = list_entry(tmp, struct file_lock, fl_link);
  637. if (posix_same_owner(fl, block_fl)) {
  638. fl = fl->fl_next;
  639. block_fl = fl;
  640. goto next_task;
  641. }
  642. }
  643. return 0;
  644. }
  645. /* Try to create a FLOCK lock on filp. We always insert new FLOCK locks
  646. * at the head of the list, but that's secret knowledge known only to
  647. * flock_lock_file and posix_lock_file.
  648. *
  649. * Note that if called with an FL_EXISTS argument, the caller may determine
  650. * whether or not a lock was successfully freed by testing the return
  651. * value for -ENOENT.
  652. */
  653. static int flock_lock_file(struct file *filp, struct file_lock *request)
  654. {
  655. struct file_lock *new_fl = NULL;
  656. struct file_lock **before;
  657. struct inode * inode = filp->f_path.dentry->d_inode;
  658. int error = 0;
  659. int found = 0;
  660. lock_kernel();
  661. if (request->fl_flags & FL_ACCESS)
  662. goto find_conflict;
  663. for_each_lock(inode, before) {
  664. struct file_lock *fl = *before;
  665. if (IS_POSIX(fl))
  666. break;
  667. if (IS_LEASE(fl))
  668. continue;
  669. if (filp != fl->fl_file)
  670. continue;
  671. if (request->fl_type == fl->fl_type)
  672. goto out;
  673. found = 1;
  674. locks_delete_lock(before);
  675. break;
  676. }
  677. if (request->fl_type == F_UNLCK) {
  678. if ((request->fl_flags & FL_EXISTS) && !found)
  679. error = -ENOENT;
  680. goto out;
  681. }
  682. error = -ENOMEM;
  683. new_fl = locks_alloc_lock();
  684. if (new_fl == NULL)
  685. goto out;
  686. /*
  687. * If a higher-priority process was blocked on the old file lock,
  688. * give it the opportunity to lock the file.
  689. */
  690. if (found)
  691. cond_resched();
  692. find_conflict:
  693. for_each_lock(inode, before) {
  694. struct file_lock *fl = *before;
  695. if (IS_POSIX(fl))
  696. break;
  697. if (IS_LEASE(fl))
  698. continue;
  699. if (!flock_locks_conflict(request, fl))
  700. continue;
  701. error = -EAGAIN;
  702. if (request->fl_flags & FL_SLEEP)
  703. locks_insert_block(fl, request);
  704. goto out;
  705. }
  706. if (request->fl_flags & FL_ACCESS)
  707. goto out;
  708. locks_copy_lock(new_fl, request);
  709. locks_insert_lock(&inode->i_flock, new_fl);
  710. new_fl = NULL;
  711. error = 0;
  712. out:
  713. unlock_kernel();
  714. if (new_fl)
  715. locks_free_lock(new_fl);
  716. return error;
  717. }
  718. static int __posix_lock_file_conf(struct inode *inode, struct file_lock *request, struct file_lock *conflock)
  719. {
  720. struct file_lock *fl;
  721. struct file_lock *new_fl = NULL;
  722. struct file_lock *new_fl2 = NULL;
  723. struct file_lock *left = NULL;
  724. struct file_lock *right = NULL;
  725. struct file_lock **before;
  726. int error, added = 0;
  727. /*
  728. * We may need two file_lock structures for this operation,
  729. * so we get them in advance to avoid races.
  730. *
  731. * In some cases we can be sure, that no new locks will be needed
  732. */
  733. if (!(request->fl_flags & FL_ACCESS) &&
  734. (request->fl_type != F_UNLCK ||
  735. request->fl_start != 0 || request->fl_end != OFFSET_MAX)) {
  736. new_fl = locks_alloc_lock();
  737. new_fl2 = locks_alloc_lock();
  738. }
  739. lock_kernel();
  740. if (request->fl_type != F_UNLCK) {
  741. for_each_lock(inode, before) {
  742. struct file_lock *fl = *before;
  743. if (!IS_POSIX(fl))
  744. continue;
  745. if (!posix_locks_conflict(request, fl))
  746. continue;
  747. if (conflock)
  748. locks_copy_lock(conflock, fl);
  749. error = -EAGAIN;
  750. if (!(request->fl_flags & FL_SLEEP))
  751. goto out;
  752. error = -EDEADLK;
  753. if (posix_locks_deadlock(request, fl))
  754. goto out;
  755. error = -EAGAIN;
  756. locks_insert_block(fl, request);
  757. goto out;
  758. }
  759. }
  760. /* If we're just looking for a conflict, we're done. */
  761. error = 0;
  762. if (request->fl_flags & FL_ACCESS)
  763. goto out;
  764. /*
  765. * Find the first old lock with the same owner as the new lock.
  766. */
  767. before = &inode->i_flock;
  768. /* First skip locks owned by other processes. */
  769. while ((fl = *before) && (!IS_POSIX(fl) ||
  770. !posix_same_owner(request, fl))) {
  771. before = &fl->fl_next;
  772. }
  773. /* Process locks with this owner. */
  774. while ((fl = *before) && posix_same_owner(request, fl)) {
  775. /* Detect adjacent or overlapping regions (if same lock type)
  776. */
  777. if (request->fl_type == fl->fl_type) {
  778. /* In all comparisons of start vs end, use
  779. * "start - 1" rather than "end + 1". If end
  780. * is OFFSET_MAX, end + 1 will become negative.
  781. */
  782. if (fl->fl_end < request->fl_start - 1)
  783. goto next_lock;
  784. /* If the next lock in the list has entirely bigger
  785. * addresses than the new one, insert the lock here.
  786. */
  787. if (fl->fl_start - 1 > request->fl_end)
  788. break;
  789. /* If we come here, the new and old lock are of the
  790. * same type and adjacent or overlapping. Make one
  791. * lock yielding from the lower start address of both
  792. * locks to the higher end address.
  793. */
  794. if (fl->fl_start > request->fl_start)
  795. fl->fl_start = request->fl_start;
  796. else
  797. request->fl_start = fl->fl_start;
  798. if (fl->fl_end < request->fl_end)
  799. fl->fl_end = request->fl_end;
  800. else
  801. request->fl_end = fl->fl_end;
  802. if (added) {
  803. locks_delete_lock(before);
  804. continue;
  805. }
  806. request = fl;
  807. added = 1;
  808. }
  809. else {
  810. /* Processing for different lock types is a bit
  811. * more complex.
  812. */
  813. if (fl->fl_end < request->fl_start)
  814. goto next_lock;
  815. if (fl->fl_start > request->fl_end)
  816. break;
  817. if (request->fl_type == F_UNLCK)
  818. added = 1;
  819. if (fl->fl_start < request->fl_start)
  820. left = fl;
  821. /* If the next lock in the list has a higher end
  822. * address than the new one, insert the new one here.
  823. */
  824. if (fl->fl_end > request->fl_end) {
  825. right = fl;
  826. break;
  827. }
  828. if (fl->fl_start >= request->fl_start) {
  829. /* The new lock completely replaces an old
  830. * one (This may happen several times).
  831. */
  832. if (added) {
  833. locks_delete_lock(before);
  834. continue;
  835. }
  836. /* Replace the old lock with the new one.
  837. * Wake up anybody waiting for the old one,
  838. * as the change in lock type might satisfy
  839. * their needs.
  840. */
  841. locks_wake_up_blocks(fl);
  842. fl->fl_start = request->fl_start;
  843. fl->fl_end = request->fl_end;
  844. fl->fl_type = request->fl_type;
  845. locks_release_private(fl);
  846. locks_copy_private(fl, request);
  847. request = fl;
  848. added = 1;
  849. }
  850. }
  851. /* Go on to next lock.
  852. */
  853. next_lock:
  854. before = &fl->fl_next;
  855. }
  856. /*
  857. * The above code only modifies existing locks in case of
  858. * merging or replacing. If new lock(s) need to be inserted
  859. * all modifications are done bellow this, so it's safe yet to
  860. * bail out.
  861. */
  862. error = -ENOLCK; /* "no luck" */
  863. if (right && left == right && !new_fl2)
  864. goto out;
  865. error = 0;
  866. if (!added) {
  867. if (request->fl_type == F_UNLCK) {
  868. if (request->fl_flags & FL_EXISTS)
  869. error = -ENOENT;
  870. goto out;
  871. }
  872. if (!new_fl) {
  873. error = -ENOLCK;
  874. goto out;
  875. }
  876. locks_copy_lock(new_fl, request);
  877. locks_insert_lock(before, new_fl);
  878. new_fl = NULL;
  879. }
  880. if (right) {
  881. if (left == right) {
  882. /* The new lock breaks the old one in two pieces,
  883. * so we have to use the second new lock.
  884. */
  885. left = new_fl2;
  886. new_fl2 = NULL;
  887. locks_copy_lock(left, right);
  888. locks_insert_lock(before, left);
  889. }
  890. right->fl_start = request->fl_end + 1;
  891. locks_wake_up_blocks(right);
  892. }
  893. if (left) {
  894. left->fl_end = request->fl_start - 1;
  895. locks_wake_up_blocks(left);
  896. }
  897. out:
  898. unlock_kernel();
  899. /*
  900. * Free any unused locks.
  901. */
  902. if (new_fl)
  903. locks_free_lock(new_fl);
  904. if (new_fl2)
  905. locks_free_lock(new_fl2);
  906. return error;
  907. }
  908. /**
  909. * posix_lock_file - Apply a POSIX-style lock to a file
  910. * @filp: The file to apply the lock to
  911. * @fl: The lock to be applied
  912. *
  913. * Add a POSIX style lock to a file.
  914. * We merge adjacent & overlapping locks whenever possible.
  915. * POSIX locks are sorted by owner task, then by starting address
  916. *
  917. * Note that if called with an FL_EXISTS argument, the caller may determine
  918. * whether or not a lock was successfully freed by testing the return
  919. * value for -ENOENT.
  920. */
  921. int posix_lock_file(struct file *filp, struct file_lock *fl)
  922. {
  923. return __posix_lock_file_conf(filp->f_path.dentry->d_inode, fl, NULL);
  924. }
  925. EXPORT_SYMBOL(posix_lock_file);
  926. /**
  927. * posix_lock_file_conf - Apply a POSIX-style lock to a file
  928. * @filp: The file to apply the lock to
  929. * @fl: The lock to be applied
  930. * @conflock: Place to return a copy of the conflicting lock, if found.
  931. *
  932. * Except for the conflock parameter, acts just like posix_lock_file.
  933. */
  934. int posix_lock_file_conf(struct file *filp, struct file_lock *fl,
  935. struct file_lock *conflock)
  936. {
  937. return __posix_lock_file_conf(filp->f_path.dentry->d_inode, fl, conflock);
  938. }
  939. EXPORT_SYMBOL(posix_lock_file_conf);
  940. /**
  941. * posix_lock_file_wait - Apply a POSIX-style lock to a file
  942. * @filp: The file to apply the lock to
  943. * @fl: The lock to be applied
  944. *
  945. * Add a POSIX style lock to a file.
  946. * We merge adjacent & overlapping locks whenever possible.
  947. * POSIX locks are sorted by owner task, then by starting address
  948. */
  949. int posix_lock_file_wait(struct file *filp, struct file_lock *fl)
  950. {
  951. int error;
  952. might_sleep ();
  953. for (;;) {
  954. error = posix_lock_file(filp, fl);
  955. if ((error != -EAGAIN) || !(fl->fl_flags & FL_SLEEP))
  956. break;
  957. error = wait_event_interruptible(fl->fl_wait, !fl->fl_next);
  958. if (!error)
  959. continue;
  960. locks_delete_block(fl);
  961. break;
  962. }
  963. return error;
  964. }
  965. EXPORT_SYMBOL(posix_lock_file_wait);
  966. /**
  967. * locks_mandatory_locked - Check for an active lock
  968. * @inode: the file to check
  969. *
  970. * Searches the inode's list of locks to find any POSIX locks which conflict.
  971. * This function is called from locks_verify_locked() only.
  972. */
  973. int locks_mandatory_locked(struct inode *inode)
  974. {
  975. fl_owner_t owner = current->files;
  976. struct file_lock *fl;
  977. /*
  978. * Search the lock list for this inode for any POSIX locks.
  979. */
  980. lock_kernel();
  981. for (fl = inode->i_flock; fl != NULL; fl = fl->fl_next) {
  982. if (!IS_POSIX(fl))
  983. continue;
  984. if (fl->fl_owner != owner)
  985. break;
  986. }
  987. unlock_kernel();
  988. return fl ? -EAGAIN : 0;
  989. }
  990. /**
  991. * locks_mandatory_area - Check for a conflicting lock
  992. * @read_write: %FLOCK_VERIFY_WRITE for exclusive access, %FLOCK_VERIFY_READ
  993. * for shared
  994. * @inode: the file to check
  995. * @filp: how the file was opened (if it was)
  996. * @offset: start of area to check
  997. * @count: length of area to check
  998. *
  999. * Searches the inode's list of locks to find any POSIX locks which conflict.
  1000. * This function is called from rw_verify_area() and
  1001. * locks_verify_truncate().
  1002. */
  1003. int locks_mandatory_area(int read_write, struct inode *inode,
  1004. struct file *filp, loff_t offset,
  1005. size_t count)
  1006. {
  1007. struct file_lock fl;
  1008. int error;
  1009. locks_init_lock(&fl);
  1010. fl.fl_owner = current->files;
  1011. fl.fl_pid = current->tgid;
  1012. fl.fl_file = filp;
  1013. fl.fl_flags = FL_POSIX | FL_ACCESS;
  1014. if (filp && !(filp->f_flags & O_NONBLOCK))
  1015. fl.fl_flags |= FL_SLEEP;
  1016. fl.fl_type = (read_write == FLOCK_VERIFY_WRITE) ? F_WRLCK : F_RDLCK;
  1017. fl.fl_start = offset;
  1018. fl.fl_end = offset + count - 1;
  1019. for (;;) {
  1020. error = __posix_lock_file_conf(inode, &fl, NULL);
  1021. if (error != -EAGAIN)
  1022. break;
  1023. if (!(fl.fl_flags & FL_SLEEP))
  1024. break;
  1025. error = wait_event_interruptible(fl.fl_wait, !fl.fl_next);
  1026. if (!error) {
  1027. /*
  1028. * If we've been sleeping someone might have
  1029. * changed the permissions behind our back.
  1030. */
  1031. if ((inode->i_mode & (S_ISGID | S_IXGRP)) == S_ISGID)
  1032. continue;
  1033. }
  1034. locks_delete_block(&fl);
  1035. break;
  1036. }
  1037. return error;
  1038. }
  1039. EXPORT_SYMBOL(locks_mandatory_area);
  1040. /* We already had a lease on this file; just change its type */
  1041. int lease_modify(struct file_lock **before, int arg)
  1042. {
  1043. struct file_lock *fl = *before;
  1044. int error = assign_type(fl, arg);
  1045. if (error)
  1046. return error;
  1047. locks_wake_up_blocks(fl);
  1048. if (arg == F_UNLCK)
  1049. locks_delete_lock(before);
  1050. return 0;
  1051. }
  1052. EXPORT_SYMBOL(lease_modify);
  1053. static void time_out_leases(struct inode *inode)
  1054. {
  1055. struct file_lock **before;
  1056. struct file_lock *fl;
  1057. before = &inode->i_flock;
  1058. while ((fl = *before) && IS_LEASE(fl) && (fl->fl_type & F_INPROGRESS)) {
  1059. if ((fl->fl_break_time == 0)
  1060. || time_before(jiffies, fl->fl_break_time)) {
  1061. before = &fl->fl_next;
  1062. continue;
  1063. }
  1064. lease_modify(before, fl->fl_type & ~F_INPROGRESS);
  1065. if (fl == *before) /* lease_modify may have freed fl */
  1066. before = &fl->fl_next;
  1067. }
  1068. }
  1069. /**
  1070. * __break_lease - revoke all outstanding leases on file
  1071. * @inode: the inode of the file to return
  1072. * @mode: the open mode (read or write)
  1073. *
  1074. * break_lease (inlined for speed) has checked there already
  1075. * is a lease on this file. Leases are broken on a call to open()
  1076. * or truncate(). This function can sleep unless you
  1077. * specified %O_NONBLOCK to your open().
  1078. */
  1079. int __break_lease(struct inode *inode, unsigned int mode)
  1080. {
  1081. int error = 0, future;
  1082. struct file_lock *new_fl, *flock;
  1083. struct file_lock *fl;
  1084. int alloc_err;
  1085. unsigned long break_time;
  1086. int i_have_this_lease = 0;
  1087. alloc_err = lease_alloc(NULL, mode & FMODE_WRITE ? F_WRLCK : F_RDLCK,
  1088. &new_fl);
  1089. lock_kernel();
  1090. time_out_leases(inode);
  1091. flock = inode->i_flock;
  1092. if ((flock == NULL) || !IS_LEASE(flock))
  1093. goto out;
  1094. for (fl = flock; fl && IS_LEASE(fl); fl = fl->fl_next)
  1095. if (fl->fl_owner == current->files)
  1096. i_have_this_lease = 1;
  1097. if (mode & FMODE_WRITE) {
  1098. /* If we want write access, we have to revoke any lease. */
  1099. future = F_UNLCK | F_INPROGRESS;
  1100. } else if (flock->fl_type & F_INPROGRESS) {
  1101. /* If the lease is already being broken, we just leave it */
  1102. future = flock->fl_type;
  1103. } else if (flock->fl_type & F_WRLCK) {
  1104. /* Downgrade the exclusive lease to a read-only lease. */
  1105. future = F_RDLCK | F_INPROGRESS;
  1106. } else {
  1107. /* the existing lease was read-only, so we can read too. */
  1108. goto out;
  1109. }
  1110. if (alloc_err && !i_have_this_lease && ((mode & O_NONBLOCK) == 0)) {
  1111. error = alloc_err;
  1112. goto out;
  1113. }
  1114. break_time = 0;
  1115. if (lease_break_time > 0) {
  1116. break_time = jiffies + lease_break_time * HZ;
  1117. if (break_time == 0)
  1118. break_time++; /* so that 0 means no break time */
  1119. }
  1120. for (fl = flock; fl && IS_LEASE(fl); fl = fl->fl_next) {
  1121. if (fl->fl_type != future) {
  1122. fl->fl_type = future;
  1123. fl->fl_break_time = break_time;
  1124. /* lease must have lmops break callback */
  1125. fl->fl_lmops->fl_break(fl);
  1126. }
  1127. }
  1128. if (i_have_this_lease || (mode & O_NONBLOCK)) {
  1129. error = -EWOULDBLOCK;
  1130. goto out;
  1131. }
  1132. restart:
  1133. break_time = flock->fl_break_time;
  1134. if (break_time != 0) {
  1135. break_time -= jiffies;
  1136. if (break_time == 0)
  1137. break_time++;
  1138. }
  1139. error = locks_block_on_timeout(flock, new_fl, break_time);
  1140. if (error >= 0) {
  1141. if (error == 0)
  1142. time_out_leases(inode);
  1143. /* Wait for the next lease that has not been broken yet */
  1144. for (flock = inode->i_flock; flock && IS_LEASE(flock);
  1145. flock = flock->fl_next) {
  1146. if (flock->fl_type & F_INPROGRESS)
  1147. goto restart;
  1148. }
  1149. error = 0;
  1150. }
  1151. out:
  1152. unlock_kernel();
  1153. if (!alloc_err)
  1154. locks_free_lock(new_fl);
  1155. return error;
  1156. }
  1157. EXPORT_SYMBOL(__break_lease);
  1158. /**
  1159. * lease_get_mtime
  1160. * @inode: the inode
  1161. * @time: pointer to a timespec which will contain the last modified time
  1162. *
  1163. * This is to force NFS clients to flush their caches for files with
  1164. * exclusive leases. The justification is that if someone has an
  1165. * exclusive lease, then they could be modifiying it.
  1166. */
  1167. void lease_get_mtime(struct inode *inode, struct timespec *time)
  1168. {
  1169. struct file_lock *flock = inode->i_flock;
  1170. if (flock && IS_LEASE(flock) && (flock->fl_type & F_WRLCK))
  1171. *time = current_fs_time(inode->i_sb);
  1172. else
  1173. *time = inode->i_mtime;
  1174. }
  1175. EXPORT_SYMBOL(lease_get_mtime);
  1176. /**
  1177. * fcntl_getlease - Enquire what lease is currently active
  1178. * @filp: the file
  1179. *
  1180. * The value returned by this function will be one of
  1181. * (if no lease break is pending):
  1182. *
  1183. * %F_RDLCK to indicate a shared lease is held.
  1184. *
  1185. * %F_WRLCK to indicate an exclusive lease is held.
  1186. *
  1187. * %F_UNLCK to indicate no lease is held.
  1188. *
  1189. * (if a lease break is pending):
  1190. *
  1191. * %F_RDLCK to indicate an exclusive lease needs to be
  1192. * changed to a shared lease (or removed).
  1193. *
  1194. * %F_UNLCK to indicate the lease needs to be removed.
  1195. *
  1196. * XXX: sfr & willy disagree over whether F_INPROGRESS
  1197. * should be returned to userspace.
  1198. */
  1199. int fcntl_getlease(struct file *filp)
  1200. {
  1201. struct file_lock *fl;
  1202. int type = F_UNLCK;
  1203. lock_kernel();
  1204. time_out_leases(filp->f_path.dentry->d_inode);
  1205. for (fl = filp->f_path.dentry->d_inode->i_flock; fl && IS_LEASE(fl);
  1206. fl = fl->fl_next) {
  1207. if (fl->fl_file == filp) {
  1208. type = fl->fl_type & ~F_INPROGRESS;
  1209. break;
  1210. }
  1211. }
  1212. unlock_kernel();
  1213. return type;
  1214. }
  1215. /**
  1216. * __setlease - sets a lease on an open file
  1217. * @filp: file pointer
  1218. * @arg: type of lease to obtain
  1219. * @flp: input - file_lock to use, output - file_lock inserted
  1220. *
  1221. * The (input) flp->fl_lmops->fl_break function is required
  1222. * by break_lease().
  1223. *
  1224. * Called with kernel lock held.
  1225. */
  1226. static int __setlease(struct file *filp, long arg, struct file_lock **flp)
  1227. {
  1228. struct file_lock *fl, **before, **my_before = NULL, *lease;
  1229. struct dentry *dentry = filp->f_path.dentry;
  1230. struct inode *inode = dentry->d_inode;
  1231. int error, rdlease_count = 0, wrlease_count = 0;
  1232. time_out_leases(inode);
  1233. error = -EINVAL;
  1234. if (!flp || !(*flp) || !(*flp)->fl_lmops || !(*flp)->fl_lmops->fl_break)
  1235. goto out;
  1236. lease = *flp;
  1237. error = -EAGAIN;
  1238. if ((arg == F_RDLCK) && (atomic_read(&inode->i_writecount) > 0))
  1239. goto out;
  1240. if ((arg == F_WRLCK)
  1241. && ((atomic_read(&dentry->d_count) > 1)
  1242. || (atomic_read(&inode->i_count) > 1)))
  1243. goto out;
  1244. /*
  1245. * At this point, we know that if there is an exclusive
  1246. * lease on this file, then we hold it on this filp
  1247. * (otherwise our open of this file would have blocked).
  1248. * And if we are trying to acquire an exclusive lease,
  1249. * then the file is not open by anyone (including us)
  1250. * except for this filp.
  1251. */
  1252. for (before = &inode->i_flock;
  1253. ((fl = *before) != NULL) && IS_LEASE(fl);
  1254. before = &fl->fl_next) {
  1255. if (lease->fl_lmops->fl_mylease(fl, lease))
  1256. my_before = before;
  1257. else if (fl->fl_type == (F_INPROGRESS | F_UNLCK))
  1258. /*
  1259. * Someone is in the process of opening this
  1260. * file for writing so we may not take an
  1261. * exclusive lease on it.
  1262. */
  1263. wrlease_count++;
  1264. else
  1265. rdlease_count++;
  1266. }
  1267. if ((arg == F_RDLCK && (wrlease_count > 0)) ||
  1268. (arg == F_WRLCK && ((rdlease_count + wrlease_count) > 0)))
  1269. goto out;
  1270. if (my_before != NULL) {
  1271. *flp = *my_before;
  1272. error = lease->fl_lmops->fl_change(my_before, arg);
  1273. goto out;
  1274. }
  1275. error = 0;
  1276. if (arg == F_UNLCK)
  1277. goto out;
  1278. error = -EINVAL;
  1279. if (!leases_enable)
  1280. goto out;
  1281. error = -ENOMEM;
  1282. fl = locks_alloc_lock();
  1283. if (fl == NULL)
  1284. goto out;
  1285. locks_copy_lock(fl, lease);
  1286. locks_insert_lock(before, fl);
  1287. *flp = fl;
  1288. error = 0;
  1289. out:
  1290. return error;
  1291. }
  1292. /**
  1293. * setlease - sets a lease on an open file
  1294. * @filp: file pointer
  1295. * @arg: type of lease to obtain
  1296. * @lease: file_lock to use
  1297. *
  1298. * Call this to establish a lease on the file.
  1299. * The fl_lmops fl_break function is required by break_lease
  1300. */
  1301. int setlease(struct file *filp, long arg, struct file_lock **lease)
  1302. {
  1303. struct dentry *dentry = filp->f_path.dentry;
  1304. struct inode *inode = dentry->d_inode;
  1305. int error;
  1306. if ((current->fsuid != inode->i_uid) && !capable(CAP_LEASE))
  1307. return -EACCES;
  1308. if (!S_ISREG(inode->i_mode))
  1309. return -EINVAL;
  1310. error = security_file_lock(filp, arg);
  1311. if (error)
  1312. return error;
  1313. lock_kernel();
  1314. error = __setlease(filp, arg, lease);
  1315. unlock_kernel();
  1316. return error;
  1317. }
  1318. EXPORT_SYMBOL(setlease);
  1319. /**
  1320. * fcntl_setlease - sets a lease on an open file
  1321. * @fd: open file descriptor
  1322. * @filp: file pointer
  1323. * @arg: type of lease to obtain
  1324. *
  1325. * Call this fcntl to establish a lease on the file.
  1326. * Note that you also need to call %F_SETSIG to
  1327. * receive a signal when the lease is broken.
  1328. */
  1329. int fcntl_setlease(unsigned int fd, struct file *filp, long arg)
  1330. {
  1331. struct file_lock fl, *flp = &fl;
  1332. struct dentry *dentry = filp->f_path.dentry;
  1333. struct inode *inode = dentry->d_inode;
  1334. int error;
  1335. if ((current->fsuid != inode->i_uid) && !capable(CAP_LEASE))
  1336. return -EACCES;
  1337. if (!S_ISREG(inode->i_mode))
  1338. return -EINVAL;
  1339. error = security_file_lock(filp, arg);
  1340. if (error)
  1341. return error;
  1342. locks_init_lock(&fl);
  1343. error = lease_init(filp, arg, &fl);
  1344. if (error)
  1345. return error;
  1346. lock_kernel();
  1347. error = __setlease(filp, arg, &flp);
  1348. if (error || arg == F_UNLCK)
  1349. goto out_unlock;
  1350. error = fasync_helper(fd, filp, 1, &flp->fl_fasync);
  1351. if (error < 0) {
  1352. /* remove lease just inserted by __setlease */
  1353. flp->fl_type = F_UNLCK | F_INPROGRESS;
  1354. flp->fl_break_time = jiffies- 10;
  1355. time_out_leases(inode);
  1356. goto out_unlock;
  1357. }
  1358. error = __f_setown(filp, task_pid(current), PIDTYPE_PID, 0);
  1359. out_unlock:
  1360. unlock_kernel();
  1361. return error;
  1362. }
  1363. /**
  1364. * flock_lock_file_wait - Apply a FLOCK-style lock to a file
  1365. * @filp: The file to apply the lock to
  1366. * @fl: The lock to be applied
  1367. *
  1368. * Add a FLOCK style lock to a file.
  1369. */
  1370. int flock_lock_file_wait(struct file *filp, struct file_lock *fl)
  1371. {
  1372. int error;
  1373. might_sleep();
  1374. for (;;) {
  1375. error = flock_lock_file(filp, fl);
  1376. if ((error != -EAGAIN) || !(fl->fl_flags & FL_SLEEP))
  1377. break;
  1378. error = wait_event_interruptible(fl->fl_wait, !fl->fl_next);
  1379. if (!error)
  1380. continue;
  1381. locks_delete_block(fl);
  1382. break;
  1383. }
  1384. return error;
  1385. }
  1386. EXPORT_SYMBOL(flock_lock_file_wait);
  1387. /**
  1388. * sys_flock: - flock() system call.
  1389. * @fd: the file descriptor to lock.
  1390. * @cmd: the type of lock to apply.
  1391. *
  1392. * Apply a %FL_FLOCK style lock to an open file descriptor.
  1393. * The @cmd can be one of
  1394. *
  1395. * %LOCK_SH -- a shared lock.
  1396. *
  1397. * %LOCK_EX -- an exclusive lock.
  1398. *
  1399. * %LOCK_UN -- remove an existing lock.
  1400. *
  1401. * %LOCK_MAND -- a `mandatory' flock. This exists to emulate Windows Share Modes.
  1402. *
  1403. * %LOCK_MAND can be combined with %LOCK_READ or %LOCK_WRITE to allow other
  1404. * processes read and write access respectively.
  1405. */
  1406. asmlinkage long sys_flock(unsigned int fd, unsigned int cmd)
  1407. {
  1408. struct file *filp;
  1409. struct file_lock *lock;
  1410. int can_sleep, unlock;
  1411. int error;
  1412. error = -EBADF;
  1413. filp = fget(fd);
  1414. if (!filp)
  1415. goto out;
  1416. can_sleep = !(cmd & LOCK_NB);
  1417. cmd &= ~LOCK_NB;
  1418. unlock = (cmd == LOCK_UN);
  1419. if (!unlock && !(cmd & LOCK_MAND) && !(filp->f_mode & 3))
  1420. goto out_putf;
  1421. error = flock_make_lock(filp, &lock, cmd);
  1422. if (error)
  1423. goto out_putf;
  1424. if (can_sleep)
  1425. lock->fl_flags |= FL_SLEEP;
  1426. error = security_file_lock(filp, cmd);
  1427. if (error)
  1428. goto out_free;
  1429. if (filp->f_op && filp->f_op->flock)
  1430. error = filp->f_op->flock(filp,
  1431. (can_sleep) ? F_SETLKW : F_SETLK,
  1432. lock);
  1433. else
  1434. error = flock_lock_file_wait(filp, lock);
  1435. out_free:
  1436. locks_free_lock(lock);
  1437. out_putf:
  1438. fput(filp);
  1439. out:
  1440. return error;
  1441. }
  1442. /* Report the first existing lock that would conflict with l.
  1443. * This implements the F_GETLK command of fcntl().
  1444. */
  1445. int fcntl_getlk(struct file *filp, struct flock __user *l)
  1446. {
  1447. struct file_lock *fl, cfl, file_lock;
  1448. struct flock flock;
  1449. int error;
  1450. error = -EFAULT;
  1451. if (copy_from_user(&flock, l, sizeof(flock)))
  1452. goto out;
  1453. error = -EINVAL;
  1454. if ((flock.l_type != F_RDLCK) && (flock.l_type != F_WRLCK))
  1455. goto out;
  1456. error = flock_to_posix_lock(filp, &file_lock, &flock);
  1457. if (error)
  1458. goto out;
  1459. if (filp->f_op && filp->f_op->lock) {
  1460. error = filp->f_op->lock(filp, F_GETLK, &file_lock);
  1461. if (file_lock.fl_ops && file_lock.fl_ops->fl_release_private)
  1462. file_lock.fl_ops->fl_release_private(&file_lock);
  1463. if (error < 0)
  1464. goto out;
  1465. else
  1466. fl = (file_lock.fl_type == F_UNLCK ? NULL : &file_lock);
  1467. } else {
  1468. fl = (posix_test_lock(filp, &file_lock, &cfl) ? &cfl : NULL);
  1469. }
  1470. flock.l_type = F_UNLCK;
  1471. if (fl != NULL) {
  1472. flock.l_pid = fl->fl_pid;
  1473. #if BITS_PER_LONG == 32
  1474. /*
  1475. * Make sure we can represent the posix lock via
  1476. * legacy 32bit flock.
  1477. */
  1478. error = -EOVERFLOW;
  1479. if (fl->fl_start > OFFT_OFFSET_MAX)
  1480. goto out;
  1481. if ((fl->fl_end != OFFSET_MAX)
  1482. && (fl->fl_end > OFFT_OFFSET_MAX))
  1483. goto out;
  1484. #endif
  1485. flock.l_start = fl->fl_start;
  1486. flock.l_len = fl->fl_end == OFFSET_MAX ? 0 :
  1487. fl->fl_end - fl->fl_start + 1;
  1488. flock.l_whence = 0;
  1489. flock.l_type = fl->fl_type;
  1490. }
  1491. error = -EFAULT;
  1492. if (!copy_to_user(l, &flock, sizeof(flock)))
  1493. error = 0;
  1494. out:
  1495. return error;
  1496. }
  1497. /* Apply the lock described by l to an open file descriptor.
  1498. * This implements both the F_SETLK and F_SETLKW commands of fcntl().
  1499. */
  1500. int fcntl_setlk(unsigned int fd, struct file *filp, unsigned int cmd,
  1501. struct flock __user *l)
  1502. {
  1503. struct file_lock *file_lock = locks_alloc_lock();
  1504. struct flock flock;
  1505. struct inode *inode;
  1506. int error;
  1507. if (file_lock == NULL)
  1508. return -ENOLCK;
  1509. /*
  1510. * This might block, so we do it before checking the inode.
  1511. */
  1512. error = -EFAULT;
  1513. if (copy_from_user(&flock, l, sizeof(flock)))
  1514. goto out;
  1515. inode = filp->f_path.dentry->d_inode;
  1516. /* Don't allow mandatory locks on files that may be memory mapped
  1517. * and shared.
  1518. */
  1519. if (IS_MANDLOCK(inode) &&
  1520. (inode->i_mode & (S_ISGID | S_IXGRP)) == S_ISGID &&
  1521. mapping_writably_mapped(filp->f_mapping)) {
  1522. error = -EAGAIN;
  1523. goto out;
  1524. }
  1525. again:
  1526. error = flock_to_posix_lock(filp, file_lock, &flock);
  1527. if (error)
  1528. goto out;
  1529. if (cmd == F_SETLKW) {
  1530. file_lock->fl_flags |= FL_SLEEP;
  1531. }
  1532. error = -EBADF;
  1533. switch (flock.l_type) {
  1534. case F_RDLCK:
  1535. if (!(filp->f_mode & FMODE_READ))
  1536. goto out;
  1537. break;
  1538. case F_WRLCK:
  1539. if (!(filp->f_mode & FMODE_WRITE))
  1540. goto out;
  1541. break;
  1542. case F_UNLCK:
  1543. break;
  1544. default:
  1545. error = -EINVAL;
  1546. goto out;
  1547. }
  1548. error = security_file_lock(filp, file_lock->fl_type);
  1549. if (error)
  1550. goto out;
  1551. if (filp->f_op && filp->f_op->lock != NULL)
  1552. error = filp->f_op->lock(filp, cmd, file_lock);
  1553. else {
  1554. for (;;) {
  1555. error = posix_lock_file(filp, file_lock);
  1556. if ((error != -EAGAIN) || (cmd == F_SETLK))
  1557. break;
  1558. error = wait_event_interruptible(file_lock->fl_wait,
  1559. !file_lock->fl_next);
  1560. if (!error)
  1561. continue;
  1562. locks_delete_block(file_lock);
  1563. break;
  1564. }
  1565. }
  1566. /*
  1567. * Attempt to detect a close/fcntl race and recover by
  1568. * releasing the lock that was just acquired.
  1569. */
  1570. if (!error && fcheck(fd) != filp && flock.l_type != F_UNLCK) {
  1571. flock.l_type = F_UNLCK;
  1572. goto again;
  1573. }
  1574. out:
  1575. locks_free_lock(file_lock);
  1576. return error;
  1577. }
  1578. #if BITS_PER_LONG == 32
  1579. /* Report the first existing lock that would conflict with l.
  1580. * This implements the F_GETLK command of fcntl().
  1581. */
  1582. int fcntl_getlk64(struct file *filp, struct flock64 __user *l)
  1583. {
  1584. struct file_lock *fl, cfl, file_lock;
  1585. struct flock64 flock;
  1586. int error;
  1587. error = -EFAULT;
  1588. if (copy_from_user(&flock, l, sizeof(flock)))
  1589. goto out;
  1590. error = -EINVAL;
  1591. if ((flock.l_type != F_RDLCK) && (flock.l_type != F_WRLCK))
  1592. goto out;
  1593. error = flock64_to_posix_lock(filp, &file_lock, &flock);
  1594. if (error)
  1595. goto out;
  1596. if (filp->f_op && filp->f_op->lock) {
  1597. error = filp->f_op->lock(filp, F_GETLK, &file_lock);
  1598. if (file_lock.fl_ops && file_lock.fl_ops->fl_release_private)
  1599. file_lock.fl_ops->fl_release_private(&file_lock);
  1600. if (error < 0)
  1601. goto out;
  1602. else
  1603. fl = (file_lock.fl_type == F_UNLCK ? NULL : &file_lock);
  1604. } else {
  1605. fl = (posix_test_lock(filp, &file_lock, &cfl) ? &cfl : NULL);
  1606. }
  1607. flock.l_type = F_UNLCK;
  1608. if (fl != NULL) {
  1609. flock.l_pid = fl->fl_pid;
  1610. flock.l_start = fl->fl_start;
  1611. flock.l_len = fl->fl_end == OFFSET_MAX ? 0 :
  1612. fl->fl_end - fl->fl_start + 1;
  1613. flock.l_whence = 0;
  1614. flock.l_type = fl->fl_type;
  1615. }
  1616. error = -EFAULT;
  1617. if (!copy_to_user(l, &flock, sizeof(flock)))
  1618. error = 0;
  1619. out:
  1620. return error;
  1621. }
  1622. /* Apply the lock described by l to an open file descriptor.
  1623. * This implements both the F_SETLK and F_SETLKW commands of fcntl().
  1624. */
  1625. int fcntl_setlk64(unsigned int fd, struct file *filp, unsigned int cmd,
  1626. struct flock64 __user *l)
  1627. {
  1628. struct file_lock *file_lock = locks_alloc_lock();
  1629. struct flock64 flock;
  1630. struct inode *inode;
  1631. int error;
  1632. if (file_lock == NULL)
  1633. return -ENOLCK;
  1634. /*
  1635. * This might block, so we do it before checking the inode.
  1636. */
  1637. error = -EFAULT;
  1638. if (copy_from_user(&flock, l, sizeof(flock)))
  1639. goto out;
  1640. inode = filp->f_path.dentry->d_inode;
  1641. /* Don't allow mandatory locks on files that may be memory mapped
  1642. * and shared.
  1643. */
  1644. if (IS_MANDLOCK(inode) &&
  1645. (inode->i_mode & (S_ISGID | S_IXGRP)) == S_ISGID &&
  1646. mapping_writably_mapped(filp->f_mapping)) {
  1647. error = -EAGAIN;
  1648. goto out;
  1649. }
  1650. again:
  1651. error = flock64_to_posix_lock(filp, file_lock, &flock);
  1652. if (error)
  1653. goto out;
  1654. if (cmd == F_SETLKW64) {
  1655. file_lock->fl_flags |= FL_SLEEP;
  1656. }
  1657. error = -EBADF;
  1658. switch (flock.l_type) {
  1659. case F_RDLCK:
  1660. if (!(filp->f_mode & FMODE_READ))
  1661. goto out;
  1662. break;
  1663. case F_WRLCK:
  1664. if (!(filp->f_mode & FMODE_WRITE))
  1665. goto out;
  1666. break;
  1667. case F_UNLCK:
  1668. break;
  1669. default:
  1670. error = -EINVAL;
  1671. goto out;
  1672. }
  1673. error = security_file_lock(filp, file_lock->fl_type);
  1674. if (error)
  1675. goto out;
  1676. if (filp->f_op && filp->f_op->lock != NULL)
  1677. error = filp->f_op->lock(filp, cmd, file_lock);
  1678. else {
  1679. for (;;) {
  1680. error = posix_lock_file(filp, file_lock);
  1681. if ((error != -EAGAIN) || (cmd == F_SETLK64))
  1682. break;
  1683. error = wait_event_interruptible(file_lock->fl_wait,
  1684. !file_lock->fl_next);
  1685. if (!error)
  1686. continue;
  1687. locks_delete_block(file_lock);
  1688. break;
  1689. }
  1690. }
  1691. /*
  1692. * Attempt to detect a close/fcntl race and recover by
  1693. * releasing the lock that was just acquired.
  1694. */
  1695. if (!error && fcheck(fd) != filp && flock.l_type != F_UNLCK) {
  1696. flock.l_type = F_UNLCK;
  1697. goto again;
  1698. }
  1699. out:
  1700. locks_free_lock(file_lock);
  1701. return error;
  1702. }
  1703. #endif /* BITS_PER_LONG == 32 */
  1704. /*
  1705. * This function is called when the file is being removed
  1706. * from the task's fd array. POSIX locks belonging to this task
  1707. * are deleted at this time.
  1708. */
  1709. void locks_remove_posix(struct file *filp, fl_owner_t owner)
  1710. {
  1711. struct file_lock lock;
  1712. /*
  1713. * If there are no locks held on this file, we don't need to call
  1714. * posix_lock_file(). Another process could be setting a lock on this
  1715. * file at the same time, but we wouldn't remove that lock anyway.
  1716. */
  1717. if (!filp->f_path.dentry->d_inode->i_flock)
  1718. return;
  1719. lock.fl_type = F_UNLCK;
  1720. lock.fl_flags = FL_POSIX | FL_CLOSE;
  1721. lock.fl_start = 0;
  1722. lock.fl_end = OFFSET_MAX;
  1723. lock.fl_owner = owner;
  1724. lock.fl_pid = current->tgid;
  1725. lock.fl_file = filp;
  1726. lock.fl_ops = NULL;
  1727. lock.fl_lmops = NULL;
  1728. if (filp->f_op && filp->f_op->lock != NULL)
  1729. filp->f_op->lock(filp, F_SETLK, &lock);
  1730. else
  1731. posix_lock_file(filp, &lock);
  1732. if (lock.fl_ops && lock.fl_ops->fl_release_private)
  1733. lock.fl_ops->fl_release_private(&lock);
  1734. }
  1735. EXPORT_SYMBOL(locks_remove_posix);
  1736. /*
  1737. * This function is called on the last close of an open file.
  1738. */
  1739. void locks_remove_flock(struct file *filp)
  1740. {
  1741. struct inode * inode = filp->f_path.dentry->d_inode;
  1742. struct file_lock *fl;
  1743. struct file_lock **before;
  1744. if (!inode->i_flock)
  1745. return;
  1746. if (filp->f_op && filp->f_op->flock) {
  1747. struct file_lock fl = {
  1748. .fl_pid = current->tgid,
  1749. .fl_file = filp,
  1750. .fl_flags = FL_FLOCK,
  1751. .fl_type = F_UNLCK,
  1752. .fl_end = OFFSET_MAX,
  1753. };
  1754. filp->f_op->flock(filp, F_SETLKW, &fl);
  1755. if (fl.fl_ops && fl.fl_ops->fl_release_private)
  1756. fl.fl_ops->fl_release_private(&fl);
  1757. }
  1758. lock_kernel();
  1759. before = &inode->i_flock;
  1760. while ((fl = *before) != NULL) {
  1761. if (fl->fl_file == filp) {
  1762. if (IS_FLOCK(fl)) {
  1763. locks_delete_lock(before);
  1764. continue;
  1765. }
  1766. if (IS_LEASE(fl)) {
  1767. lease_modify(before, F_UNLCK);
  1768. continue;
  1769. }
  1770. /* What? */
  1771. BUG();
  1772. }
  1773. before = &fl->fl_next;
  1774. }
  1775. unlock_kernel();
  1776. }
  1777. /**
  1778. * posix_unblock_lock - stop waiting for a file lock
  1779. * @filp: how the file was opened
  1780. * @waiter: the lock which was waiting
  1781. *
  1782. * lockd needs to block waiting for locks.
  1783. */
  1784. int
  1785. posix_unblock_lock(struct file *filp, struct file_lock *waiter)
  1786. {
  1787. int status = 0;
  1788. lock_kernel();
  1789. if (waiter->fl_next)
  1790. __locks_delete_block(waiter);
  1791. else
  1792. status = -ENOENT;
  1793. unlock_kernel();
  1794. return status;
  1795. }
  1796. EXPORT_SYMBOL(posix_unblock_lock);
  1797. static void lock_get_status(char* out, struct file_lock *fl, int id, char *pfx)
  1798. {
  1799. struct inode *inode = NULL;
  1800. if (fl->fl_file != NULL)
  1801. inode = fl->fl_file->f_path.dentry->d_inode;
  1802. out += sprintf(out, "%d:%s ", id, pfx);
  1803. if (IS_POSIX(fl)) {
  1804. out += sprintf(out, "%6s %s ",
  1805. (fl->fl_flags & FL_ACCESS) ? "ACCESS" : "POSIX ",
  1806. (inode == NULL) ? "*NOINODE*" :
  1807. (IS_MANDLOCK(inode) &&
  1808. (inode->i_mode & (S_IXGRP | S_ISGID)) == S_ISGID) ?
  1809. "MANDATORY" : "ADVISORY ");
  1810. } else if (IS_FLOCK(fl)) {
  1811. if (fl->fl_type & LOCK_MAND) {
  1812. out += sprintf(out, "FLOCK MSNFS ");
  1813. } else {
  1814. out += sprintf(out, "FLOCK ADVISORY ");
  1815. }
  1816. } else if (IS_LEASE(fl)) {
  1817. out += sprintf(out, "LEASE ");
  1818. if (fl->fl_type & F_INPROGRESS)
  1819. out += sprintf(out, "BREAKING ");
  1820. else if (fl->fl_file)
  1821. out += sprintf(out, "ACTIVE ");
  1822. else
  1823. out += sprintf(out, "BREAKER ");
  1824. } else {
  1825. out += sprintf(out, "UNKNOWN UNKNOWN ");
  1826. }
  1827. if (fl->fl_type & LOCK_MAND) {
  1828. out += sprintf(out, "%s ",
  1829. (fl->fl_type & LOCK_READ)
  1830. ? (fl->fl_type & LOCK_WRITE) ? "RW " : "READ "
  1831. : (fl->fl_type & LOCK_WRITE) ? "WRITE" : "NONE ");
  1832. } else {
  1833. out += sprintf(out, "%s ",
  1834. (fl->fl_type & F_INPROGRESS)
  1835. ? (fl->fl_type & F_UNLCK) ? "UNLCK" : "READ "
  1836. : (fl->fl_type & F_WRLCK) ? "WRITE" : "READ ");
  1837. }
  1838. if (inode) {
  1839. #ifdef WE_CAN_BREAK_LSLK_NOW
  1840. out += sprintf(out, "%d %s:%ld ", fl->fl_pid,
  1841. inode->i_sb->s_id, inode->i_ino);
  1842. #else
  1843. /* userspace relies on this representation of dev_t ;-( */
  1844. out += sprintf(out, "%d %02x:%02x:%ld ", fl->fl_pid,
  1845. MAJOR(inode->i_sb->s_dev),
  1846. MINOR(inode->i_sb->s_dev), inode->i_ino);
  1847. #endif
  1848. } else {
  1849. out += sprintf(out, "%d <none>:0 ", fl->fl_pid);
  1850. }
  1851. if (IS_POSIX(fl)) {
  1852. if (fl->fl_end == OFFSET_MAX)
  1853. out += sprintf(out, "%Ld EOF\n", fl->fl_start);
  1854. else
  1855. out += sprintf(out, "%Ld %Ld\n", fl->fl_start,
  1856. fl->fl_end);
  1857. } else {
  1858. out += sprintf(out, "0 EOF\n");
  1859. }
  1860. }
  1861. static void move_lock_status(char **p, off_t* pos, off_t offset)
  1862. {
  1863. int len;
  1864. len = strlen(*p);
  1865. if(*pos >= offset) {
  1866. /* the complete line is valid */
  1867. *p += len;
  1868. *pos += len;
  1869. return;
  1870. }
  1871. if(*pos+len > offset) {
  1872. /* use the second part of the line */
  1873. int i = offset-*pos;
  1874. memmove(*p,*p+i,len-i);
  1875. *p += len-i;
  1876. *pos += len;
  1877. return;
  1878. }
  1879. /* discard the complete line */
  1880. *pos += len;
  1881. }
  1882. /**
  1883. * get_locks_status - reports lock usage in /proc/locks
  1884. * @buffer: address in userspace to write into
  1885. * @start: ?
  1886. * @offset: how far we are through the buffer
  1887. * @length: how much to read
  1888. */
  1889. int get_locks_status(char *buffer, char **start, off_t offset, int length)
  1890. {
  1891. struct list_head *tmp;
  1892. char *q = buffer;
  1893. off_t pos = 0;
  1894. int i = 0;
  1895. lock_kernel();
  1896. list_for_each(tmp, &file_lock_list) {
  1897. struct list_head *btmp;
  1898. struct file_lock *fl = list_entry(tmp, struct file_lock, fl_link);
  1899. lock_get_status(q, fl, ++i, "");
  1900. move_lock_status(&q, &pos, offset);
  1901. if(pos >= offset+length)
  1902. goto done;
  1903. list_for_each(btmp, &fl->fl_block) {
  1904. struct file_lock *bfl = list_entry(btmp,
  1905. struct file_lock, fl_block);
  1906. lock_get_status(q, bfl, i, " ->");
  1907. move_lock_status(&q, &pos, offset);
  1908. if(pos >= offset+length)
  1909. goto done;
  1910. }
  1911. }
  1912. done:
  1913. unlock_kernel();
  1914. *start = buffer;
  1915. if(q-buffer < length)
  1916. return (q-buffer);
  1917. return length;
  1918. }
  1919. /**
  1920. * lock_may_read - checks that the region is free of locks
  1921. * @inode: the inode that is being read
  1922. * @start: the first byte to read
  1923. * @len: the number of bytes to read
  1924. *
  1925. * Emulates Windows locking requirements. Whole-file
  1926. * mandatory locks (share modes) can prohibit a read and
  1927. * byte-range POSIX locks can prohibit a read if they overlap.
  1928. *
  1929. * N.B. this function is only ever called
  1930. * from knfsd and ownership of locks is never checked.
  1931. */
  1932. int lock_may_read(struct inode *inode, loff_t start, unsigned long len)
  1933. {
  1934. struct file_lock *fl;
  1935. int result = 1;
  1936. lock_kernel();
  1937. for (fl = inode->i_flock; fl != NULL; fl = fl->fl_next) {
  1938. if (IS_POSIX(fl)) {
  1939. if (fl->fl_type == F_RDLCK)
  1940. continue;
  1941. if ((fl->fl_end < start) || (fl->fl_start > (start + len)))
  1942. continue;
  1943. } else if (IS_FLOCK(fl)) {
  1944. if (!(fl->fl_type & LOCK_MAND))
  1945. continue;
  1946. if (fl->fl_type & LOCK_READ)
  1947. continue;
  1948. } else
  1949. continue;
  1950. result = 0;
  1951. break;
  1952. }
  1953. unlock_kernel();
  1954. return result;
  1955. }
  1956. EXPORT_SYMBOL(lock_may_read);
  1957. /**
  1958. * lock_may_write - checks that the region is free of locks
  1959. * @inode: the inode that is being written
  1960. * @start: the first byte to write
  1961. * @len: the number of bytes to write
  1962. *
  1963. * Emulates Windows locking requirements. Whole-file
  1964. * mandatory locks (share modes) can prohibit a write and
  1965. * byte-range POSIX locks can prohibit a write if they overlap.
  1966. *
  1967. * N.B. this function is only ever called
  1968. * from knfsd and ownership of locks is never checked.
  1969. */
  1970. int lock_may_write(struct inode *inode, loff_t start, unsigned long len)
  1971. {
  1972. struct file_lock *fl;
  1973. int result = 1;
  1974. lock_kernel();
  1975. for (fl = inode->i_flock; fl != NULL; fl = fl->fl_next) {
  1976. if (IS_POSIX(fl)) {
  1977. if ((fl->fl_end < start) || (fl->fl_start > (start + len)))
  1978. continue;
  1979. } else if (IS_FLOCK(fl)) {
  1980. if (!(fl->fl_type & LOCK_MAND))
  1981. continue;
  1982. if (fl->fl_type & LOCK_WRITE)
  1983. continue;
  1984. } else
  1985. continue;
  1986. result = 0;
  1987. break;
  1988. }
  1989. unlock_kernel();
  1990. return result;
  1991. }
  1992. EXPORT_SYMBOL(lock_may_write);
  1993. static int __init filelock_init(void)
  1994. {
  1995. filelock_cache = kmem_cache_create("file_lock_cache",
  1996. sizeof(struct file_lock), 0, SLAB_PANIC,
  1997. init_once, NULL);
  1998. return 0;
  1999. }
  2000. core_initcall(filelock_init);