fs/exfat/misc.c

   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  */
  26 void __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 /*
  50  * exfat_msg() - print preformated EXFAT specific messages.
  51  * All logs except what uses exfat_fs_error() should be written by exfat_msg()
  52  */
  53 void exfat_msg(struct super_block *sb, const char *level, const char *fmt, ...)
  54 {
  55         struct va_format vaf;
  56         va_list args;
  57
  58         va_start(args, fmt);
  59         vaf.fmt = fmt;
  60         vaf.va = &args;
  61         /* level means KERN_ pacility level */
  62         printk("%sexFAT-fs (%s): %pV\n", level, sb->s_id, &vaf);
  63         va_end(args);
  64 }
  65
  66 #define SECS_PER_MIN    (60)
  67 #define TIMEZONE_SEC(x) ((x) * 15 * SECS_PER_MIN)
  68
  69 static void exfat_adjust_tz(struct timespec64 *ts, u8 tz_off)
  70 {
  71         if (tz_off <= 0x3F)
  72                 ts->tv_sec -= TIMEZONE_SEC(tz_off);
  73         else /* 0x40 <= (tz_off & 0x7F) <=0x7F */
  74                 ts->tv_sec += TIMEZONE_SEC(0x80 - tz_off);
  75 }
  76
  77 static inline int exfat_tz_offset(struct exfat_sb_info *sbi)
  78 {
  79         if (sbi->options.sys_tz)
  80                 return -sys_tz.tz_minuteswest;
  81         return sbi->options.time_offset;
  82 }
  83
  84 /* Convert a EXFAT time/date pair to a UNIX date (seconds since 1 1 70). */
  85 void exfat_get_entry_time(struct exfat_sb_info *sbi, struct timespec64 *ts,
  86                 u8 tz, __le16 time, __le16 date, u8 time_cs)
  87 {
  88         u16 t = le16_to_cpu(time);
  89         u16 d = le16_to_cpu(date);
  90
  91         ts->tv_sec = mktime64(1980 + (d >> 9), d >> 5 & 0x000F, d & 0x001F,
  92                               t >> 11, (t >> 5) & 0x003F, (t & 0x001F) << 1);
  93
  94
  95         /* time_cs field represent 0 ~ 199cs(1990 ms) */
  96         if (time_cs) {
  97                 ts->tv_sec += time_cs / 100;
  98                 ts->tv_nsec = (time_cs % 100) * 10 * NSEC_PER_MSEC;
  99         } else
 100                 ts->tv_nsec = 0;
 101
 102         if (tz & EXFAT_TZ_VALID)
 103                 /* Adjust timezone to UTC0. */
 104                 exfat_adjust_tz(ts, tz & ~EXFAT_TZ_VALID);
 105         else
 106                 ts->tv_sec -= exfat_tz_offset(sbi) * SECS_PER_MIN;
 107 }
 108
 109 /* Convert linear UNIX date to a EXFAT time/date pair. */
 110 void exfat_set_entry_time(struct exfat_sb_info *sbi, struct timespec64 *ts,
 111                 u8 *tz, __le16 *time, __le16 *date, u8 *time_cs)
 112 {
 113         struct tm tm;
 114         u16 t, d;
 115
 116         time64_to_tm(ts->tv_sec, 0, &tm);
 117         t = (tm.tm_hour << 11) | (tm.tm_min << 5) | (tm.tm_sec >> 1);
 118         d = ((tm.tm_year - 80) <<  9) | ((tm.tm_mon + 1) << 5) | tm.tm_mday;
 119
 120         *time = cpu_to_le16(t);
 121         *date = cpu_to_le16(d);
 122
 123         /* time_cs field represent 0 ~ 199cs(1990 ms) */
 124         if (time_cs)
 125                 *time_cs = (tm.tm_sec & 1) * 100 +
 126                         ts->tv_nsec / (10 * NSEC_PER_MSEC);
 127
 128         /*
 129          * Record 00h value for OffsetFromUtc field and 1 value for OffsetValid
 130          * to indicate that local time and UTC are the same.
 131          */
 132         *tz = EXFAT_TZ_VALID;
 133 }
 134
 135 /*
 136  * The timestamp for access_time has double seconds granularity.
 137  * (There is no 10msIncrement field for access_time unlike create/modify_time)
 138  * atime also has only a 2-second resolution.
 139  */
 140 void exfat_truncate_atime(struct timespec64 *ts)
 141 {
 142         ts->tv_sec = round_down(ts->tv_sec, 2);
 143         ts->tv_nsec = 0;
 144 }
 145
 146 u16 exfat_calc_chksum16(void *data, int len, u16 chksum, int type)
 147 {
 148         int i;
 149         u8 *c = (u8 *)data;
 150
 151         for (i = 0; i < len; i++, c++) {
 152                 if (unlikely(type == CS_DIR_ENTRY && (i == 2 || i == 3)))
 153                         continue;
 154                 chksum = ((chksum << 15) | (chksum >> 1)) + *c;
 155         }
 156         return chksum;
 157 }
 158
 159 u32 exfat_calc_chksum32(void *data, int len, u32 chksum, int type)
 160 {
 161         int i;
 162         u8 *c = (u8 *)data;
 163
 164         for (i = 0; i < len; i++, c++) {
 165                 if (unlikely(type == CS_BOOT_SECTOR &&
 166                              (i == 106 || i == 107 || i == 112)))
 167                         continue;
 168                 chksum = ((chksum << 31) | (chksum >> 1)) + *c;
 169         }
 170         return chksum;
 171 }
 172
 173 void exfat_update_bh(struct buffer_head *bh, int sync)
 174 {
 175         set_buffer_uptodate(bh);
 176         mark_buffer_dirty(bh);
 177
 178         if (sync)
 179                 sync_dirty_buffer(bh);
 180 }
 181
 182 int exfat_update_bhs(struct buffer_head **bhs, int nr_bhs, int sync)
 183 {
 184         int i, err = 0;
 185
 186         for (i = 0; i < nr_bhs; i++) {
 187                 set_buffer_uptodate(bhs[i]);
 188                 mark_buffer_dirty(bhs[i]);
 189                 if (sync)
 190                         write_dirty_buffer(bhs[i], REQ_SYNC);
 191         }
 192
 193         for (i = 0; i < nr_bhs && sync; i++) {
 194                 wait_on_buffer(bhs[i]);
 195                 if (!err && !buffer_uptodate(bhs[i]))
 196                         err = -EIO;
 197         }
 198         return err;
 199 }
 200
 201 void exfat_chain_set(struct exfat_chain *ec, unsigned int dir,
 202                 unsigned int size, unsigned char flags)
 203 {
 204         ec->dir = dir;
 205         ec->size = size;
 206         ec->flags = flags;
 207 }
 208
 209 void exfat_chain_dup(struct exfat_chain *dup, struct exfat_chain *ec)
 210 {
 211         return exfat_chain_set(dup, ec->dir, ec->size, ec->flags);
 212 }