What are pid and lock files for?

Class	Daemons::PidFile
In:	lib/daemons/pidfile.rb
Parent:	Pid

What is a Pid-File?

A Pid-File is a file containing the process identification number (pid) that is stored in a well-defined location of the filesystem thus allowing other programs to find out the pid of a running script.

Daemons needs the pid of the scripts that are currently running in the background to send them so called signals. Daemons uses the TERM signal to tell the script to exit when you issue a stop command.

How does a Pid-File look like?

Pid-Files generated by Daemons have to following format:

  <scriptname>.rb<number>.pid

(Note that <number> is omitted if only one instance of the script can run at any time)

Each file just contains one line with the pid as string (for example 6432).

Where are the Pid-Files stored?

Daemons is configurable to store the Pid-Files relative to three different locations:

1. in a directory relative to the directory where the script (the one that is supposed to run as a daemon) resides (:script option for :dir_mode)
2. in a directory given by :dir (:normal option for :dir_mode)
3. in the preconfigured directory /var/run (:system option for :dir_mode)

Methods

cleanup   exist?   existing   filename   find_files   new   pid   pid=  

Attributes

dir	[R]
multiple	[R]
number	[R]
progname	[R]

Public Class methods

existing(path)

[Source]

    # File lib/daemons/pidfile.rb, line 55
55:     def PidFile.existing(path)
56:       new_instance = PidFile.allocate
57:       
58:       new_instance.instance_variable_set(:@path, path)
59:       
60:       def new_instance.filename
61:         return @path
62:       end
63:       
64:       return new_instance
65:     end

find_files(dir, progname, delete = false)

[Source]

    # File lib/daemons/pidfile.rb, line 36
36:     def PidFile.find_files(dir, progname, delete = false)
37:       files = Dir[File.join(dir, "#{progname}*.pid")]
38:       
39:       files.delete_if {|f| not (File.file?(f) and File.readable?(f))}
40:       if delete 
41:         files.delete_if do |f|
42:           pid = File.open(f) {|h| h.read}.to_i
43:           rsl =  ! Pid.running?(pid)
44:           if rsl
45:             puts "pid-file for killed process #{pid} found (#{f}), deleting."
46:             begin; File.unlink(f); rescue ::Exception; end
47:           end
48:           rsl
49:         end
50:       end
51:     
52:       return files
53:     end

new(dir, progname, multiple = false)

[Source]

    # File lib/daemons/pidfile.rb, line 67
67:     def  initializeinitialize(dir, progname, multiple = false)
68:       @dir = File.expand_path(dir)
69:       @progname = progname
70:       @multiple = multiple
71:       @number = nil
72:       @number = 0 if multiple
73:       
74:       if multiple
75:         while File.exist?(filename) and @number < 1024
76:           @number += 1
77:         end
78:         
79:         if @number == 1024
80:           raise RuntimeException('cannot run more than 1024 instances of the application')
81:         end
82:       end
83:     end

Public Instance methods

cleanup()

[Source]

     # File lib/daemons/pidfile.rb, line 100
100:     def cleanup
101:       File.delete(filename) if pid == Process.pid
102:     end

exist?()

[Source]

    # File lib/daemons/pidfile.rb, line 89
89:     def exist?
90:       File.exist? filename
91:     end

filename()

[Source]

    # File lib/daemons/pidfile.rb, line 85
85:     def filename
86:       File.join(@dir, "#{@progname}#{ @number or '' }.pid")
87:     end

pid()

[Source]

     # File lib/daemons/pidfile.rb, line 104
104:     def pid
105:       begin
106:         File.open(filename) {|f|
107:           return f.gets.to_i
108:         }
109:       rescue ::Exception
110:         return nil
111:       end
112:     end

pid=(p)

[Source]

    # File lib/daemons/pidfile.rb, line 93
93:     def pid=(p)
94:       File.open(filename, 'w') {|f|
95:         f.chmod(0644)
96:         f.puts p   #Process.pid
97:       }
98:     end

[Validate]

 

 

 

8 down vote favorite share [g+] share [fb] share [tw]

I often see that programs specify pid and lock files. And I'm not quite sure what they do.

For example, when compiling nginx:

--pid-path=/var/run/nginx.pid \ --lock-path=/var/lock/nginx.lock \ 

Can somebody shed some light on this one?

lock pidfile

linkimprove this question

edited May 8 '11 at 1:34

asked May 7 '11 at 20:19 Stann 33418 100% accept rate

feedback

migrated from serverfault.com May 7 '11 at 20:41

This question came from our site for system administrators and desktop support professionals.

3 Answers

active oldest votes

up vote 10 down vote accepted

pid files are written by some programs to record their process ID while they are starting. This has multiple purposes:

• It's a signal to other processes and users of the system that that particular program is running, or at least started successfully.
• It allows one to write a script really easy to check if it's running and issue a plain kill command if one wants to end it.
• It's a cheap way for a program to see if a previous running instance of it did not exit successfully.

Mere presence of a pid file doesn't guarantee that that particular process id is running, of course, so this method isn't 100% foolproof but "good enough" in a lot of instances. Checking if a particular PID exists in the process table isn't totally portable across UNIX-like operating systems unless you want to depend on the ps utility, which may not be desirable to call in all instances (and I believe some UNIX-like operating systems implement ps differently anyway).

Lock files are used by programs to ensure two (well-behaved) separate instances of a program, which may be running concurrently on one system, don't access something else at the same time. The idea is before the program accesses its resource, it checks for presence of a lock file, and if the lock file exists, either error out or wait for it to go away. When it doesn't exist, the program wanting to "acquire" the resource creates the file, and then other instances that might come across later will wait for this process to be done with it. Of course, this assumes the program "acquiring" the lock does in fact release it and doesn't forget to delete the lock file.

This works because the filesystem under all UNIX-like operating systems enforces serialization, which means only one change to the filesystem actually happens at any given time. Sort of like locks with databases and such.

linkimprove this answer

answered May 7 '11 at 20:50 ultrasawblade 2,4051313

feedback

up vote 4 down vote

These files are often used by daemons that should only be run once on a system. The PID file usually contains the process ID number of the already launched and running program if one exists. Also, when it starts up, it creates the lock file. As long as the lock file exists, it won't start another one without user intervention. If the lock file exists and the process id mentioned in the pid file isn't running, the daemon is considered to be in a "dead" state, meaning it's supposed to be running but isn't probably due to a crash or improper shutdown. This might initiate a special startup / restart scenario for some programs. Properly shutting it down will remove the lock file.

linkimprove this answer

answered May 7 '11 at 20:46 Caleb 19.6k22953

feedback

up vote 3 down vote

A PID file will contain the Process ID of a running process. This has various uses; you can read it and check that the process is still running and take appropriate action or read it and kill the process. A lock file is most likely application specific. Lock files are used to indicate that some resource is in use and that the process wanting access should wait until the resource is freed before continuing.