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