sysctl.3: Adjust for pageout daemon algo changes from last year.
[dragonfly.git] / bin / dd / position.c
1 /*-
2  * SPDX-License-Identifier: BSD-3-Clause
3  *
4  * Copyright (c) 1991, 1993, 1994
5  *      The Regents of the University of California.  All rights reserved.
6  *
7  * This code is derived from software contributed to Berkeley by
8  * Keith Muller of the University of California, San Diego and Lance
9  * Visser of Convex Computer Corporation.
10  *
11  * Redistribution and use in source and binary forms, with or without
12  * modification, are permitted provided that the following conditions
13  * are met:
14  * 1. Redistributions of source code must retain the above copyright
15  *    notice, this list of conditions and the following disclaimer.
16  * 2. Redistributions in binary form must reproduce the above copyright
17  *    notice, this list of conditions and the following disclaimer in the
18  *    documentation and/or other materials provided with the distribution.
19  * 3. Neither the name of the University nor the names of its contributors
20  *    may be used to endorse or promote products derived from this software
21  *    without specific prior written permission.
22  *
23  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33  * SUCH DAMAGE.
34  *
35  * @(#)position.c       8.3 (Berkeley) 4/2/94
36  * $FreeBSD: head/bin/dd/position.c 337865 2018-08-15 19:46:13Z kevans $
37  */
38
39 #include <sys/types.h>
40 #include <sys/mtio.h>
41
42 #include <err.h>
43 #include <errno.h>
44 #include <limits.h>
45 #include <unistd.h>
46
47 #include "dd.h"
48 #include "extern.h"
49
50 static off_t seek_offset(IO *);
51
52 static off_t
53 seek_offset(IO *io)
54 {
55         off_t n;
56         size_t sz;
57
58         n = io->offset;
59         sz = io->dbsz;
60
61         _Static_assert(sizeof(io->offset) == sizeof(int64_t), "64-bit off_t");
62
63         /*
64          * If the lseek offset will be negative, verify that this is a special
65          * device file.  Some such files (e.g. /dev/kmem) permit "negative"
66          * offsets.
67          *
68          * Bail out if the calculation of a file offset would overflow.
69          */
70         if ((io->flags & ISCHR) == 0 && (n < 0 || n > OFF_MAX / (ssize_t)sz))
71                 errx(1, "seek offsets cannot be larger than %jd",
72                     (intmax_t)OFF_MAX);
73         else if ((io->flags & ISCHR) != 0 && (uint64_t)n > UINT64_MAX / sz)
74                 errx(1, "seek offsets cannot be larger than %ju",
75                     (uintmax_t)UINT64_MAX);
76
77         return ((off_t)( (uint64_t)n * sz ));
78 }
79
80 /*
81  * Position input/output data streams before starting the copy.  Device type
82  * dependent.  Seekable devices use lseek, and the rest position by reading.
83  * Seeking past the end of file can cause null blocks to be written to the
84  * output.
85  */
86 void
87 pos_in(void)
88 {
89         off_t cnt;
90         int warned;
91         ssize_t nr;
92         size_t bcnt;
93
94         /* If known to be seekable, try to seek on it. */
95         if (in.flags & ISSEEK) {
96                 errno = 0;
97                 if (lseek(in.fd, seek_offset(&in), SEEK_CUR) == -1 &&
98                     errno != 0)
99                         err(1, "%s", in.name);
100                 return;
101         }
102
103         /* Don't try to read a really weird amount (like negative). */
104         if (in.offset < 0)
105                 errx(1, "%s: illegal offset", "iseek/skip");
106
107         /*
108          * Read the data.  If a pipe, read until satisfy the number of bytes
109          * being skipped.  No differentiation for reading complete and partial
110          * blocks for other devices.
111          */
112         for (bcnt = in.dbsz, cnt = in.offset, warned = 0; cnt;) {
113                 if ((nr = read(in.fd, in.db, bcnt)) > 0) {
114                         if (in.flags & ISPIPE) {
115                                 if (!(bcnt -= nr)) {
116                                         bcnt = in.dbsz;
117                                         --cnt;
118                                 }
119                         } else {
120                                 --cnt;
121                         }
122                         if (need_summary)
123                                 summary();
124                         if (need_progress)
125                                 progress();
126                         continue;
127                 }
128
129                 if (nr == 0) {
130                         if (files_cnt > 1) {
131                                 --files_cnt;
132                                 continue;
133                         }
134                         errx(1, "skip reached end of input");
135                 }
136
137                 /*
138                  * Input error -- either EOF with no more files, or I/O error.
139                  * If noerror not set die.  POSIX requires that the warning
140                  * message be followed by an I/O display.
141                  */
142                 if (ddflags & C_NOERROR) {
143                         if (!warned) {
144                                 warn("%s", in.name);
145                                 warned = 1;
146                                 summary();
147                         }
148                         continue;
149                 }
150                 err(1, "%s", in.name);
151         }
152 }
153
154 void
155 pos_out(void)
156 {
157         struct mtop t_op;
158         off_t cnt;
159         ssize_t n;
160
161         /*
162          * If not a tape, try seeking on the file.  Seeking on a pipe is
163          * going to fail, but don't protect the user -- they shouldn't
164          * have specified the seek operand.
165          */
166         if (out.flags & (ISSEEK | ISPIPE)) {
167                 errno = 0;
168                 if (lseek(out.fd, seek_offset(&out), SEEK_CUR) == -1 &&
169                     errno != 0)
170                         err(1, "%s", out.name);
171                 return;
172         }
173
174         /* Don't try to read a really weird amount (like negative). */
175         if (out.offset < 0)
176                 errx(1, "%s: illegal offset", "oseek/seek");
177
178         /* If no read access, try using mtio. */
179         if (out.flags & NOREAD) {
180                 t_op.mt_op = MTFSR;
181                 t_op.mt_count = out.offset;
182
183                 if (ioctl(out.fd, MTIOCTOP, &t_op) == -1)
184                         err(1, "%s", out.name);
185                 return;
186         }
187
188         /* Read it. */
189         for (cnt = 0; cnt < out.offset; ++cnt) {
190                 if ((n = read(out.fd, out.db, out.dbsz)) > 0)
191                         continue;
192
193                 if (n == -1)
194                         err(1, "%s", out.name);
195
196                 /*
197                  * If reach EOF, fill with NUL characters; first, back up over
198                  * the EOF mark.  Note, cnt has not yet been incremented, so
199                  * the EOF read does not count as a seek'd block.
200                  */
201                 t_op.mt_op = MTBSR;
202                 t_op.mt_count = 1;
203                 if (ioctl(out.fd, MTIOCTOP, &t_op) == -1)
204                         err(1, "%s", out.name);
205
206                 while (cnt++ < out.offset) {
207                         n = write(out.fd, out.db, out.dbsz);
208                         if (n == -1)
209                                 err(1, "%s", out.name);
210                         if (n != out.dbsz)
211                                 errx(1, "%s: write failure", out.name);
212                 }
213                 break;
214         }
215 }