Add -p switch to "zpool get"
[zfs.git] / etc / init.d / zfs.fedora.in
1 #!/bin/bash
2 #
3 # zfs           This script will mount/umount the zfs filesystems.
4 #
5 # chkconfig:    2345 01 99
6 # description:  This script will mount/umount the zfs filesystems during
7 #               system boot/shutdown.  Configuration of which filesystems
8 #               should be mounted is handled by the zfs 'mountpoint' and
9 #               'canmount' properties.  See the zfs(8) man page for details.
10 #               It is also responsible for all userspace zfs services.
11 #
12 ### BEGIN INIT INFO
13 # Provides: zfs
14 # Required-Start:
15 # Required-Stop:
16 # Should-Start:
17 # Should-Stop:
18 # Default-Start: 2 3 4 5
19 # Default-Stop: 1
20 # Short-Description: Mount/umount the zfs filesystems
21 # Description: ZFS is an advanced filesystem designed to simplify managing
22 #              and protecting your data.  This service mounts the ZFS
23 #              filesystems and starts all related zfs services.
24 ### END INIT INFO
25
26 export PATH=/usr/local/sbin:/usr/bin:/bin:/usr/local/sbin:/usr/sbin:/sbin
27
28 if [ -z "$init" ]; then
29     # Not interactive
30     grep -Eqi 'zfs=off|zfs=no' /proc/cmdline && exit 3
31 fi
32
33 # Source function library & LSB routines
34 . /etc/rc.d/init.d/functions
35
36 # script variables
37 RETVAL=0
38 ZFS="@sbindir@/zfs"
39 ZPOOL="@sbindir@/zpool"
40 ZPOOL_CACHE="@sysconfdir@/zfs/zpool.cache"
41 servicename=zfs
42 LOCKFILE=/var/lock/subsys/$servicename
43
44 # functions
45 zfs_installed() {
46         modinfo zfs > /dev/null 2>&1 || return 5
47         $ZPOOL  > /dev/null 2>&1
48         [ $? == 127 ] && return 5
49         $ZFS    > /dev/null 2>&1
50         [ $? == 127 ] && return 5
51         return 0
52 }
53
54 reregister_mounts() {
55         cat /etc/mtab | while read -r fs mntpnt fstype opts rest ; do
56                 fs=`printf '%b\n' "$fs"`
57                 mntpnt=`printf '%b\n' "$mntpnt"`
58                 if [ "$fstype" == "zfs" ] ; then
59                         if [ "$mntpnt" == "/" ] ; then
60                                 mount -f -o zfsutil -t zfs --move / /removethismountpointhoweverpossible
61                                 umount --fake /removethismountpointhoweverpossible
62                         else
63                                 umount --fake "$mntpnt"
64                         fi
65                 elif echo "$fs" | grep -q "^/dev/zd" ; then
66                         if [ "$mntpnt" == "/" ] ; then
67                                 mount -f -t "$fstype" --move / /removethismountpointhoweverpossible
68                                 umount --fake /removethismountpointhoweverpossible
69                         else
70                                 umount --fake "$mntpnt"
71                         fi
72                 fi
73         done
74         cat /proc/mounts | while read -r fs mntpnt fstype opts rest ; do
75                 fs=`printf '%b\n' "$fs"`
76                 mntpnt=`printf '%b\n' "$mntpnt"`
77                 if [ "$fstype" == "zfs" ] ; then
78                         mount -f -t zfs -o zfsutil "$fs" "$mntpnt"
79                 elif echo "$fs" | grep -q "^/dev/zd" ; then
80                         mount -f -t "$fstype" -o "$opts" "$fs" "$mntpnt"
81                 fi
82         done
83 }
84
85 # i need a bash guru to simplify this, since this is copy and paste, but donno how
86 # to correctly dereference variable names in bash, or how to do this right
87
88 declare -A MTAB
89 declare -A FSTAB
90
91 # first parameter is a regular expression that filters mtab
92 read_mtab() {
93         for fs in "${!MTAB[@]}" ; do unset MTAB["$fs"] ; done
94         while read -r fs mntpnt fstype opts blah ; do
95                 fs=`printf '%b\n' "$fs"`
96                 MTAB["$fs"]=$mntpnt
97         done < <(grep "$1" /etc/mtab)
98 }
99
100 in_mtab() {
101         [ "${MTAB[$1]}" != "" ]
102         return $?
103 }
104
105 # first parameter is a regular expression that filters fstab
106 read_fstab() {
107         for fs in "${!FSTAB[@]}" ; do unset FSTAB["$fs"] ; done
108         while read -r fs mntpnt fstype opts blah ; do
109                 fs=`printf '%b\n' "$fs"`
110                 FSTAB["$fs"]=$mntpnt
111         done < <(grep "$1" /etc/fstab)
112 }
113
114 in_fstab() {
115         [ "${FSTAB[$1]}" != "" ]
116         return $?
117 }
118
119 start()
120 {
121         if [ -f "$LOCKFILE" ] ; then return 0 ; fi
122
123         # check if ZFS is installed.  If not, comply to FC standards and bail
124         zfs_installed || {
125                 action $"Checking if ZFS is installed: not installed" /bin/false
126                 return 5
127         }
128
129         # Requires selinux policy which has not been written.
130         if [ -r "/selinux/enforce" ] &&
131            [ "$(cat /selinux/enforce)" = "1" ]; then
132                 action $"SELinux ZFS policy required: " /bin/false || return 6
133         fi
134
135         # Delay until all required block devices are present.
136         udevadm settle
137
138         # load kernel module infrastructure
139         if ! grep -q zfs /proc/modules ; then
140                 action $"Loading kernel ZFS infrastructure: " modprobe zfs || return 5
141         fi
142
143         # fix mtab to include already-mounted fs filesystems, in case there are any
144         # we ONLY do this if mtab does not point to /proc/mounts
145         # which is the case in some systems (systemd may bring that soon)
146         if ! readlink /etc/mtab | grep -q /proc ; then
147                 if grep -qE "(^/dev/zd| zfs )" /proc/mounts ; then
148                         action $"Registering already-mounted ZFS filesystems and volumes: " reregister_mounts || return 150
149                 fi
150         fi
151
152         if [ -f $ZPOOL_CACHE ] ; then
153
154                 echo -n $"Importing ZFS pools not yet imported: "
155                 $ZPOOL import -c $ZPOOL_CACHE -aN || true # stupid zpool will fail if all pools are already imported
156                 RETVAL=$?
157                 if [ $RETVAL -ne 0 ]; then
158                         failure "Importing ZFS pools not yet imported: "
159                         return 151
160                 fi
161                 success "Importing ZFS pools not yet imported: "
162
163         fi
164
165         action $"Mounting ZFS filesystems not yet mounted: " $ZFS mount -a || return 152
166
167         action $"Exporting ZFS filesystems: " $ZFS share -a || return 153
168
169         read_mtab  "^/dev/zd"
170         read_fstab "^/dev/zd"
171
172         template=$"Mounting volume %s registered in fstab: "
173         for volume in "${!FSTAB[@]}" ; do
174                 if in_mtab "$volume" ; then continue ; fi
175                 string=`printf "$template" "$volume"`
176                 action "$string" mount "$volume"
177         done
178
179         touch "$LOCKFILE"
180 }
181
182 stop()
183 {
184         if [ ! -f "$LOCKFILE" ] ; then return 0 ; fi
185
186         # check if ZFS is installed.  If not, comply to FC standards and bail
187         zfs_installed || {
188                 action $"Checking if ZFS is installed: not installed" /bin/false
189                 return 5
190         }
191
192         # the poweroff of the system takes care of this
193         # but it never unmounts the root filesystem itself
194         # shit
195
196         action $"Syncing ZFS filesystems: " sync
197              # about the only thing we can do, and then we
198              # hope that the umount process will succeed
199              # unfortunately the umount process does not dismount
200              # the root file system, there ought to be some way
201              # we can tell zfs to just flush anything in memory
202              # when a request to remount,ro comes in
203
204         #echo -n $"Unmounting ZFS filesystems: "
205         #$ZFS umount -a
206         #RETVAL=$?
207         #if [ $RETVAL -ne 0 ]; then
208         #       failure
209
210         #       return 8
211         #fi
212         #success
213
214         rm -f "$LOCKFILE"
215 }
216
217 # See how we are called
218 case "$1" in
219         start)
220                 start
221                 RETVAL=$?
222                 ;;
223         stop)
224                 stop
225                 RETVAL=$?
226                 ;;
227         status)
228                 lsmod | grep -q zfs || RETVAL=3
229                 $ZPOOL status && echo && $ZFS list || {
230                         [ -f "$LOCKFILE" ] && RETVAL=2 || RETVAL=4
231                 }
232                 ;;
233         restart)
234                 stop
235                 start
236                 ;;
237         condrestart)
238                 if [ -f "$LOCKFILE" ] ; then
239                         stop
240                         start
241                 fi
242                 ;;
243         *)
244                 echo $"Usage: $0 {start|stop|status|restart|condrestart}"
245                 RETVAL=3
246                 ;;
247 esac
248
249 exit $RETVAL