0a08f79b5f8dda8df9396427453a593fc1e8dfcf
[dragonfly.git] / sbin / swapon / swapon.c
1 /*
2  * Copyright (c) 1980, 1993
3  *      The Regents of the University of California.  All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  * 3. Neither the name of the University nor the names of its contributors
14  *    may be used to endorse or promote products derived from this software
15  *    without specific prior written permission.
16  *
17  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27  * SUCH DAMAGE.
28  *
29  * @(#) Copyright (c) 1980, 1993 The Regents of the University of California.  All rights reserved.
30  * @(#)swapon.c 8.1 (Berkeley) 6/5/93
31  * $FreeBSD: src/sbin/swapon/swapon.c,v 1.8.2.2 2001/07/30 10:30:11 dd Exp $
32  */
33
34 #include <sys/param.h>
35 #include <sys/stat.h>
36 #include <sys/sysctl.h>
37 #include <sys/linker.h>
38 #include <sys/diskslice.h>
39 #include <sys/ioctl_compat.h>
40 #include <vm/vm_param.h>
41
42 #include <err.h>
43 #include <errno.h>
44 #include <fstab.h>
45 #include <stdio.h>
46 #include <stdlib.h>
47 #include <string.h>
48 #include <unistd.h>
49 #include <fcntl.h>
50 #include <libutil.h>
51
52 static void usage(void);
53 static int swap_on_off(char *name, int doingall, int trim, int ask);
54 static char *docrypt(char *fs_spec, int pass);
55 static void swaplist(int lflag, int sflag, int hflag);
56
57 static int qflag;
58
59 enum { SWAPON, SWAPOFF, SWAPCTL } orig_prog, which_prog = SWAPCTL;
60
61 int
62 main(int argc, char **argv)
63 {
64         struct fstab *fsp;
65         char *ptr;
66         int ret;
67         int ch;
68         int doall, sflag, lflag, hflag, eflag, cflag, iflag;
69
70         if ((ptr = strrchr(argv[0], '/')) == NULL)
71                 ptr = argv[0];
72         if (strstr(ptr, "swapon"))
73                 which_prog = SWAPON;
74         else if (strstr(ptr, "swapoff"))
75                 which_prog = SWAPOFF;
76         orig_prog = which_prog;
77
78         sflag = lflag = hflag = doall = eflag = cflag = iflag = 0;
79         while ((ch = getopt(argc, argv, "AacdeghiklmqsU")) != -1) {
80                 switch((char)ch) {
81                 case 'A':
82                         if (which_prog == SWAPCTL) {
83                                 doall = 1;
84                                 which_prog = SWAPON;
85                         } else {
86                                 usage();
87                         }
88                         break;
89                 case 'a':
90                         if (which_prog == SWAPON || which_prog == SWAPOFF)
91                                 doall = 1;
92                         else
93                                 which_prog = SWAPON;
94                         break;
95                 case 'd':
96                         if (which_prog == SWAPCTL)
97                                 which_prog = SWAPOFF;
98                         else
99                                 usage();
100                         break;
101                 case 'c':
102                         cflag = 1;
103                         break;
104                 case 'e':
105                         eflag = 1;
106                         break;
107                 case 'g':
108                         hflag = 'G';
109                         break;
110                 case 'h':
111                         hflag = 'H';
112                         break;
113                 case 'i':
114                         iflag = 1;
115                         break;
116                 case 'k':
117                         hflag = 'K';
118                         break;
119                 case 'l':
120                         lflag = 1;
121                         break;
122                 case 'm':
123                         hflag = 'M';
124                         break;
125                 case 'q':
126                         if (which_prog == SWAPON || which_prog == SWAPOFF)
127                                 qflag = 1;
128                         break;
129                 case 's':
130                         sflag = 1;
131                         break;
132                 case 'U':
133                         if (which_prog == SWAPCTL) {
134                                 doall = 1;
135                                 which_prog = SWAPOFF;
136                         } else {
137                                 usage();
138                         }
139                         break;
140                 case '?':
141                 default:
142                         usage();
143                 }
144         }
145         argv += optind;
146
147         ret = 0;
148         if (which_prog == SWAPON || which_prog == SWAPOFF) {
149                 if (doall) {
150                         while ((fsp = getfsent()) != NULL) {
151                                 char *fs_spec;
152                                 int dotrim = eflag;
153
154                                 if (strcmp(fsp->fs_type, FSTAB_SW))
155                                         continue;
156                                 if (strstr(fsp->fs_mntops, "noauto"))
157                                         continue;
158
159                                 if (strstr(fsp->fs_mntops, "notrim"))
160                                         dotrim = 0;
161                                 else if (strstr(fsp->fs_mntops, "trim"))
162                                         dotrim = 1;
163
164                                 if (cflag || strstr(fsp->fs_mntops, "crypt"))
165                                         fs_spec = docrypt(fsp->fs_spec, 1);
166                                 else
167                                         fs_spec = strdup(fsp->fs_spec);
168                                 if (swap_on_off(fs_spec, 1, dotrim, iflag)) {
169                                         ret = 1;
170                                 } else {
171                                         if (cflag ||
172                                             strstr(fsp->fs_mntops, "crypt")) {
173                                                 docrypt(fsp->fs_spec, 2);
174                                         }
175                                         if (!qflag) {
176                                                 printf("%s: %sing %s as swap "
177                                                        "device\n",
178                                                     getprogname(),
179                                                     (which_prog == SWAPOFF ?
180                                                             "remov" : "add"),
181                                                     fs_spec);
182                                         }
183                                 }
184                                 free(fs_spec);
185                         }
186                 } else if (*argv == NULL) {
187                         usage();
188                 }
189                 for (; *argv; ++argv) {
190                         char *ospec = getdevpath(*argv, 0);
191                         char *fs_spec;
192                         if (cflag)
193                                 fs_spec = docrypt(ospec, 1);
194                         else
195                                 fs_spec = strdup(ospec);
196                         if (swap_on_off(fs_spec, 0, eflag, iflag)) {
197                                 ret = 1;
198                         } else {
199                                 if (cflag)
200                                         docrypt(ospec, 2);
201                                 if (!qflag) {
202                                         printf("%s: %sing %s as swap device\n",
203                                             getprogname(),
204                                             (which_prog == SWAPOFF ?
205                                                 "remov" : "add"),
206                                             fs_spec);
207                                 }
208                         }
209                         free(fs_spec);
210                 }
211         } else {
212                 if (lflag || sflag)
213                         swaplist(lflag, sflag, hflag);
214                 else
215                         usage();
216         }
217         exit(ret);
218 }
219
220 static
221 char *
222 docrypt(char *fs_spec, int pass)
223 {
224         char *id;
225         char *res;
226         char *buf;
227
228         if ((id = strrchr(fs_spec, '/')) == NULL)
229                 id = fs_spec;
230         else
231                 ++id;
232         asprintf(&id, "swap-%s", id);
233         asprintf(&res, "/dev/mapper/%s", id);
234
235         switch(which_prog) {
236         case SWAPOFF:
237                 if (pass != 2)
238                         break;
239                 asprintf(&buf, "/sbin/cryptsetup remove %s", id);
240                 system(buf);
241                 free(buf);
242                 free(id);
243                 break;
244         case SWAPON:
245                 if (pass != 1)
246                         break;
247                 if (kldfind("dm_target_crypt") < 0)
248                         kldload("dm_target_crypt");
249
250                 asprintf(&buf,
251                          "/sbin/cryptsetup --key-file /dev/urandom "
252                          "--key-size 256 create %s %s",
253                          id, fs_spec);
254                 if (qflag == 0)
255                         printf("%s\n", buf);
256                 system(buf);
257                 free(buf);
258                 free(id);
259
260                 /*
261                  * NOTE: Don't revert to /dev/da* on error because this could
262                  *       inadvertently add both /dev/da* and
263                  *       /dev/mapper/swap-da*.
264                  *
265                  *       Allow the swapon operation to report failure or
266                  *       report a duplicate.
267                  */
268                 break;
269         default:
270                 free(res);
271                 free(id);
272                 res = strdup(fs_spec);
273                 break;
274         }
275
276         if (pass == 2) {
277                 free (res);
278                 res = NULL;
279         }
280         return res;
281 }
282
283 /*
284  * TRIM the device
285  */
286 static
287 void
288 trim_volume(char * name)
289 {       
290         struct partinfo pinfo;
291         int fd,i,n;
292         size_t bytes = 0,ksize;
293         char *xswbuf;
294         struct xswdev *xsw;
295
296
297         /*
298         * Determine if this device is already being used by swap without 
299         * calling swapon(). 
300         */
301         if ((sysctlbyname("vm.swap_info_array", NULL, &bytes, NULL, 0) < 0) ||
302             bytes == 0) {
303                 err(1, "sysctlbyname()");
304         }
305
306         xswbuf = malloc(bytes);
307         if ((sysctlbyname("vm.swap_info_array", xswbuf, &bytes, NULL, 0) < 0) ||
308             bytes == 0) {
309                         free(xswbuf);
310                         err(1, "sysctlbyname()");
311         }
312
313         ksize = ((struct xswdev *)xswbuf)->xsw_size;
314         n = (int)(bytes / ksize);
315         for (i = 0; i < n; ++i) {
316                 xsw = (void *)((char *)xswbuf + i * ksize);
317
318                 if (xsw->xsw_dev == NODEV )
319                         continue;
320                 if(!strcmp(devname(xsw->xsw_dev, S_IFCHR),
321                     name + strlen("/dev/"))) {
322                         warnx("%s: device already a swap device", name);
323                         exit(1);
324                 }
325         }
326         
327         /*
328          * Get the size and offset of this parititon/device
329          */
330         fd = open(name, O_RDWR);
331         if (fd < 0)
332                 err(1, "Unable to open %s R+W", name);
333         if (ioctl(fd, DIOCGPART, &pinfo) < 0) {
334                 printf("Cannot trim regular file\n");
335                 usage ();
336         }
337         off_t ioarg[2];
338         
339         /*Trim the Device*/     
340         ioarg[0] = pinfo.media_offset;
341         ioarg[1] = pinfo.media_size;
342         printf("Trimming Device:%s, sectors (%llu -%llu)\n",name,
343              (unsigned long long)ioarg[0]/512,
344              (unsigned long long)ioarg[1]/512);
345         if (ioctl(fd, IOCTLTRIM, ioarg) < 0) {
346                 printf("Device trim failed\n");
347                 usage ();
348         }
349         close(fd);
350 }
351
352 static int
353 swap_on_off(char *name, int doingall, int trim, int ask)
354 {
355
356         if (ask && which_prog == SWAPON) {
357                 printf("Do you really want to use device %s as a swap device ?\n", name);
358                 printf("You might loose data. [Y/N]");
359
360                 int c = fgetc(stdin);
361                 printf("\n");
362                 if (c != 'y' && c != 'Y')
363                         return(1);
364
365         }
366         if (which_prog == SWAPON && trim) {
367                 char sysctl_name[64];
368                 int trim_enabled = 0;
369                 size_t olen = sizeof(trim_enabled);
370                 char *dev_name = strdup(name);
371                 dev_name = strtok(dev_name + strlen("/dev/da"),"s");
372                 sprintf(sysctl_name, "kern.cam.da.%s.trim_enabled", dev_name);
373                 if (sysctlbyname(sysctl_name, &trim_enabled, &olen, NULL, 0) < 0) {
374                         if (qflag == 0) {
375                                 printf("TRIM not supported on %s, "
376                                        "ignoring\n",
377                                        name);
378                         }
379                         errno = 0;
380                 } else if (!trim_enabled) {
381                         if (qflag == 0) {
382                                 printf("TRIM not enabled on %s (%s), "
383                                        "ignoring\n",
384                                        name, sysctl_name);
385                         }
386                 } else {
387                         trim_volume(name);
388                 }
389         }
390         if ((which_prog == SWAPOFF ? swapoff(name) : swapon(name)) == -1) {
391                 switch(errno) {
392                 case EBUSY:
393                         if (!doingall)
394                                 warnx("%s: device already in use", name);
395                         break;
396                 case EINVAL:
397                         if (which_prog == SWAPON)
398                                 warnx("%s: NSWAPDEV limit reached", name);
399                         else if (!doingall)
400                                 warn("%s", name);
401                         break;
402                 default:
403                         warn("%s", name);
404                         break;
405                 }
406                 return(1);
407         }
408         return(0);
409 }
410
411 static void
412 usage(void)
413 {
414         fprintf(stderr, "usage: %s ", getprogname());
415         switch (orig_prog) {
416         case SWAPON:
417         case SWAPOFF:
418                 fprintf(stderr, "-aeiq | file ...\n");
419                 break;
420         case SWAPCTL:
421                 fprintf(stderr, "[-AeghiklmsU] [-a file ... | -d file ...]\n");
422                 break;
423         }
424         exit(1);
425 }
426
427 static void
428 sizetobuf(char *buf, size_t bufsize, int hflag, long long val, int hlen,
429     long blocksize)
430 {
431         if (hflag == 'H') {
432                 char tmp[16];
433
434                 humanize_number(tmp, 5, (int64_t)val, "", HN_AUTOSCALE,
435                     HN_B | HN_NOSPACE | HN_DECIMAL);
436                 snprintf(buf, bufsize, "%*s", hlen, tmp);
437         } else {
438                 snprintf(buf, bufsize, "%*lld", hlen, val / blocksize);
439         }
440 }
441
442 static void
443 swaplist(int lflag, int sflag, int hflag)
444 {
445         size_t ksize, bytes = 0;
446         char *xswbuf;
447         struct xswdev *xsw;
448         int hlen, pagesize;
449         int i, n;
450         long blocksize;
451         long long total, used, tmp_total, tmp_used;
452         char buf[32];
453
454         pagesize = getpagesize();
455         switch(hflag) {
456         case 'G':
457                 blocksize = 1024 * 1024 * 1024;
458                 strlcpy(buf, "1GB-blocks", sizeof(buf));
459                 hlen = 10;
460                 break;
461         case 'H':
462                 blocksize = -1;
463                 strlcpy(buf, "Bytes", sizeof(buf));
464                 hlen = 10;
465                 break;
466         case 'K':
467                 blocksize = 1024;
468                 strlcpy(buf, "1kB-blocks", sizeof(buf));
469                 hlen = 10;
470                 break;
471         case 'M':
472                 blocksize = 1024 * 1024;
473                 strlcpy(buf, "1MB-blocks", sizeof(buf));
474                 hlen = 10;
475                 break;
476         default:
477                 getbsize(&hlen, &blocksize);
478                 snprintf(buf, sizeof(buf), "%ld-blocks", blocksize);
479                 break;
480         }
481
482         if (sysctlbyname("vm.swap_info_array", NULL, &bytes, NULL, 0) < 0)
483                 err(1, "sysctlbyname()");
484         if (bytes == 0)
485                 err(1, "sysctlbyname()");
486
487         xswbuf = malloc(bytes);
488         if (sysctlbyname("vm.swap_info_array", xswbuf, &bytes, NULL, 0) < 0) {
489                 free(xswbuf);
490                 err(1, "sysctlbyname()");
491         }
492         if (bytes == 0) {
493                 free(xswbuf);
494                 err(1, "sysctlbyname()");
495         }
496
497         /*
498          * Calculate size of xsw entry returned by kernel (it can be larger
499          * than the one we have if there is a version mismatch).
500          */
501         ksize = ((struct xswdev *)xswbuf)->xsw_size;
502         n = (int)(bytes / ksize);
503
504         if (lflag) {
505                 printf("%-13s %*s %*s\n",
506                     "Device:",
507                     hlen, buf,
508                     hlen, "Used:");
509         }
510
511         total = used = tmp_total = tmp_used = 0;
512         for (i = 0; i < n; ++i) {
513                 xsw = (void *)((char *)xswbuf + i * ksize);
514
515                 if (xsw->xsw_nblks == 0)
516                         continue;
517
518                 tmp_total = (long long)xsw->xsw_nblks * pagesize;
519                 tmp_used = (long long)xsw->xsw_used * pagesize;
520                 total += tmp_total;
521                 used += tmp_used;
522                 if (lflag) {
523                         sizetobuf(buf, sizeof(buf), hflag, tmp_total, hlen,
524                             blocksize);
525                         if (xsw->xsw_dev == NODEV) {
526                                 printf("%-13s %s ", "[NFS swap]", buf);
527                         } else {
528                                 printf("/dev/%-8s %s ",
529                                     devname(xsw->xsw_dev, S_IFCHR), buf);
530                         }
531
532                         sizetobuf(buf, sizeof(buf), hflag, tmp_used, hlen,
533                             blocksize);
534                         printf("%s\n", buf);
535                 }
536         }
537
538         if (sflag) {
539                 sizetobuf(buf, sizeof(buf), hflag, total, hlen, blocksize);
540                 printf("Total:        %s ", buf);
541                 sizetobuf(buf, sizeof(buf), hflag, used, hlen, blocksize);
542                 printf("%s\n", buf);
543         }
544 }