aboutsummaryrefslogtreecommitdiffstats
path: root/fs/fat/misc.c
diff options
context:
space:
mode:
Diffstat (limited to 'fs/fat/misc.c')
-rw-r--r--fs/fat/misc.c225
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 */
18void 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
36EXPORT_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 */
40void 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 */
80int 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
139extern struct timezone sys_tz;
140
141/* Linear day numbers of the respective 1sts in non-leap years. */
142static 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). */
148int 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. */
167void 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
197EXPORT_SYMBOL(fat_date_unix2dos);
198
199int 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
225EXPORT_SYMBOL(fat_sync_bhs);