You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
483 lines
13 KiB
483 lines
13 KiB
/*
|
|
* Copyright (C) 2012-2013 Samsung Electronics Co., Ltd.
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version 2
|
|
* of the License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
/*
|
|
* linux/fs/fat/misc.c
|
|
*
|
|
* Written 1992,1993 by Werner Almesberger
|
|
* 22/11/2000 - Fixed fat_date_unix2dos for dates earlier than 01/01/1980
|
|
* and date_dos2unix for date==0 by Igor Zhbanov(bsg@uniyar.ac.ru)
|
|
*/
|
|
|
|
/************************************************************************/
|
|
/* */
|
|
/* PROJECT : exFAT & FAT12/16/32 File System */
|
|
/* FILE : misc.c */
|
|
/* PURPOSE : Helper function for checksum and handing sdFAT error */
|
|
/* */
|
|
/*----------------------------------------------------------------------*/
|
|
/* NOTES */
|
|
/* */
|
|
/* */
|
|
/************************************************************************/
|
|
|
|
#include <linux/module.h>
|
|
#include <linux/fs.h>
|
|
#include <linux/buffer_head.h>
|
|
#include <linux/time.h>
|
|
#include <linux/blkdev.h>
|
|
#include "sdfat.h"
|
|
#include "version.h"
|
|
|
|
|
|
#ifdef CONFIG_SDFAT_SUPPORT_STLOG
|
|
#ifdef CONFIG_PROC_FSLOG
|
|
#include <linux/fslog.h>
|
|
#else
|
|
#include <linux/stlog.h>
|
|
#endif
|
|
#else
|
|
#define ST_LOG(fmt, ...)
|
|
#endif
|
|
|
|
#if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 10, 0)
|
|
#include <linux/ktime.h>
|
|
#ifndef _TIME_T
|
|
#define _TIME_T
|
|
typedef ktime_t time_t;
|
|
#endif
|
|
#endif
|
|
|
|
/*************************************************************************
|
|
* FUNCTIONS WHICH HAS KERNEL VERSION DEPENDENCY
|
|
*************************************************************************/
|
|
#ifdef CONFIG_SDFAT_UEVENT
|
|
static struct kobject sdfat_uevent_kobj;
|
|
|
|
int sdfat_uevent_init(struct kset *sdfat_kset)
|
|
{
|
|
int err;
|
|
struct kobj_type *ktype = get_ktype(&sdfat_kset->kobj);
|
|
|
|
sdfat_uevent_kobj.kset = sdfat_kset;
|
|
err = kobject_init_and_add(&sdfat_uevent_kobj, ktype, NULL, "uevent");
|
|
if (err)
|
|
pr_err("[SDFAT] Unable to create sdfat uevent kobj\n");
|
|
|
|
return err;
|
|
}
|
|
|
|
void sdfat_uevent_uninit(void)
|
|
{
|
|
kobject_del(&sdfat_uevent_kobj);
|
|
memset(&sdfat_uevent_kobj, 0, sizeof(struct kobject));
|
|
}
|
|
|
|
void sdfat_uevent_ro_remount(struct super_block *sb)
|
|
{
|
|
struct block_device *bdev = sb->s_bdev;
|
|
dev_t bd_dev = bdev ? bdev->bd_dev : 0;
|
|
|
|
char major[16], minor[16];
|
|
char *envp[] = { major, minor, NULL };
|
|
|
|
/* Do not trigger uevent if a device has been ejected */
|
|
if (fsapi_check_bdi_valid(sb))
|
|
return;
|
|
|
|
snprintf(major, sizeof(major), "MAJOR=%d", MAJOR(bd_dev));
|
|
snprintf(minor, sizeof(minor), "MINOR=%d", MINOR(bd_dev));
|
|
|
|
kobject_uevent_env(&sdfat_uevent_kobj, KOBJ_CHANGE, envp);
|
|
|
|
ST_LOG("[SDFAT](%s[%d:%d]): Uevent triggered\n",
|
|
sb->s_id, MAJOR(bd_dev), MINOR(bd_dev));
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
* sdfat_fs_error reports a file system problem that might indicate fa data
|
|
* corruption/inconsistency. Depending on 'errors' mount option the
|
|
* panic() is called, or error message is printed FAT and nothing is done,
|
|
* or filesystem is remounted read-only (default behavior).
|
|
* In case the file system is remounted read-only, it can be made writable
|
|
* again by remounting it.
|
|
*/
|
|
void __sdfat_fs_error(struct super_block *sb, int report, const char *fmt, ...)
|
|
{
|
|
struct sdfat_mount_options *opts = &SDFAT_SB(sb)->options;
|
|
va_list args;
|
|
struct va_format vaf;
|
|
struct block_device *bdev = sb->s_bdev;
|
|
dev_t bd_dev = bdev ? bdev->bd_dev : 0;
|
|
|
|
if (report) {
|
|
va_start(args, fmt);
|
|
vaf.fmt = fmt;
|
|
vaf.va = &args;
|
|
pr_err("[SDFAT](%s[%d:%d]):ERR: %pV\n",
|
|
sb->s_id, MAJOR(bd_dev), MINOR(bd_dev), &vaf);
|
|
#ifdef CONFIG_SDFAT_SUPPORT_STLOG
|
|
if (opts->errors == SDFAT_ERRORS_RO && !sb_rdonly(sb)) {
|
|
ST_LOG("[SDFAT](%s[%d:%d]):ERR: %pV\n",
|
|
sb->s_id, MAJOR(bd_dev), MINOR(bd_dev), &vaf);
|
|
}
|
|
#endif
|
|
va_end(args);
|
|
}
|
|
|
|
if (opts->errors == SDFAT_ERRORS_PANIC) {
|
|
panic("[SDFAT](%s[%d:%d]): fs panic from previous error\n",
|
|
sb->s_id, MAJOR(bd_dev), MINOR(bd_dev));
|
|
} else if (opts->errors == SDFAT_ERRORS_RO && !sb_rdonly(sb)) {
|
|
sb->s_flags |= SB_RDONLY;
|
|
sdfat_statistics_set_mnt_ro();
|
|
pr_err("[SDFAT](%s[%d:%d]): Filesystem has been set "
|
|
"read-only\n", sb->s_id, MAJOR(bd_dev), MINOR(bd_dev));
|
|
#ifdef CONFIG_SDFAT_SUPPORT_STLOG
|
|
ST_LOG("[SDFAT](%s[%d:%d]): Filesystem has been set read-only\n",
|
|
sb->s_id, MAJOR(bd_dev), MINOR(bd_dev));
|
|
#endif
|
|
sdfat_uevent_ro_remount(sb);
|
|
}
|
|
}
|
|
EXPORT_SYMBOL(__sdfat_fs_error);
|
|
|
|
/**
|
|
* __sdfat_msg() - print preformated SDFAT specific messages.
|
|
* All logs except what uses sdfat_fs_error() should be written by __sdfat_msg()
|
|
* If 'st' is set, the log is propagated to ST_LOG.
|
|
*/
|
|
void __sdfat_msg(struct super_block *sb, const char *level, int st, const char *fmt, ...)
|
|
{
|
|
struct va_format vaf;
|
|
va_list args;
|
|
struct block_device *bdev = sb->s_bdev;
|
|
dev_t bd_dev = bdev ? bdev->bd_dev : 0;
|
|
|
|
va_start(args, fmt);
|
|
vaf.fmt = fmt;
|
|
vaf.va = &args;
|
|
/* level means KERN_ pacility level */
|
|
printk("%s[SDFAT](%s[%d:%d]): %pV\n", level,
|
|
sb->s_id, MAJOR(bd_dev), MINOR(bd_dev), &vaf);
|
|
#ifdef CONFIG_SDFAT_SUPPORT_STLOG
|
|
if (st) {
|
|
ST_LOG("[SDFAT](%s[%d:%d]): %pV\n",
|
|
sb->s_id, MAJOR(bd_dev), MINOR(bd_dev), &vaf);
|
|
}
|
|
#endif
|
|
va_end(args);
|
|
}
|
|
EXPORT_SYMBOL(__sdfat_msg);
|
|
|
|
void sdfat_log_version(void)
|
|
{
|
|
pr_info("[SDFAT] Filesystem version %s\n", SDFAT_VERSION);
|
|
#ifdef CONFIG_SDFAT_SUPPORT_STLOG
|
|
ST_LOG("[SDFAT] Filesystem version %s\n", SDFAT_VERSION);
|
|
#endif
|
|
}
|
|
EXPORT_SYMBOL(sdfat_log_version);
|
|
|
|
/* <linux/time.h> externs sys_tz
|
|
* extern struct timezone sys_tz;
|
|
*/
|
|
#define UNIX_SECS_1980 315532800L
|
|
|
|
#if BITS_PER_LONG == 64
|
|
#define UNIX_SECS_2108 4354819200L
|
|
#endif
|
|
|
|
/* days between 1970/01/01 and 1980/01/01 (2 leap days) */
|
|
#define DAYS_DELTA_DECADE (365 * 10 + 2)
|
|
/* 120 (2100 - 1980) isn't leap year */
|
|
#define NO_LEAP_YEAR_2100 (120)
|
|
#define IS_LEAP_YEAR(y) (!((y) & 0x3) && (y) != NO_LEAP_YEAR_2100)
|
|
|
|
#define SECS_PER_MIN (60)
|
|
#define SECS_PER_HOUR (60 * SECS_PER_MIN)
|
|
#define SECS_PER_DAY (24 * SECS_PER_HOUR)
|
|
|
|
/* do not use time_t directly to prevent compile errors on 32bit kernel */
|
|
#define time_do_div(ori, base) \
|
|
({ \
|
|
u64 __ori = ori; \
|
|
do_div(__ori, base); \
|
|
(time_t)__ori; \
|
|
})
|
|
|
|
#define time_do_mod(ori, base) \
|
|
({ \
|
|
u64 __ori = ori; \
|
|
(time_t)do_div(__ori, base); \
|
|
})
|
|
|
|
#define MAKE_LEAP_YEAR(leap_year, year) \
|
|
({ \
|
|
/* 2100 isn't leap year */ \
|
|
if (unlikely(year > NO_LEAP_YEAR_2100)) \
|
|
leap_year = time_do_div((year + 3), 4) - 1; \
|
|
else \
|
|
leap_year = time_do_div((year + 3), 4); \
|
|
})
|
|
|
|
/* Linear day numbers of the respective 1sts in non-leap years. */
|
|
static time_t accum_days_in_year[] = {
|
|
/* Month : N 01 02 03 04 05 06 07 08 09 10 11 12 */
|
|
0, 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 0, 0, 0,
|
|
};
|
|
|
|
#define TIMEZONE_SEC(x) ((x) * 15 * SECS_PER_MIN)
|
|
/* Convert a FAT time/date pair to a UNIX date (seconds since 1 1 70). */
|
|
void sdfat_time_fat2unix(struct sdfat_sb_info *sbi, sdfat_timespec_t *ts,
|
|
DATE_TIME_T *tp)
|
|
{
|
|
time_t year = tp->Year;
|
|
time_t ld; /* leap day */
|
|
|
|
MAKE_LEAP_YEAR(ld, year);
|
|
|
|
if (IS_LEAP_YEAR(year) && (tp->Month) > 2)
|
|
ld++;
|
|
|
|
ts->tv_sec = tp->Second + tp->Minute * SECS_PER_MIN
|
|
+ tp->Hour * SECS_PER_HOUR
|
|
+ (year * 365 + ld + accum_days_in_year[tp->Month]
|
|
+ (tp->Day - 1) + DAYS_DELTA_DECADE) * SECS_PER_DAY;
|
|
|
|
ts->tv_nsec = 0;
|
|
|
|
/* Treat as local time */
|
|
if (!sbi->options.tz_utc && !tp->Timezone.valid) {
|
|
ts->tv_sec += sys_tz.tz_minuteswest * SECS_PER_MIN;
|
|
return;
|
|
}
|
|
|
|
/* Treat as UTC time */
|
|
if (!tp->Timezone.valid)
|
|
return;
|
|
|
|
/* Treat as UTC time, but need to adjust timezone to UTC0 */
|
|
if (tp->Timezone.off <= 0x3F)
|
|
ts->tv_sec -= TIMEZONE_SEC(tp->Timezone.off);
|
|
else /* 0x40 <= (tp->Timezone & 0x7F) <=0x7F */
|
|
ts->tv_sec += TIMEZONE_SEC(0x80 - tp->Timezone.off);
|
|
}
|
|
|
|
#define TIMEZONE_CUR_OFFSET() ((sys_tz.tz_minuteswest / (-15)) & 0x7F)
|
|
/* Convert linear UNIX date to a FAT time/date pair. */
|
|
void sdfat_time_unix2fat(struct sdfat_sb_info *sbi, sdfat_timespec_t *ts,
|
|
DATE_TIME_T *tp)
|
|
{
|
|
bool tz_valid = (sbi->fsi.vol_type == EXFAT) ? true : false;
|
|
time_t second = ts->tv_sec;
|
|
time_t day, month, year;
|
|
time_t ld; /* leap day */
|
|
|
|
tp->Timezone.value = 0x00;
|
|
|
|
/* Treats as local time with proper time */
|
|
if (tz_valid || !sbi->options.tz_utc) {
|
|
second -= sys_tz.tz_minuteswest * SECS_PER_MIN;
|
|
if (tz_valid) {
|
|
tp->Timezone.valid = 1;
|
|
tp->Timezone.off = TIMEZONE_CUR_OFFSET();
|
|
}
|
|
}
|
|
|
|
/* Jan 1 GMT 00:00:00 1980. But what about another time zone? */
|
|
if (second < UNIX_SECS_1980) {
|
|
tp->Second = 0;
|
|
tp->Minute = 0;
|
|
tp->Hour = 0;
|
|
tp->Day = 1;
|
|
tp->Month = 1;
|
|
tp->Year = 0;
|
|
return;
|
|
}
|
|
#if (BITS_PER_LONG == 64)
|
|
if (second >= UNIX_SECS_2108) {
|
|
tp->Second = 59;
|
|
tp->Minute = 59;
|
|
tp->Hour = 23;
|
|
tp->Day = 31;
|
|
tp->Month = 12;
|
|
tp->Year = 127;
|
|
return;
|
|
}
|
|
#endif
|
|
|
|
day = time_do_div(second, SECS_PER_DAY) - DAYS_DELTA_DECADE;
|
|
year = time_do_div(day, 365);
|
|
|
|
MAKE_LEAP_YEAR(ld, year);
|
|
if (year * 365 + ld > day)
|
|
year--;
|
|
|
|
MAKE_LEAP_YEAR(ld, year);
|
|
day -= year * 365 + ld;
|
|
|
|
if (IS_LEAP_YEAR(year) && day == accum_days_in_year[3]) {
|
|
month = 2;
|
|
} else {
|
|
if (IS_LEAP_YEAR(year) && day > accum_days_in_year[3])
|
|
day--;
|
|
for (month = 1; month < 12; month++) {
|
|
if (accum_days_in_year[month + 1] > day)
|
|
break;
|
|
}
|
|
}
|
|
day -= accum_days_in_year[month];
|
|
|
|
tp->Second = (u16)time_do_mod(second, SECS_PER_MIN);
|
|
tp->Minute = (u16)time_do_mod(time_do_div(second, SECS_PER_MIN), 60);
|
|
tp->Hour = (u16)time_do_mod(time_do_div(second, SECS_PER_HOUR), 24);
|
|
tp->Day = (u16)(day + 1);
|
|
tp->Month = (u16)month;
|
|
tp->Year = (u16)year;
|
|
}
|
|
|
|
TIMESTAMP_T *tm_now(struct inode *inode, TIMESTAMP_T *tp)
|
|
{
|
|
sdfat_timespec_t ts = current_time(inode);
|
|
DATE_TIME_T dt;
|
|
|
|
sdfat_time_unix2fat(SDFAT_SB(inode->i_sb), &ts, &dt);
|
|
|
|
tp->year = dt.Year;
|
|
tp->mon = dt.Month;
|
|
tp->day = dt.Day;
|
|
tp->hour = dt.Hour;
|
|
tp->min = dt.Minute;
|
|
tp->sec = dt.Second;
|
|
tp->tz.value = dt.Timezone.value;
|
|
|
|
return tp;
|
|
}
|
|
|
|
u8 calc_chksum_1byte(void *data, s32 len, u8 chksum)
|
|
{
|
|
s32 i;
|
|
u8 *c = (u8 *) data;
|
|
|
|
for (i = 0; i < len; i++, c++)
|
|
chksum = (((chksum & 1) << 7) | ((chksum & 0xFE) >> 1)) + *c;
|
|
|
|
return chksum;
|
|
}
|
|
|
|
u16 calc_chksum_2byte(void *data, s32 len, u16 chksum, s32 type)
|
|
{
|
|
s32 i;
|
|
u8 *c = (u8 *) data;
|
|
|
|
for (i = 0; i < len; i++, c++) {
|
|
if (((i == 2) || (i == 3)) && (type == CS_DIR_ENTRY))
|
|
continue;
|
|
chksum = (((chksum & 1) << 15) | ((chksum & 0xFFFE) >> 1)) + (u16) *c;
|
|
}
|
|
return chksum;
|
|
}
|
|
|
|
#ifdef CONFIG_SDFAT_TRACE_ELAPSED_TIME
|
|
struct timeval __t1, __t2;
|
|
u32 sdfat_time_current_usec(struct timeval *tv)
|
|
{
|
|
do_gettimeofday(tv);
|
|
return (u32)(tv->tv_sec*1000000 + tv->tv_usec);
|
|
}
|
|
#endif /* CONFIG_SDFAT_TRACE_ELAPSED_TIME */
|
|
|
|
#ifdef CONFIG_SDFAT_DBG_CAREFUL
|
|
/* Check the consistency of i_size_ondisk (FAT32, or flags 0x01 only) */
|
|
void sdfat_debug_check_clusters(struct inode *inode)
|
|
{
|
|
unsigned int num_clusters;
|
|
volatile uint32_t tmp_fat_chain[50];
|
|
volatile int tmp_i = 0;
|
|
volatile unsigned int num_clusters_org, tmp_i = 0;
|
|
CHAIN_T clu;
|
|
FILE_ID_T *fid = &(SDFAT_I(inode)->fid);
|
|
FS_INFO_T *fsi = &(SDFAT_SB(inode->i_sb)->fsi);
|
|
|
|
if (SDFAT_I(inode)->i_size_ondisk == 0)
|
|
num_clusters = 0;
|
|
else
|
|
num_clusters = ((SDFAT_I(inode)->i_size_ondisk-1) >> fsi->cluster_size_bits) + 1;
|
|
|
|
clu.dir = fid->start_clu;
|
|
clu.size = num_clusters;
|
|
clu.flags = fid->flags;
|
|
|
|
num_clusters_org = num_clusters;
|
|
|
|
if (clu.flags == 0x03)
|
|
return;
|
|
|
|
while (num_clusters > 0) {
|
|
/* FAT chain logging */
|
|
tmp_fat_chain[tmp_i] = clu.dir;
|
|
tmp_i++;
|
|
if (tmp_i >= 50)
|
|
tmp_i = 0;
|
|
|
|
BUG_ON(IS_CLUS_EOF(clu.dir) || IS_CLUS_FREE(clu.dir));
|
|
|
|
if (get_next_clus_safe(inode->i_sb, &(clu.dir)))
|
|
EMSG("%s: failed to access to FAT\n");
|
|
|
|
num_clusters--;
|
|
}
|
|
|
|
BUG_ON(!IS_CLUS_EOF(clu.dir));
|
|
}
|
|
|
|
#endif /* CONFIG_SDFAT_DBG_CAREFUL */
|
|
|
|
#ifdef CONFIG_SDFAT_DBG_MSG
|
|
void __sdfat_dmsg(int level, const char *fmt, ...)
|
|
{
|
|
#ifdef CONFIG_SDFAT_DBG_SHOW_PID
|
|
struct va_format vaf;
|
|
va_list args;
|
|
|
|
/* should check type */
|
|
if (level > SDFAT_MSG_LEVEL)
|
|
return;
|
|
|
|
va_start(args, fmt);
|
|
vaf.fmt = fmt;
|
|
vaf.va = &args;
|
|
/* fmt already includes KERN_ pacility level */
|
|
printk("[%u] %pV", current->pid, &vaf);
|
|
va_end(args);
|
|
#else
|
|
va_list args;
|
|
|
|
/* should check type */
|
|
if (level > SDFAT_MSG_LEVEL)
|
|
return;
|
|
|
|
va_start(args, fmt);
|
|
/* fmt already includes KERN_ pacility level */
|
|
vprintk(fmt, args);
|
|
va_end(args);
|
|
#endif
|
|
}
|
|
#endif
|
|
|
|
|