diff options
Diffstat (limited to 'fs/fat/misc.c')
-rw-r--r-- | fs/fat/misc.c | 225 |
1 files changed, 225 insertions, 0 deletions
diff --git a/fs/fat/misc.c b/fs/fat/misc.c new file mode 100644 index 000000000000..2a0df2122f5d --- /dev/null +++ b/fs/fat/misc.c | |||
@@ -0,0 +1,225 @@ | |||
1 | /* | ||
2 | * linux/fs/fat/misc.c | ||
3 | * | ||
4 | * Written 1992,1993 by Werner Almesberger | ||
5 | * 22/11/2000 - Fixed fat_date_unix2dos for dates earlier than 01/01/1980 | ||
6 | * and date_dos2unix for date==0 by Igor Zhbanov(bsg@uniyar.ac.ru) | ||
7 | */ | ||
8 | |||
9 | #include <linux/module.h> | ||
10 | #include <linux/fs.h> | ||
11 | #include <linux/msdos_fs.h> | ||
12 | #include <linux/buffer_head.h> | ||
13 | |||
14 | /* | ||
15 | * fat_fs_panic reports a severe file system problem and sets the file system | ||
16 | * read-only. The file system can be made writable again by remounting it. | ||
17 | */ | ||
18 | void fat_fs_panic(struct super_block *s, const char *fmt, ...) | ||
19 | { | ||
20 | va_list args; | ||
21 | |||
22 | printk(KERN_ERR "FAT: Filesystem panic (dev %s)\n", s->s_id); | ||
23 | |||
24 | printk(KERN_ERR " "); | ||
25 | va_start(args, fmt); | ||
26 | vprintk(fmt, args); | ||
27 | va_end(args); | ||
28 | printk("\n"); | ||
29 | |||
30 | if (!(s->s_flags & MS_RDONLY)) { | ||
31 | s->s_flags |= MS_RDONLY; | ||
32 | printk(KERN_ERR " File system has been set read-only\n"); | ||
33 | } | ||
34 | } | ||
35 | |||
36 | EXPORT_SYMBOL(fat_fs_panic); | ||
37 | |||
38 | /* Flushes the number of free clusters on FAT32 */ | ||
39 | /* XXX: Need to write one per FSINFO block. Currently only writes 1 */ | ||
40 | void fat_clusters_flush(struct super_block *sb) | ||
41 | { | ||
42 | struct msdos_sb_info *sbi = MSDOS_SB(sb); | ||
43 | struct buffer_head *bh; | ||
44 | struct fat_boot_fsinfo *fsinfo; | ||
45 | |||
46 | if (sbi->fat_bits != 32) | ||
47 | return; | ||
48 | |||
49 | bh = sb_bread(sb, sbi->fsinfo_sector); | ||
50 | if (bh == NULL) { | ||
51 | printk(KERN_ERR "FAT: bread failed in fat_clusters_flush\n"); | ||
52 | return; | ||
53 | } | ||
54 | |||
55 | fsinfo = (struct fat_boot_fsinfo *)bh->b_data; | ||
56 | /* Sanity check */ | ||
57 | if (!IS_FSINFO(fsinfo)) { | ||
58 | printk(KERN_ERR "FAT: Did not find valid FSINFO signature.\n" | ||
59 | " Found signature1 0x%08x signature2 0x%08x" | ||
60 | " (sector = %lu)\n", | ||
61 | le32_to_cpu(fsinfo->signature1), | ||
62 | le32_to_cpu(fsinfo->signature2), | ||
63 | sbi->fsinfo_sector); | ||
64 | } else { | ||
65 | if (sbi->free_clusters != -1) | ||
66 | fsinfo->free_clusters = cpu_to_le32(sbi->free_clusters); | ||
67 | if (sbi->prev_free != -1) | ||
68 | fsinfo->next_cluster = cpu_to_le32(sbi->prev_free); | ||
69 | mark_buffer_dirty(bh); | ||
70 | if (sb->s_flags & MS_SYNCHRONOUS) | ||
71 | sync_dirty_buffer(bh); | ||
72 | } | ||
73 | brelse(bh); | ||
74 | } | ||
75 | |||
76 | /* | ||
77 | * fat_chain_add() adds a new cluster to the chain of clusters represented | ||
78 | * by inode. | ||
79 | */ | ||
80 | int fat_chain_add(struct inode *inode, int new_dclus, int nr_cluster) | ||
81 | { | ||
82 | struct super_block *sb = inode->i_sb; | ||
83 | struct msdos_sb_info *sbi = MSDOS_SB(sb); | ||
84 | int ret, new_fclus, last; | ||
85 | |||
86 | /* | ||
87 | * We must locate the last cluster of the file to add this new | ||
88 | * one (new_dclus) to the end of the link list (the FAT). | ||
89 | */ | ||
90 | last = new_fclus = 0; | ||
91 | if (MSDOS_I(inode)->i_start) { | ||
92 | int fclus, dclus; | ||
93 | |||
94 | ret = fat_get_cluster(inode, FAT_ENT_EOF, &fclus, &dclus); | ||
95 | if (ret < 0) | ||
96 | return ret; | ||
97 | new_fclus = fclus + 1; | ||
98 | last = dclus; | ||
99 | } | ||
100 | |||
101 | /* add new one to the last of the cluster chain */ | ||
102 | if (last) { | ||
103 | struct fat_entry fatent; | ||
104 | |||
105 | fatent_init(&fatent); | ||
106 | ret = fat_ent_read(inode, &fatent, last); | ||
107 | if (ret >= 0) { | ||
108 | int wait = inode_needs_sync(inode); | ||
109 | ret = fat_ent_write(inode, &fatent, new_dclus, wait); | ||
110 | fatent_brelse(&fatent); | ||
111 | } | ||
112 | if (ret < 0) | ||
113 | return ret; | ||
114 | // fat_cache_add(inode, new_fclus, new_dclus); | ||
115 | } else { | ||
116 | MSDOS_I(inode)->i_start = new_dclus; | ||
117 | MSDOS_I(inode)->i_logstart = new_dclus; | ||
118 | /* | ||
119 | * Since generic_osync_inode() synchronize later if | ||
120 | * this is not directory, we don't here. | ||
121 | */ | ||
122 | if (S_ISDIR(inode->i_mode) && IS_DIRSYNC(inode)) { | ||
123 | ret = fat_sync_inode(inode); | ||
124 | if (ret) | ||
125 | return ret; | ||
126 | } else | ||
127 | mark_inode_dirty(inode); | ||
128 | } | ||
129 | if (new_fclus != (inode->i_blocks >> (sbi->cluster_bits - 9))) { | ||
130 | fat_fs_panic(sb, "clusters badly computed (%d != %lu)", | ||
131 | new_fclus, inode->i_blocks >> (sbi->cluster_bits - 9)); | ||
132 | fat_cache_inval_inode(inode); | ||
133 | } | ||
134 | inode->i_blocks += nr_cluster << (sbi->cluster_bits - 9); | ||
135 | |||
136 | return 0; | ||
137 | } | ||
138 | |||
139 | extern struct timezone sys_tz; | ||
140 | |||
141 | /* Linear day numbers of the respective 1sts in non-leap years. */ | ||
142 | static int day_n[] = { | ||
143 | /* Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec */ | ||
144 | 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 0, 0, 0, 0 | ||
145 | }; | ||
146 | |||
147 | /* Convert a MS-DOS time/date pair to a UNIX date (seconds since 1 1 70). */ | ||
148 | int date_dos2unix(unsigned short time, unsigned short date) | ||
149 | { | ||
150 | int month, year, secs; | ||
151 | |||
152 | /* | ||
153 | * first subtract and mask after that... Otherwise, if | ||
154 | * date == 0, bad things happen | ||
155 | */ | ||
156 | month = ((date >> 5) - 1) & 15; | ||
157 | year = date >> 9; | ||
158 | secs = (time & 31)*2+60*((time >> 5) & 63)+(time >> 11)*3600+86400* | ||
159 | ((date & 31)-1+day_n[month]+(year/4)+year*365-((year & 3) == 0 && | ||
160 | month < 2 ? 1 : 0)+3653); | ||
161 | /* days since 1.1.70 plus 80's leap day */ | ||
162 | secs += sys_tz.tz_minuteswest*60; | ||
163 | return secs; | ||
164 | } | ||
165 | |||
166 | /* Convert linear UNIX date to a MS-DOS time/date pair. */ | ||
167 | void fat_date_unix2dos(int unix_date, __le16 *time, __le16 *date) | ||
168 | { | ||
169 | int day, year, nl_day, month; | ||
170 | |||
171 | unix_date -= sys_tz.tz_minuteswest*60; | ||
172 | |||
173 | /* Jan 1 GMT 00:00:00 1980. But what about another time zone? */ | ||
174 | if (unix_date < 315532800) | ||
175 | unix_date = 315532800; | ||
176 | |||
177 | *time = cpu_to_le16((unix_date % 60)/2+(((unix_date/60) % 60) << 5)+ | ||
178 | (((unix_date/3600) % 24) << 11)); | ||
179 | day = unix_date/86400-3652; | ||
180 | year = day/365; | ||
181 | if ((year+3)/4+365*year > day) | ||
182 | year--; | ||
183 | day -= (year+3)/4+365*year; | ||
184 | if (day == 59 && !(year & 3)) { | ||
185 | nl_day = day; | ||
186 | month = 2; | ||
187 | } else { | ||
188 | nl_day = (year & 3) || day <= 59 ? day : day-1; | ||
189 | for (month = 0; month < 12; month++) { | ||
190 | if (day_n[month] > nl_day) | ||
191 | break; | ||
192 | } | ||
193 | } | ||
194 | *date = cpu_to_le16(nl_day-day_n[month-1]+1+(month << 5)+(year << 9)); | ||
195 | } | ||
196 | |||
197 | EXPORT_SYMBOL(fat_date_unix2dos); | ||
198 | |||
199 | int fat_sync_bhs(struct buffer_head **bhs, int nr_bhs) | ||
200 | { | ||
201 | int i, e, err = 0; | ||
202 | |||
203 | for (i = 0; i < nr_bhs; i++) { | ||
204 | lock_buffer(bhs[i]); | ||
205 | if (test_clear_buffer_dirty(bhs[i])) { | ||
206 | get_bh(bhs[i]); | ||
207 | bhs[i]->b_end_io = end_buffer_write_sync; | ||
208 | e = submit_bh(WRITE, bhs[i]); | ||
209 | if (!err && e) | ||
210 | err = e; | ||
211 | } else | ||
212 | unlock_buffer(bhs[i]); | ||
213 | } | ||
214 | for (i = 0; i < nr_bhs; i++) { | ||
215 | wait_on_buffer(bhs[i]); | ||
216 | if (buffer_eopnotsupp(bhs[i])) { | ||
217 | clear_buffer_eopnotsupp(bhs[i]); | ||
218 | err = -EOPNOTSUPP; | ||
219 | } else if (!err && !buffer_uptodate(bhs[i])) | ||
220 | err = -EIO; | ||
221 | } | ||
222 | return err; | ||
223 | } | ||
224 | |||
225 | EXPORT_SYMBOL(fat_sync_bhs); | ||