1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright 2007 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26 /*
27 * lofiadm - administer lofi(7d). Very simple, add and remove file<->device
28 * associations, and display status. All the ioctls are private between
29 * lofi and lofiadm, and so are very simple - device information is
30 * communicated via a minor number.
31 */
32
33 #pragma ident "@(#)main.c 1.8 07/12/18 SMI"
34
35 #include <sys/types.h>
36 #include <sys/param.h>
37 #include <sys/lofi.h>
38 #include <sys/stat.h>
39 #include <netinet/in.h>
40 #include <stdio.h>
41 #include <fcntl.h>
42 #include <locale.h>
43 #include <string.h>
44 #include <strings.h>
45 #include <errno.h>
46 #include <stdlib.h>
47 #include <unistd.h>
48 #include <stropts.h>
49 #include <libdevinfo.h>
50 #include <libgen.h>
51 #include <ctype.h>
52 #include <dlfcn.h>
53 #include "utils.h"
54
55 static const char USAGE[] =
56 "Usage: %s -a file [ device ]\n"
57 " %s -d file | device \n"
58 " %s -C [algorithm] [-s segment_size] file \n"
59 " %s -U file \n"
60 " %s [ device | file ]\n";
61
62 static const char *pname;
63 static int addflag = 0;
64 static int deleteflag = 0;
65 static int errflag = 0;
66 static int compressflag = 0;
67 static int uncompressflag = 0;
68
69 static int gzip_compress(void *src, size_t srclen, void *dst,
70 size_t *destlen, int level);
71
72 lofi_compress_info_t lofi_compress_table[LOFI_COMPRESS_FUNCTIONS] = {
73 {NULL, gzip_compress, 6, "gzip"}, /* default */
74 {NULL, gzip_compress, 6, "gzip-6"},
75 {NULL, gzip_compress, 9, "gzip-9"}
76 };
77
78 #define FORMAT "%-20s %-30s %s\n"
79 #define NONE "-"
80 #define COMPRESS "Compressed"
81 #define COMPRESS_ALGORITHM "gzip"
82 #define COMPRESS_THRESHOLD 2048
83 #define SEGSIZE 131072
84 #define BLOCK_SIZE 512
85 #define KILOBYTE 1024
86 #define MEGABYTE (KILOBYTE * KILOBYTE)
87 #define GIGABYTE (KILOBYTE * MEGABYTE)
88 #define LIBZ "libz.so"
89
90 static int (*compress2p)(void *, ulong_t *, void *, size_t, int) = NULL;
91
92 static int gzip_compress(void *src, size_t srclen, void *dst,
93 size_t *dstlen, int level)
94 {
95 void *libz_hdl = NULL;
96
97 /*
98 * The first time we are called, attempt to dlopen()
99 * libz.so and get a pointer to the compress2() function
100 */
101 if (compress2p == NULL) {
102 if ((libz_hdl = openlib(LIBZ)) == NULL)
103 die(gettext("could not find %s. "
104 "gzip compression unavailable\n"), LIBZ);
105
106 if ((compress2p =
107 (int (*)(void *, ulong_t *, void *, size_t, int))
108 dlsym(libz_hdl, "compress2")) == NULL) {
109 closelib();
110 die(gettext("could not find the correct %s. "
111 "gzip compression unavailable\n"), LIBZ);
112 }
113 }
114
115 if ((*compress2p)(dst, (ulong_t *)dstlen, src, srclen, level) != 0)
116 return (-1);
117 return (0);
118 }
119
120 /*
121 * Print the list of all the mappings. Including a header.
122 */
123 static void
124 print_mappings(int fd)
125 {
126 struct lofi_ioctl li;
127 int minor;
128 int maxminor;
129 char path[MAXPATHLEN];
130 char options[MAXPATHLEN];
131
132 li.li_minor = 0;
133 if (ioctl(fd, LOFI_GET_MAXMINOR, &li) == -1) {
134 perror("ioctl");
135 exit(E_ERROR);
136 }
137
138 maxminor = li.li_minor;
139
140 (void) printf(FORMAT, "Block Device", "File", "Options");
141 for (minor = 1; minor <= maxminor; minor++) {
142 li.li_minor = minor;
143 if (ioctl(fd, LOFI_GET_FILENAME, &li) == -1) {
144 if (errno == ENXIO)
145 continue;
146 perror("ioctl");
147 break;
148 }
149 (void) snprintf(path, sizeof (path), "/dev/%s/%d",
150 LOFI_BLOCK_NAME, minor);
151 if (li.li_algorithm[0] == '\0')
152 (void) snprintf(options, sizeof (options), "%s", NONE);
153 else
154 (void) snprintf(options, sizeof (options),
155 COMPRESS "(%s)", li.li_algorithm);
156
157 (void) printf(FORMAT, path, li.li_filename, options);
158 }
159 }
160
161 static void
162 usage(void)
163 {
164 (void) fprintf(stderr, gettext(USAGE), pname, pname,
165 pname, pname, pname);
166 exit(E_USAGE);
167 }
168
169 /*
170 * Translate a lofi device name to a minor number. We might be asked
171 * to do this when there is no association (such as when the user specifies
172 * a particular device), so we can only look at the string.
173 */
174 static int
175 name_to_minor(const char *devicename)
176 {
177 int minor;
178
179 if (sscanf(devicename, "/dev/" LOFI_BLOCK_NAME "/%d", &minor) == 1) {
180 return (minor);
181 }
182 if (sscanf(devicename, "/dev/" LOFI_CHAR_NAME "/%d", &minor) == 1) {
183 return (minor);
184 }
185 return (0);
186 }
187
188 /*
189 * This might be the first time we've used this minor number. If so,
190 * it might also be that the /dev links are in the process of being created
191 * by devfsadmd (or that they'll be created "soon"). We cannot return
192 * until they're there or the invoker of lofiadm might try to use them
193 * and not find them. This can happen if a shell script is running on
194 * an MP.
195 */
196 static int sleeptime = 2; /* number of seconds to sleep between stat's */
197 static int maxsleep = 120; /* maximum number of seconds to sleep */
198
199 static void
200 wait_until_dev_complete(int minor)
201 {
202 struct stat64 buf;
203 int cursleep;
204 char blkpath[MAXPATHLEN];
205 char charpath[MAXPATHLEN];
206 di_devlink_handle_t hdl;
207
208
209 (void) snprintf(blkpath, sizeof (blkpath), "/dev/%s/%d",
210 LOFI_BLOCK_NAME, minor);
211 (void) snprintf(charpath, sizeof (charpath), "/dev/%s/%d",
212 LOFI_CHAR_NAME, minor);
213
214 /* Check if links already present */
215 if (stat64(blkpath, &buf) == 0 && stat64(charpath, &buf) == 0)
216 return;
217
218 /* First use di_devlink_init() */
219 if (hdl = di_devlink_init("lofi", DI_MAKE_LINK)) {
220 (void) di_devlink_fini(&hdl);
221 goto out;
222 }
223
224 /*
225 * Under normal conditions, di_devlink_init(DI_MAKE_LINK) above will
226 * only fail if the caller is non-root. In that case, wait for
227 * link creation via sysevents.
228 */
229 cursleep = 0;
230 while (cursleep < maxsleep) {
231 if ((stat64(blkpath, &buf) == -1) ||
232 (stat64(charpath, &buf) == -1)) {
233 (void) sleep(sleeptime);
234 cursleep += sleeptime;
235 continue;
236 }
237 return;
238 }
239
240 /* one last try */
241
242 out:
243 if (stat64(blkpath, &buf) == -1) {
244 die(gettext("%s was not created"), blkpath);
245 }
246 if (stat64(charpath, &buf) == -1) {
247 die(gettext("%s was not created"), charpath);
248 }
249 }
250
251 /*
252 * Add a device association. If devicename is NULL, let the driver
253 * pick a device.
254 */
255 static void
256 add_mapping(int lfd, const char *devicename, const char *filename,
257 int *minor_created, int suppress)
258 {
259 struct lofi_ioctl li;
260 int minor;
261
262 if (devicename == NULL) {
263 /* pick one */
264 li.li_minor = 0;
265 (void) strlcpy(li.li_filename, filename,
266 sizeof (li.li_filename));
267 minor = ioctl(lfd, LOFI_MAP_FILE, &li);
268 if (minor == -1) {
269 die(gettext("could not map file %s"), filename);
270 }
271 wait_until_dev_complete(minor);
272 /* print one picked */
273 if (!suppress)
274 (void) printf("/dev/%s/%d\n", LOFI_BLOCK_NAME, minor);
275
276 /* fill in the minor if needed */
277 if (minor_created != NULL) {
278 *minor_created = minor;
279 }
280 return;
281 }
282 /* use device we were given */
283 minor = name_to_minor(devicename);
284 if (minor == 0) {
285 die(gettext("malformed device name %s\n"), devicename);
286 }
287 (void) strlcpy(li.li_filename, filename, sizeof (li.li_filename));
288 li.li_minor = minor;
289 if (ioctl(lfd, LOFI_MAP_FILE_MINOR, &li) == -1) {
290 die(gettext("could not map file %s to %s"), filename,
291 devicename);
292 }
293 wait_until_dev_complete(minor);
294 }
295
296 /*
297 * Remove an association. Delete by device name if non-NULL, or by
298 * filename otherwise.
299 */
300 static void
301 delete_mapping(int lfd, const char *devicename, const char *filename,
302 boolean_t force)
303 {
304 struct lofi_ioctl li;
305
306 li.li_force = force;
307 if (devicename == NULL) {
308 /* delete by filename */
309 (void) strlcpy(li.li_filename, filename,
310 sizeof (li.li_filename));
311 li.li_minor = 0;
312 if (ioctl(lfd, LOFI_UNMAP_FILE, &li) == -1) {
313 die(gettext("could not unmap file %s"), filename);
314 }
315 return;
316 }
317 /* delete by device */
318
319 li.li_minor = name_to_minor(devicename);
320 if (li.li_minor == 0) {
321 die(gettext("malformed device name %s\n"), devicename);
322 }
323 if (ioctl(lfd, LOFI_UNMAP_FILE_MINOR, &li) == -1) {
324 die(gettext("could not unmap device %s"), devicename);
325 }
326 }
327
328 static void
329 print_one_mapping(int lfd, const char *devicename, const char *filename)
330 {
331 struct lofi_ioctl li;
332
333 if (devicename == NULL) {
334 /* given filename, print devicename */
335 li.li_minor = 0;
336 (void) strlcpy(li.li_filename, filename,
337 sizeof (li.li_filename));
338 if (ioctl(lfd, LOFI_GET_MINOR, &li) == -1) {
339 die(gettext("could not find device for %s"), filename);
340 }
341 (void) printf("/dev/%s/%d\n", LOFI_BLOCK_NAME, li.li_minor);
342 return;
343 }
344
345 /* given devicename, print filename */
346 li.li_minor = name_to_minor(devicename);
347 if (li.li_minor == 0) {
348 die(gettext("malformed device name %s\n"), devicename);
349 }
350 if (ioctl(lfd, LOFI_GET_FILENAME, &li) == -1) {
351 die(gettext("could not find filename for %s"), devicename);
352 }
353 (void) printf("%s\n", li.li_filename);
354 }
355
356 /*
357 * Uncompress a file.
358 *
359 * First map the file in to establish a device
360 * association, then read from it. On-the-fly
361 * decompression will automatically uncompress
362 * the file if it's compressed
363 *
364 * If the file is mapped and a device association
365 * has been established, disallow uncompressing
366 * the file until it is unmapped.
367 */
368 static void
369 lofi_uncompress(int lfd, const char *filename)
370 {
371 struct lofi_ioctl li;
372 char buf[MAXBSIZE];
373 char devicename[32];
374 char tmpfilename[MAXPATHLEN];
375 char *dir = NULL;
376 char *file = NULL;
377 int minor = 0;
378 struct stat64 statbuf;
379 int compfd = -1;
380 int uncompfd = -1;
381 ssize_t rbytes;
382
383 /*
384 * Disallow uncompressing the file if it is
385 * already mapped.
386 */
387 li.li_minor = 0;
388 (void) strlcpy(li.li_filename, filename, sizeof (li.li_filename));
389 if (ioctl(lfd, LOFI_GET_MINOR, &li) != -1)
390 die(gettext("%s must be unmapped before uncompressing"),
391 filename);
392
393 /* Zero length files don't need to be uncompressed */
394 if (stat64(filename, &statbuf) == -1)
395 die(gettext("stat: %s"), filename);
396 if (statbuf.st_size == 0)
397 return;
398
399 add_mapping(lfd, NULL, filename, &minor, 1);
400 (void) snprintf(devicename, sizeof (devicename), "/dev/%s/%d",
401 LOFI_BLOCK_NAME, minor);
402
403 /* If the file isn't compressed, we just return */
404 if ((ioctl(lfd, LOFI_CHECK_COMPRESSED, &li) == -1) ||
405 (li.li_algorithm == '\0')) {
406 delete_mapping(lfd, devicename, filename, B_TRUE);
407 return;
408 }
409
410 if ((compfd = open64(devicename, O_RDONLY | O_NONBLOCK)) == -1) {
411 delete_mapping(lfd, devicename, filename, B_TRUE);
412 die(gettext("open: %s"), filename);
413 }
414 /* Create a temp file in the same directory */
415 dir = strdup(filename);
416 dir = dirname(dir);
417 file = strdup(filename);
418 file = basename(file);
419 (void) snprintf(tmpfilename, sizeof (tmpfilename),
420 "%s/.%sXXXXXX", dir, file);
421
422 if ((uncompfd = mkstemp64(tmpfilename)) == -1) {
423 (void) close(compfd);
424 delete_mapping(lfd, devicename, filename, B_TRUE);
425 free(dir);
426 free(file);
427 return;
428 }
429
430 /*
431 * Set the mode bits and the owner of this temporary
432 * file to be that of the original uncompressed file
433 */
434 (void) fchmod(uncompfd, statbuf.st_mode);
435
436 if (fchown(uncompfd, statbuf.st_uid, statbuf.st_gid) == -1) {
437 (void) close(compfd);
438 (void) close(uncompfd);
439 delete_mapping(lfd, devicename, filename, B_TRUE);
440 free(dir);
441 free(file);
442 return;
443 }
444
445 /* Now read from the device in MAXBSIZE-sized chunks */
446 for (;;) {
447 rbytes = read(compfd, buf, sizeof (buf));
448
449 if (rbytes <= 0)
450 break;
451
452 if (write(uncompfd, buf, rbytes) != rbytes) {
453 rbytes = -1;
454 break;
455 }
456 }
457
458 (void) close(compfd);
459 (void) close(uncompfd);
460 free(dir);
461 free(file);
462
463 /* Delete the mapping */
464 delete_mapping(lfd, devicename, filename, B_TRUE);
465
466 /*
467 * If an error occured while reading or writing, rbytes will
468 * be negative
469 */
470 if (rbytes < 0) {
471 (void) unlink(tmpfilename);
472 die(gettext("could not read from %s"), filename);
473 }
474
475 /* Rename the temp file to the actual file */
476 if (rename(tmpfilename, filename) == -1)
477 (void) unlink(tmpfilename);
478 }
479
480 /*
481 * Compress a file
482 */
483 static void
484 lofi_compress(int lfd, const char *filename, int compress_index,
485 uint32_t segsize)
486 {
487 struct lofi_ioctl lic;
488 lofi_compress_info_t *li;
489 char tmpfilename[MAXPATHLEN];
490 char comp_filename[MAXPATHLEN];
491 char algorithm[MAXALGLEN];
492 char *dir = NULL, *file = NULL;
493 uchar_t *uncompressed_seg = NULL;
494 uchar_t *compressed_seg = NULL;
495 uint32_t compressed_segsize;
496 uint32_t len_compressed, count;
497 uint32_t index_entries, index_sz;
498 uint64_t *index = NULL;
499 uint64_t offset;
500 size_t real_segsize;
501 struct stat64 statbuf;
502 int compfd = -1, uncompfd = -1;
503 int tfd = -1;
504 ssize_t rbytes, wbytes, lastread;
505 int i, type;
506
507 /*
508 * Disallow compressing the file if it is
509 * already mapped
510 */
511 lic.li_minor = 0;
512 (void) strlcpy(lic.li_filename, filename, sizeof (lic.li_filename));
513 if (ioctl(lfd, LOFI_GET_MINOR, &lic) != -1)
514 die(gettext("%s must be unmapped before compressing"),
515 filename);
516
517 li = &lofi_compress_table[compress_index];
518
519 /*
520 * The size of the buffer to hold compressed data must
521 * be slightly larger than the compressed segment size.
522 *
523 * The compress functions use part of the buffer as
524 * scratch space to do calculations.
525 * Ref: http://www.zlib.net/manual.html#compress2
526 */
527 compressed_segsize = segsize + (segsize >> 6);
528 compressed_seg = (uchar_t *)malloc(compressed_segsize + SEGHDR);
529 uncompressed_seg = (uchar_t *)malloc(segsize);
530
531 if (compressed_seg == NULL || uncompressed_seg == NULL)
532 die(gettext("No memory"));
533
534 if ((uncompfd = open64(filename, O_RDONLY|O_LARGEFILE, 0)) == -1)
535 die(gettext("open: %s"), filename);
536
537 if (fstat64(uncompfd, &statbuf) == -1) {
538 (void) close(uncompfd);
539 die(gettext("fstat: %s"), filename);
540 }
541
542 /* Zero length files don't need to be compressed */
543 if (statbuf.st_size == 0) {
544 (void) close(uncompfd);
545 return;
546 }
547
548 /*
549 * Create temporary files in the same directory that
550 * will hold the intermediate data
551 */
552 dir = strdup(filename);
553 dir = dirname(dir);
554 file = strdup(filename);
555 file = basename(file);
556 (void) snprintf(tmpfilename, sizeof (tmpfilename),
557 "%s/.%sXXXXXX", dir, file);
558 (void) snprintf(comp_filename, sizeof (comp_filename),
559 "%s/.%sXXXXXX", dir, file);
560
561 if ((tfd = mkstemp64(tmpfilename)) == -1)
562 goto cleanup;
563
564 if ((compfd = mkstemp64(comp_filename)) == -1)
565 goto cleanup;
566
567 /*
568 * Set the mode bits and owner of the compressed
569 * file to be that of the original uncompressed file
570 */
571 (void) fchmod(compfd, statbuf.st_mode);
572
573 if (fchown(compfd, statbuf.st_uid, statbuf.st_gid) == -1)
574 goto cleanup;
575
576 /*
577 * Calculate the number of index entries required.
578 * index entries are stored as an array. adding
579 * a '2' here accounts for the fact that the last
580 * segment may not be a multiple of the segment size
581 */
582 index_sz = (statbuf.st_size / segsize) + 2;
583 index = malloc(sizeof (*index) * index_sz);
584
585 if (index == NULL)
586 goto cleanup;
587
588 offset = 0;
589 lastread = segsize;
590 count = 0;
591
592 /*
593 * Now read from the uncompressed file in 'segsize'
594 * sized chunks, compress what was read in and
595 * write it out to a temporary file
596 */
597 for (;;) {
598 rbytes = read(uncompfd, uncompressed_seg, segsize);
599
600 if (rbytes <= 0)
601 break;
602
603 if (lastread < segsize)
604 goto cleanup;
605
606 /*
607 * Account for the first byte that
608 * indicates whether a segment is
609 * compressed or not
610 */
611 real_segsize = segsize - 1;
612 (void) li->l_compress(uncompressed_seg, rbytes,
613 compressed_seg + SEGHDR, &real_segsize, li->l_level);
614
615 /*
616 * If the length of the compressed data is more
617 * than a threshold then there isn't any benefit
618 * to be had from compressing this segment - leave
619 * it uncompressed.
620 *
621 * NB. In case an error occurs during compression (above)
622 * the 'real_segsize' isn't changed. The logic below
623 * ensures that that segment is left uncompressed.
624 */
625 len_compressed = real_segsize;
626 if (real_segsize > segsize - COMPRESS_THRESHOLD) {
627 (void) memcpy(compressed_seg + SEGHDR, uncompressed_seg,
628 rbytes);
629 type = UNCOMPRESSED;
630 len_compressed = rbytes;
631 } else {
632 type = COMPRESSED;
633 }
634
635 /*
636 * Set the first byte or the SEGHDR to
637 * indicate if it's compressed or not
638 */
639 *compressed_seg = type;
640 wbytes = write(tfd, compressed_seg, len_compressed + SEGHDR);
641 if (wbytes != (len_compressed + SEGHDR)) {
642 rbytes = -1;
643 break;
644 }
645
646 index[count] = BE_64(offset);
647 offset += wbytes;
648 lastread = rbytes;
649 count++;
650 }
651
652 (void) close(uncompfd);
653
654 if (rbytes < 0)
655 goto cleanup;
656 /*
657 * The last index entry is a sentinel entry. It does not point to
658 * an actual compressed segment but helps in computing the size of
659 * the compressed segment. The size of each compressed segment is
660 * computed by subtracting the current index value from the next
661 * one (the compressed blocks are stored sequentially)
662 */
663 index[count++] = BE_64(offset);
664
665 /*
666 * Now write the compressed data along with the
667 * header information to this file which will
668 * later be renamed to the original uncompressed
669 * file name
670 *
671 * The header is as follows -
672 *
673 * Signature (name of the compression algorithm)
674 * Compression segment size (a multiple of 512)
675 * Number of index entries
676 * Size of the last block
677 * The array containing the index entries
678 *
679 * the header is always stored in network byte
680 * order
681 */
682 (void) bzero(algorithm, sizeof (algorithm));
683 (void) strlcpy(algorithm, li->l_name, sizeof (algorithm));
684 if (write(compfd, algorithm, sizeof (algorithm))
685 != sizeof (algorithm))
686 goto cleanup;
687
688 segsize = htonl(segsize);
689 if (write(compfd, &segsize, sizeof (segsize)) != sizeof (segsize))
690 goto cleanup;
691
692 index_entries = htonl(count);
693 if (write(compfd, &index_entries, sizeof (index_entries)) !=
694 sizeof (index_entries))
695 goto cleanup;
696
697 lastread = htonl(lastread);
698 if (write(compfd, &lastread, sizeof (lastread)) != sizeof (lastread))
699 goto cleanup;
700
701 for (i = 0; i < count; i++) {
702 if (write(compfd, index + i, sizeof (*index)) !=
703 sizeof (*index))
704 goto cleanup;
705 }
706
707 /* Header is written, now write the compressed data */
708 if (lseek(tfd, 0, SEEK_SET) != 0)
709 goto cleanup;
710
711 rbytes = wbytes = 0;
712
713 for (;;) {
714 rbytes = read(tfd, compressed_seg, compressed_segsize + SEGHDR);
715
716 if (rbytes <= 0)
717 break;
718
719 if (write(compfd, compressed_seg, rbytes) != rbytes)
720 goto cleanup;
721 }
722
723 if (fstat64(compfd, &statbuf) == -1)
724 goto cleanup;
725
726 /*
727 * Round up the compressed file size to be a multiple of
728 * DEV_BSIZE. lofi(7D) likes it that way.
729 */
730 if ((offset = statbuf.st_size % DEV_BSIZE) > 0) {
731
732 offset = DEV_BSIZE - offset;
733
734 for (i = 0; i < offset; i++)
735 uncompressed_seg[i] = '\0';
736 if (write(compfd, uncompressed_seg, offset) != offset)
737 goto cleanup;
738 }
739 (void) close(compfd);
740 (void) close(tfd);
741 (void) unlink(tmpfilename);
742 cleanup:
743 if (rbytes < 0) {
744 if (tfd != -1)
745 (void) unlink(tmpfilename);
746 if (compfd != -1)
747 (void) unlink(comp_filename);
748 die(gettext("error compressing file %s"), filename);
749 } else {
750 /* Rename the compressed file to the actual file */
751 if (rename(comp_filename, filename) == -1) {
752 (void) unlink(comp_filename);
753 die(gettext("error compressing file %s"), filename);
754 }
755 }
756 if (compressed_seg != NULL)
757 free(compressed_seg);
758 if (uncompressed_seg != NULL)
759 free(uncompressed_seg);
760 if (dir != NULL)
761 free(dir);
762 if (file != NULL)
763 free(file);
764 if (index != NULL)
765 free(index);
766 if (compfd != -1)
767 (void) close(compfd);
768 if (uncompfd != -1)
769 (void) close(uncompfd);
770 if (tfd != -1)
771 (void) close(tfd);
772 }
773
774 static int
775 lofi_compress_select(const char *algname)
776 {
777 int i;
778
779 for (i = 0; i < LOFI_COMPRESS_FUNCTIONS; i++) {
780 if (strcmp(lofi_compress_table[i].l_name, algname) == 0)
781 return (i);
782 }
783 return (-1);
784 }
785
786 static void
787 check_algorithm_validity(const char *algname, int *compress_index)
788 {
789 *compress_index = lofi_compress_select(algname);
790 if (*compress_index < 0)
791 die(gettext("invalid algorithm name: %s\n"), algname);
792 }
793
794 static void
795 check_file_validity(const char *filename)
796 {
797 struct stat64 buf;
798 int error;
799 int fd = -1;
800
801 fd = open64(filename, O_RDONLY);
802 if (fd == -1) {
803 die(gettext("open: %s"), filename);
804 }
805 error = fstat64(fd, &buf);
806 if (error == -1) {
807 die(gettext("fstat: %s"), filename);
808 } else if (!S_ISLOFIABLE(buf.st_mode)) {
809 die(gettext("%s is not a regular file, "
810 "block, or character device\n"),
811 filename);
812 } else if ((buf.st_size % DEV_BSIZE) != 0) {
813 die(gettext("size of %s is not a multiple "
814 "of %d\n"),
815 filename, DEV_BSIZE);
816 }
817 (void) close(fd);
818
819 if (name_to_minor(filename) != 0) {
820 die(gettext("cannot use " LOFI_DRIVER_NAME
821 " on itself\n"), NULL);
822 }
823 }
824
825 static uint32_t
826 convert_to_num(const char *str)
827 {
828 int len;
829 uint32_t segsize, mult = 1;
830
831 len = strlen(str);
832 if (len && isalpha(str[len - 1])) {
833 switch (str[len - 1]) {
834 case 'k':
835 case 'K':
836 mult = KILOBYTE;
837 break;
838 case 'b':
839 case 'B':
840 mult = BLOCK_SIZE;
841 break;
842 case 'm':
843 case 'M':
844 mult = MEGABYTE;
845 break;
846 case 'g':
847 case 'G':
848 mult = GIGABYTE;
849 break;
850 default:
851 die(gettext("invalid segment size %s\n"), str);
852 }
853 }
854
855 segsize = atol(str);
856 segsize *= mult;
857
858 return (segsize);
859 }
860
861 int
862 main(int argc, char *argv[])
863 {
864 int lfd;
865 int c;
866 const char *devicename = NULL;
867 const char *filename = NULL;
868 const char *algname = COMPRESS_ALGORITHM;
869 int openflag;
870 int minor;
871 int compress_index;
872 uint32_t segsize = SEGSIZE;
873 static char *lofictl = "/dev/" LOFI_CTL_NAME;
874 boolean_t force = B_FALSE;
875
876 pname = getpname(argv[0]);
877
878 (void) setlocale(LC_ALL, "");
879 (void) textdomain(TEXT_DOMAIN);
880
881 while ((c = getopt(argc, argv, "a:C:d:s:U:f")) != EOF) {
882 switch (c) {
883 case 'a':
884 addflag = 1;
885 filename = optarg;
886 check_file_validity(filename);
887
888 if (((argc - optind) > 0) && (*argv[optind] != '-')) {
889 /* optional device */
890 devicename = argv[optind];
891 optind++;
892 }
893 break;
894 case 'C':
895 compressflag = 1;
896
897 if (((argc - optind) > 0) &&
898 (*optarg == '-')) {
899 check_algorithm_validity(algname,
900 &compress_index);
901 optind--;
902 break;
903 } else if (((argc - optind) == 1) &&
904 (*argv[optind] != '-')) {
905 algname = optarg;
906 filename = argv[optind];
907 optind++;
908 } else if (((argc - optind) > 1) &&
909 (*argv[optind] == '-')) {
910 algname = optarg;
911 check_algorithm_validity(algname,
912 &compress_index);
913 break;
914 } else {
915 filename = optarg;
916 }
917
918 check_file_validity(filename);
919 check_algorithm_validity(algname, &compress_index);
920 break;
921 case 'd':
922 deleteflag = 1;
923
924 minor = name_to_minor(optarg);
925 if (minor != 0)
926 devicename = optarg;
927 else
928 filename = optarg;
929 break;
930 case 'f':
931 force = B_TRUE;
932 break;
933 case 's':
934 segsize = convert_to_num(optarg);
935
936 if (segsize == 0 || segsize % DEV_BSIZE)
937 die(gettext("segment size %s is invalid "
938 "or not a multiple of minimum block "
939 "size %ld\n"), optarg, DEV_BSIZE);
940
941 filename = argv[optind];
942 check_file_validity(filename);
943 optind++;
944 break;
945 case 'U':
946 uncompressflag = 1;
947 filename = optarg;
948 check_file_validity(filename);
949 break;
950 case '?':
951 default:
952 errflag = 1;
953 break;
954 }
955 }
956 if (errflag ||
957 (addflag && deleteflag) ||
958 ((compressflag || uncompressflag) && (addflag || deleteflag)))
959 usage();
960
961 switch (argc - optind) {
962 case 0: /* no more args */
963 break;
964 case 1: /* one arg without options means print the association */
965 if (addflag || deleteflag)
966 usage();
967 if (compressflag || uncompressflag)
968 usage();
969 minor = name_to_minor(argv[optind]);
970 if (minor != 0)
971 devicename = argv[optind];
972 else
973 filename = argv[optind];
974 break;
975 default:
976 usage();
977 break;
978 }
979
980 if (filename && !valid_abspath(filename))
981 exit(E_ERROR);
982
983 /*
984 * Here, we know the arguments are correct, the filename is an
985 * absolute path, it exists and is a regular file. We don't yet
986 * know that the device name is ok or not.
987 */
988 /*
989 * Now to the real work.
990 */
991 openflag = O_EXCL;
992 if (addflag || deleteflag || compressflag || uncompressflag)
993 openflag |= O_RDWR;
994 else
995 openflag |= O_RDONLY;
996 lfd = open(lofictl, openflag);
997 if (lfd == -1) {
998 if ((errno == EPERM) || (errno == EACCES)) {
999 die("you do not have permission to perform "
1000 "that operation.\n");
1001 } else {
1002 die("%s", lofictl);
1003 }
1004 /*NOTREACHED*/
1005 }
1006 if (addflag)
1007 add_mapping(lfd, devicename, filename, NULL, 0);
1008 else if (compressflag)
1009 lofi_compress(lfd, filename, compress_index, segsize);
1010 else if (uncompressflag)
1011 lofi_uncompress(lfd, filename);
1012 else if (deleteflag)
1013 delete_mapping(lfd, devicename, filename, force);
1014 else if (filename || devicename)
1015 print_one_mapping(lfd, devicename, filename);
1016 else
1017 print_mappings(lfd);
1018
1019 (void) close(lfd);
1020 closelib();
1021 return (E_SUCCESS);
1022 }