Commit | Line | Data |
---|---|---|
772b29cc NJ |
1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* | |
3 | * Written 1992,1993 by Werner Almesberger | |
4 | * 22/11/2000 - Fixed fat_date_unix2dos for dates earlier than 01/01/1980 | |
5 | * and date_dos2unix for date==0 by Igor Zhbanov(bsg@uniyar.ac.ru) | |
6 | * Copyright (C) 2012-2013 Samsung Electronics Co., Ltd. | |
7 | */ | |
8 | ||
9 | #include <linux/time.h> | |
10 | #include <linux/fs.h> | |
11 | #include <linux/slab.h> | |
12 | #include <linux/buffer_head.h> | |
13 | ||
14 | #include "exfat_raw.h" | |
15 | #include "exfat_fs.h" | |
16 | ||
17 | /* | |
18 | * exfat_fs_error reports a file system problem that might indicate fa data | |
19 | * corruption/inconsistency. Depending on 'errors' mount option the | |
20 | * panic() is called, or error message is printed FAT and nothing is done, | |
21 | * or filesystem is remounted read-only (default behavior). | |
22 | * In case the file system is remounted read-only, it can be made writable | |
23 | * again by remounting it. | |
24 | */ | |
25 | void __exfat_fs_error(struct super_block *sb, int report, const char *fmt, ...) | |
26 | { | |
27 | struct exfat_mount_options *opts = &EXFAT_SB(sb)->options; | |
28 | va_list args; | |
29 | struct va_format vaf; | |
30 | ||
31 | if (report) { | |
32 | va_start(args, fmt); | |
33 | vaf.fmt = fmt; | |
34 | vaf.va = &args; | |
d1727d55 | 35 | exfat_err(sb, "error, %pV", &vaf); |
772b29cc NJ |
36 | va_end(args); |
37 | } | |
38 | ||
39 | if (opts->errors == EXFAT_ERRORS_PANIC) { | |
40 | panic("exFAT-fs (%s): fs panic from previous error\n", | |
41 | sb->s_id); | |
42 | } else if (opts->errors == EXFAT_ERRORS_RO && !sb_rdonly(sb)) { | |
43 | sb->s_flags |= SB_RDONLY; | |
d1727d55 | 44 | exfat_err(sb, "Filesystem has been set read-only"); |
772b29cc NJ |
45 | } |
46 | } | |
47 | ||
48 | /* | |
49 | * exfat_msg() - print preformated EXFAT specific messages. | |
50 | * All logs except what uses exfat_fs_error() should be written by exfat_msg() | |
51 | */ | |
52 | void exfat_msg(struct super_block *sb, const char *level, const char *fmt, ...) | |
53 | { | |
54 | struct va_format vaf; | |
55 | va_list args; | |
56 | ||
57 | va_start(args, fmt); | |
58 | vaf.fmt = fmt; | |
59 | vaf.va = &args; | |
60 | /* level means KERN_ pacility level */ | |
61 | printk("%sexFAT-fs (%s): %pV\n", level, sb->s_id, &vaf); | |
62 | va_end(args); | |
63 | } | |
64 | ||
65 | #define SECS_PER_MIN (60) | |
66 | #define TIMEZONE_SEC(x) ((x) * 15 * SECS_PER_MIN) | |
67 | ||
68 | static void exfat_adjust_tz(struct timespec64 *ts, u8 tz_off) | |
69 | { | |
70 | if (tz_off <= 0x3F) | |
71 | ts->tv_sec -= TIMEZONE_SEC(tz_off); | |
72 | else /* 0x40 <= (tz_off & 0x7F) <=0x7F */ | |
73 | ts->tv_sec += TIMEZONE_SEC(0x80 - tz_off); | |
74 | } | |
75 | ||
76 | /* Convert a EXFAT time/date pair to a UNIX date (seconds since 1 1 70). */ | |
77 | void exfat_get_entry_time(struct exfat_sb_info *sbi, struct timespec64 *ts, | |
ed0f84d3 | 78 | u8 tz, __le16 time, __le16 date, u8 time_cs) |
772b29cc NJ |
79 | { |
80 | u16 t = le16_to_cpu(time); | |
81 | u16 d = le16_to_cpu(date); | |
82 | ||
83 | ts->tv_sec = mktime64(1980 + (d >> 9), d >> 5 & 0x000F, d & 0x001F, | |
84 | t >> 11, (t >> 5) & 0x003F, (t & 0x001F) << 1); | |
85 | ||
86 | ||
ed0f84d3 TK |
87 | /* time_cs field represent 0 ~ 199cs(1990 ms) */ |
88 | if (time_cs) { | |
89 | ts->tv_sec += time_cs / 100; | |
90 | ts->tv_nsec = (time_cs % 100) * 10 * NSEC_PER_MSEC; | |
81df1ad4 ES |
91 | } else |
92 | ts->tv_nsec = 0; | |
772b29cc NJ |
93 | |
94 | if (tz & EXFAT_TZ_VALID) | |
95 | /* Adjust timezone to UTC0. */ | |
96 | exfat_adjust_tz(ts, tz & ~EXFAT_TZ_VALID); | |
97 | else | |
98 | /* Convert from local time to UTC using time_offset. */ | |
99 | ts->tv_sec -= sbi->options.time_offset * SECS_PER_MIN; | |
100 | } | |
101 | ||
102 | /* Convert linear UNIX date to a EXFAT time/date pair. */ | |
103 | void exfat_set_entry_time(struct exfat_sb_info *sbi, struct timespec64 *ts, | |
ed0f84d3 | 104 | u8 *tz, __le16 *time, __le16 *date, u8 *time_cs) |
772b29cc NJ |
105 | { |
106 | struct tm tm; | |
107 | u16 t, d; | |
108 | ||
109 | time64_to_tm(ts->tv_sec, 0, &tm); | |
110 | t = (tm.tm_hour << 11) | (tm.tm_min << 5) | (tm.tm_sec >> 1); | |
111 | d = ((tm.tm_year - 80) << 9) | ((tm.tm_mon + 1) << 5) | tm.tm_mday; | |
112 | ||
113 | *time = cpu_to_le16(t); | |
114 | *date = cpu_to_le16(d); | |
115 | ||
ed0f84d3 TK |
116 | /* time_cs field represent 0 ~ 199cs(1990 ms) */ |
117 | if (time_cs) | |
118 | *time_cs = (tm.tm_sec & 1) * 100 + | |
772b29cc NJ |
119 | ts->tv_nsec / (10 * NSEC_PER_MSEC); |
120 | ||
121 | /* | |
122 | * Record 00h value for OffsetFromUtc field and 1 value for OffsetValid | |
123 | * to indicate that local time and UTC are the same. | |
124 | */ | |
125 | *tz = EXFAT_TZ_VALID; | |
126 | } | |
127 | ||
81df1ad4 ES |
128 | /* |
129 | * The timestamp for access_time has double seconds granularity. | |
130 | * (There is no 10msIncrement field for access_time unlike create/modify_time) | |
131 | * atime also has only a 2-second resolution. | |
132 | */ | |
133 | void exfat_truncate_atime(struct timespec64 *ts) | |
134 | { | |
135 | ts->tv_sec = round_down(ts->tv_sec, 2); | |
136 | ts->tv_nsec = 0; | |
137 | } | |
138 | ||
5875bf28 | 139 | u16 exfat_calc_chksum16(void *data, int len, u16 chksum, int type) |
772b29cc NJ |
140 | { |
141 | int i; | |
5875bf28 | 142 | u8 *c = (u8 *)data; |
772b29cc NJ |
143 | |
144 | for (i = 0; i < len; i++, c++) { | |
5875bf28 | 145 | if (unlikely(type == CS_DIR_ENTRY && (i == 2 || i == 3))) |
772b29cc | 146 | continue; |
5875bf28 | 147 | chksum = ((chksum << 15) | (chksum >> 1)) + *c; |
772b29cc NJ |
148 | } |
149 | return chksum; | |
150 | } | |
151 | ||
476189c0 TK |
152 | u32 exfat_calc_chksum32(void *data, int len, u32 chksum, int type) |
153 | { | |
154 | int i; | |
155 | u8 *c = (u8 *)data; | |
156 | ||
157 | for (i = 0; i < len; i++, c++) { | |
158 | if (unlikely(type == CS_BOOT_SECTOR && | |
159 | (i == 106 || i == 107 || i == 112))) | |
160 | continue; | |
161 | chksum = ((chksum << 31) | (chksum >> 1)) + *c; | |
162 | } | |
163 | return chksum; | |
164 | } | |
165 | ||
2c7f8937 | 166 | void exfat_update_bh(struct buffer_head *bh, int sync) |
772b29cc | 167 | { |
772b29cc NJ |
168 | set_buffer_uptodate(bh); |
169 | mark_buffer_dirty(bh); | |
170 | ||
171 | if (sync) | |
172 | sync_dirty_buffer(bh); | |
173 | } | |
174 | ||
3db3c3fb TK |
175 | int exfat_update_bhs(struct buffer_head **bhs, int nr_bhs, int sync) |
176 | { | |
177 | int i, err = 0; | |
178 | ||
179 | for (i = 0; i < nr_bhs; i++) { | |
180 | set_buffer_uptodate(bhs[i]); | |
181 | mark_buffer_dirty(bhs[i]); | |
182 | if (sync) | |
183 | write_dirty_buffer(bhs[i], 0); | |
184 | } | |
185 | ||
186 | for (i = 0; i < nr_bhs && sync; i++) { | |
187 | wait_on_buffer(bhs[i]); | |
188 | if (!err && !buffer_uptodate(bhs[i])) | |
189 | err = -EIO; | |
190 | } | |
191 | return err; | |
192 | } | |
193 | ||
772b29cc NJ |
194 | void exfat_chain_set(struct exfat_chain *ec, unsigned int dir, |
195 | unsigned int size, unsigned char flags) | |
196 | { | |
197 | ec->dir = dir; | |
198 | ec->size = size; | |
199 | ec->flags = flags; | |
200 | } | |
201 | ||
202 | void exfat_chain_dup(struct exfat_chain *dup, struct exfat_chain *ec) | |
203 | { | |
204 | return exfat_chain_set(dup, ec->dir, ec->size, ec->flags); | |
205 | } |