dosfstools  4.2
About: dosfstools are utilities to create, check and label (MS-DOS) FAT filesystems.
  Fossies Dox: dosfstools-4.2.tar.gz  ("unofficial" and yet experimental doxygen-generated source code documentation)  

io.c
Go to the documentation of this file.
1 /* io.c - Virtual disk input/output
2 
3  Copyright (C) 1993 Werner Almesberger <werner.almesberger@lrc.di.epfl.ch>
4  Copyright (C) 1998 Roman Hodek <Roman.Hodek@informatik.uni-erlangen.de>
5  Copyright (C) 2008-2014 Daniel Baumann <mail@daniel-baumann.ch>
6  Copyright (C) 2015 Andreas Bombe <aeb@debian.org>
7 
8  This program is free software: you can redistribute it and/or modify
9  it under the terms of the GNU General Public License as published by
10  the Free Software Foundation, either version 3 of the License, or
11  (at your option) any later version.
12 
13  This program is distributed in the hope that it will be useful,
14  but WITHOUT ANY WARRANTY; without even the implied warranty of
15  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16  GNU General Public License for more details.
17 
18  You should have received a copy of the GNU General Public License
19  along with this program. If not, see <http://www.gnu.org/licenses/>.
20 
21  The complete text of the GNU General Public License
22  can be found in /usr/share/common-licenses/GPL-3 file.
23 */
24 
25 /*
26  * Thu Feb 26 01:15:36 CET 1998: Martin Schulze <joey@infodrom.north.de>
27  * Fixed nasty bug that caused every file with a name like
28  * xxxxxxxx.xxx to be treated as bad name that needed to be fixed.
29  */
30 
31 /* FAT32, VFAT, Atari format support, and various fixes additions May 1998
32  * by Roman Hodek <Roman.Hodek@informatik.uni-erlangen.de> */
33 
34 #define _LARGEFILE64_SOURCE
35 #include <stdlib.h>
36 #include <stdio.h>
37 #include <string.h>
38 #include <unistd.h>
39 #include <sys/types.h>
40 #include <sys/stat.h>
41 #include <errno.h>
42 #include <fcntl.h>
43 
44 #include "fsck.fat.h"
45 #include "common.h"
46 #include "io.h"
47 
48 typedef struct _change {
49  void *data;
50  off_t pos;
51  int size;
52  struct _change *next;
54 
55 static CHANGE *changes, *last;
56 static int fd, did_change = 0;
57 
58 
59 void fs_open(const char *path, int rw)
60 {
61  if ((fd = open(path, rw ? O_RDWR : O_RDONLY)) < 0) {
62  perror("open");
63  exit(6);
64  }
65  changes = last = NULL;
66  did_change = 0;
67 }
68 
69 /**
70  * Read data from the partition, accounting for any pending updates that are
71  * queued for writing.
72  *
73  * @param[in] pos Byte offset, relative to the beginning of the partition,
74  * at which to read
75  * @param[in] size Number of bytes to read
76  * @param[out] data Where to put the data read
77  */
78 void fs_read(off_t pos, int size, void *data)
79 {
80  CHANGE *walk;
81  int got;
82 
83  if (lseek(fd, pos, 0) != pos)
84  pdie("Seek to %lld", (long long)pos);
85  if ((got = read(fd, data, size)) < 0)
86  pdie("Read %d bytes at %lld", size, (long long)pos);
87  if (got != size)
88  die("Got %d bytes instead of %d at %lld", got, size, (long long)pos);
89  for (walk = changes; walk; walk = walk->next) {
90  if (walk->pos < pos + size && walk->pos + walk->size > pos) {
91  if (walk->pos < pos)
92  memcpy(data, (char *)walk->data + pos - walk->pos,
93  min(size, walk->size - pos + walk->pos));
94  else
95  memcpy((char *)data + walk->pos - pos, walk->data,
96  min(walk->size, size + pos - walk->pos));
97  }
98  }
99 }
100 
101 int fs_test(off_t pos, int size)
102 {
103  void *scratch;
104  int okay;
105 
106  if (lseek(fd, pos, 0) != pos)
107  pdie("Seek to %lld", (long long)pos);
108  scratch = alloc(size);
109  okay = read(fd, scratch, size) == size;
110  free(scratch);
111  return okay;
112 }
113 
114 void fs_write(off_t pos, int size, void *data)
115 {
116  CHANGE *new;
117  int did;
118 
119  if (write_immed) {
120  did_change = 1;
121  if (lseek(fd, pos, 0) != pos)
122  pdie("Seek to %lld", (long long)pos);
123  if ((did = write(fd, data, size)) == size)
124  return;
125  if (did < 0)
126  pdie("Write %d bytes at %lld", size, (long long)pos);
127  die("Wrote %d bytes instead of %d at %lld", did, size, (long long)pos);
128  }
129  new = alloc(sizeof(CHANGE));
130  new->pos = pos;
131  memcpy(new->data = alloc(new->size = size), data, size);
132  new->next = NULL;
133  if (last)
134  last->next = new;
135  else
136  changes = new;
137  last = new;
138 }
139 
140 static void fs_flush(void)
141 {
142  CHANGE *this;
143  int size;
144 
145  while (changes) {
146  this = changes;
147  changes = changes->next;
148  if (lseek(fd, this->pos, 0) != this->pos)
149  fprintf(stderr,
150  "Seek to %lld failed: %s\n Did not write %d bytes.\n",
151  (long long)this->pos, strerror(errno), this->size);
152  else if ((size = write(fd, this->data, this->size)) < 0)
153  fprintf(stderr, "Writing %d bytes at %lld failed: %s\n", this->size,
154  (long long)this->pos, strerror(errno));
155  else if (size != this->size)
156  fprintf(stderr, "Wrote %d bytes instead of %d bytes at %lld."
157  "\n", size, this->size, (long long)this->pos);
158  free(this->data);
159  free(this);
160  }
161 }
162 
163 int fs_close(int write)
164 {
165  CHANGE *next;
166  int changed;
167 
168  changed = ! !changes;
169  if (write)
170  fs_flush();
171  else
172  while (changes) {
173  next = changes->next;
174  free(changes->data);
175  free(changes);
176  changes = next;
177  }
178  if (close(fd) < 0)
179  pdie("closing filesystem");
180  return changed || did_change;
181 }
182 
183 int fs_changed(void)
184 {
185  return ! !changes || did_change;
186 }
void pdie(const char *msg,...)
Definition: common.c:67
void die(const char *msg,...)
Definition: common.c:53
void * alloc(int size)
Definition: common.c:81
int write_immed
Definition: common.c:43
int min(int a, int b)
Definition: common.c:113
int rw
Definition: fatlabel.c:49
static CHANGE * last
Definition: io.c:55
int fs_changed(void)
Definition: io.c:183
static CHANGE * changes
Definition: io.c:55
struct _change CHANGE
int fs_close(int write)
Definition: io.c:163
int fs_test(off_t pos, int size)
Definition: io.c:101
static int fd
Definition: io.c:56
void fs_read(off_t pos, int size, void *data)
Definition: io.c:78
void fs_write(off_t pos, int size, void *data)
Definition: io.c:114
void fs_open(const char *path, int rw)
Definition: io.c:59
static int did_change
Definition: io.c:56
static void fs_flush(void)
Definition: io.c:140
Definition: io.c:48
int size
Definition: io.c:51
off_t pos
Definition: io.c:50
struct _change * next
Definition: io.c:52
void * data
Definition: io.c:49