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
129u16 exfat_calc_chksum16(void *data, int len, u16 chksum, int type)
130{
131	int i;
132	u8 *c = (u8 *)data;
133
134	for (i = 0; i < len; i++, c++) {
135		if (unlikely(type == CS_DIR_ENTRY && (i == 2 || i == 3)))
136			continue;
137		chksum = ((chksum << 15) | (chksum >> 1)) + *c;
138	}
139	return chksum;
140}
141
142u32 exfat_calc_chksum32(void *data, int len, u32 chksum, int type)
143{
144	int i;
145	u8 *c = (u8 *)data;
146
147	for (i = 0; i < len; i++, c++) {
148		if (unlikely(type == CS_BOOT_SECTOR &&
149			     (i == 106 || i == 107 || i == 112)))
150			continue;
151		chksum = ((chksum << 31) | (chksum >> 1)) + *c;
152	}
153	return chksum;
154}
155
156void exfat_update_bh(struct buffer_head *bh, int sync)
157{
158	set_buffer_uptodate(bh);
159	mark_buffer_dirty(bh);
160
161	if (sync)
162		sync_dirty_buffer(bh);
163}
164
165int exfat_update_bhs(struct buffer_head **bhs, int nr_bhs, int sync)
166{
167	int i, err = 0;
168
169	for (i = 0; i < nr_bhs; i++) {
170		set_buffer_uptodate(bhs[i]);
171		mark_buffer_dirty(bhs[i]);
172		if (sync)
173			write_dirty_buffer(bhs[i], REQ_SYNC);
174	}
175
176	for (i = 0; i < nr_bhs && sync; i++) {
177		wait_on_buffer(bhs[i]);
178		if (!err && !buffer_uptodate(bhs[i]))
179			err = -EIO;
180	}
181	return err;
182}
183
184void exfat_chain_set(struct exfat_chain *ec, unsigned int dir,
185		unsigned int size, unsigned char flags)
186{
187	ec->dir = dir;
188	ec->size = size;
189	ec->flags = flags;
190}
191
192void exfat_chain_dup(struct exfat_chain *dup, struct exfat_chain *ec)
193{
194	return exfat_chain_set(dup, ec->dir, ec->size, ec->flags);
195}