Skip to content

Commit

Permalink
udf: Remove struct ustr as non-needed intermediate storage
Browse files Browse the repository at this point in the history 
Although 'struct ustr' tries to structurize the data by combining
the string and its length, it doesn't actually make much benefit,
since it saves only one parameter, but introduces an extra copying
of the whole buffer, serving as an intermediate storage. It looks
quite inefficient and not actually needed.

This commit gets rid of the struct ustr by changing the parameters
of some functions appropriately.

Also, it removes using 'dstring' type, since it doesn't make much
sense too.

Just using the occasion, add a 'const' qualifier to udf_get_filename
to make consistent parameters sets.

Signed-off-by: Andrew Gabbasov <andrew_gabbasov@mentor.com>
Signed-off-by: Jan Kara <jack@suse.cz>
  • Loading branch information
Andrew Gabbasov authored and Jan Kara committed Feb 9, 2016
1 parent 066b9cd commit 9293fcf
Show file tree
Hide file tree
Showing 3 changed files with 61 additions and 134 deletions.
36 changes: 13 additions & 23 deletions fs/udf/super.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -887,18 +887,14 @@ static int udf_find_fileset(struct super_block *sb,
static int udf_load_pvoldesc(struct super_block *sb, sector_t block)
{
struct primaryVolDesc *pvoldesc;
struct ustr *instr, *outstr;
uint8_t *outstr;
struct buffer_head *bh;
uint16_t ident;
int ret = -ENOMEM;

instr = kmalloc(sizeof(struct ustr), GFP_NOFS);
if (!instr)
return -ENOMEM;

outstr = kmalloc(sizeof(struct ustr), GFP_NOFS);
outstr = kmalloc(128, GFP_NOFS);
if (!outstr)
goto out1;
return -ENOMEM;

bh = udf_read_tagged(sb, block, block, &ident);
if (!bh) {
Expand All @@ -923,31 +919,25 @@ static int udf_load_pvoldesc(struct super_block *sb, sector_t block)
#endif
}

if (!udf_build_ustr(instr, pvoldesc->volIdent, 32)) {
ret = udf_CS0toUTF8(outstr, instr);
if (ret < 0)
goto out_bh;
ret = udf_CS0toUTF8(outstr, 31, pvoldesc->volIdent, 32);
if (ret < 0)
goto out_bh;

strncpy(UDF_SB(sb)->s_volume_ident, outstr->u_name,
outstr->u_len > 31 ? 31 : outstr->u_len);
udf_debug("volIdent[] = '%s'\n", UDF_SB(sb)->s_volume_ident);
}
strncpy(UDF_SB(sb)->s_volume_ident, outstr, ret);
udf_debug("volIdent[] = '%s'\n", UDF_SB(sb)->s_volume_ident);

if (!udf_build_ustr(instr, pvoldesc->volSetIdent, 128)) {
ret = udf_CS0toUTF8(outstr, instr);
if (ret < 0)
goto out_bh;
ret = udf_CS0toUTF8(outstr, 127, pvoldesc->volSetIdent, 128);
if (ret < 0)
goto out_bh;

udf_debug("volSetIdent[] = '%s'\n", outstr->u_name);
}
outstr[ret] = 0;
udf_debug("volSetIdent[] = '%s'\n", outstr);

ret = 0;
out_bh:
brelse(bh);
out2:
kfree(outstr);
out1:
kfree(instr);
return ret;
}

Expand Down
13 changes: 3 additions & 10 deletions fs/udf/udfdecl.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -106,12 +106,6 @@ struct generic_desc {
__le32 volDescSeqNum;
};

struct ustr {
uint8_t u_cmpID;
uint8_t u_name[UDF_NAME_LEN];
uint8_t u_len;
};


/* super.c */

Expand Down Expand Up @@ -214,12 +208,11 @@ udf_get_lb_pblock(struct super_block *sb, struct kernel_lb_addr *loc,
}

/* unicode.c */
extern int udf_get_filename(struct super_block *, uint8_t *, int, uint8_t *,
int);
extern int udf_get_filename(struct super_block *, const uint8_t *, int,
uint8_t *, int);
extern int udf_put_filename(struct super_block *, const uint8_t *, int,
uint8_t *, int);
extern int udf_build_ustr(struct ustr *, dstring *, int);
extern int udf_CS0toUTF8(struct ustr *, const struct ustr *);
extern int udf_CS0toUTF8(uint8_t *, int, const uint8_t *, int);

/* ialloc.c */
extern void udf_free_inode(struct inode *);
Expand Down
146 changes: 45 additions & 101 deletions fs/udf/unicode.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -28,53 +28,8 @@

#include "udf_sb.h"

static int udf_translate_to_linux(uint8_t *, int, uint8_t *, int, uint8_t *,
int);

static int udf_char_to_ustr(struct ustr *dest, const uint8_t *src, int strlen)
{
if ((!dest) || (!src) || (!strlen) || (strlen > UDF_NAME_LEN))
return 0;

memset(dest, 0, sizeof(struct ustr));
memcpy(dest->u_name, src, strlen);
dest->u_cmpID = 0x08;
dest->u_len = strlen;

return strlen;
}

/*
* udf_build_ustr
*/
int udf_build_ustr(struct ustr *dest, dstring *ptr, int size)
{
int usesize;

if (!dest || !ptr || !size)
return -1;
BUG_ON(size < 2);

usesize = min_t(size_t, ptr[size - 1], sizeof(dest->u_name));
usesize = min(usesize, size - 2);
dest->u_cmpID = ptr[0];
dest->u_len = usesize;
memcpy(dest->u_name, ptr + 1, usesize);
memset(dest->u_name + usesize, 0, sizeof(dest->u_name) - usesize);

return 0;
}

/*
* udf_build_ustr_exact
*/
static void udf_build_ustr_exact(struct ustr *dest, dstring *ptr, int exactsize)
{
memset(dest, 0, sizeof(struct ustr));
dest->u_cmpID = ptr[0];
dest->u_len = exactsize - 1;
memcpy(dest->u_name, ptr + 1, exactsize - 1);
}
static int udf_translate_to_linux(uint8_t *, int, const uint8_t *, int,
const uint8_t *, int);

static int udf_uni2char_utf8(wchar_t uni,
unsigned char *out,
Expand Down Expand Up @@ -159,72 +114,72 @@ static int udf_char2uni_utf8(const unsigned char *in,
return u_len;
}

static int udf_name_from_CS0(struct ustr *utf_o,
const struct ustr *ocu_i,
static int udf_name_from_CS0(uint8_t *str_o, int str_max_len,
const uint8_t *ocu, int ocu_len,
int (*conv_f)(wchar_t, unsigned char *, int))
{
const uint8_t *ocu;
uint8_t cmp_id, ocu_len;
uint8_t cmp_id;
int i, len;
int str_o_len = 0;

if (str_max_len <= 0)
return 0;

ocu_len = ocu_i->u_len;
if (ocu_len == 0) {
memset(utf_o, 0, sizeof(struct ustr));
memset(str_o, 0, str_max_len);
return 0;
}

cmp_id = ocu_i->u_cmpID;
cmp_id = ocu[0];
if (cmp_id != 8 && cmp_id != 16) {
memset(utf_o, 0, sizeof(struct ustr));
pr_err("unknown compression code (%d) stri=%s\n",
cmp_id, ocu_i->u_name);
memset(str_o, 0, str_max_len);
pr_err("unknown compression code (%d) stri=%s\n", cmp_id, ocu);
return -EINVAL;
}

ocu = ocu_i->u_name;
utf_o->u_len = 0;
for (i = 0; (i < ocu_len) && (utf_o->u_len < UDF_NAME_LEN);) {
for (i = 1; (i < ocu_len) && (str_o_len < str_max_len);) {
/* Expand OSTA compressed Unicode to Unicode */
uint32_t c = ocu[i++];
if (cmp_id == 16)
c = (c << 8) | ocu[i++];

len = conv_f(c, &utf_o->u_name[utf_o->u_len],
UDF_NAME_LEN - utf_o->u_len);
len = conv_f(c, &str_o[str_o_len], str_max_len - str_o_len);
/* Valid character? */
if (len >= 0)
utf_o->u_len += len;
str_o_len += len;
else if (len == -ENAMETOOLONG)
break;
else
utf_o->u_name[utf_o->u_len++] = '?';
str_o[str_o_len++] = '?';
}
utf_o->u_cmpID = 8;

return utf_o->u_len;
return str_o_len;
}

static int udf_name_to_CS0(dstring *ocu, struct ustr *uni, int length,
static int udf_name_to_CS0(uint8_t *ocu, int ocu_max_len,
const uint8_t *str_i, int str_len,
int (*conv_f)(const unsigned char *, int, wchar_t *))
{
int i, len;
unsigned int max_val;
wchar_t uni_char;
int u_len, u_ch;

memset(ocu, 0, sizeof(dstring) * length);
if (ocu_max_len <= 0)
return 0;

memset(ocu, 0, ocu_max_len);
ocu[0] = 8;
max_val = 0xff;
u_ch = 1;

try_again:
u_len = 0;
for (i = 0; i < uni->u_len; i++) {
u_len = 1;
for (i = 0; i < str_len; i++) {
/* Name didn't fit? */
if (u_len + 1 + u_ch >= length)
if (u_len + u_ch > ocu_max_len)
return 0;
len = conv_f(&uni->u_name[i], uni->u_len - i, &uni_char);
len = conv_f(&str_i[i], str_len - i, &uni_char);
if (!len)
continue;
/* Invalid character, deal with it */
Expand All @@ -241,84 +196,73 @@ static int udf_name_to_CS0(dstring *ocu, struct ustr *uni, int length,
}

if (max_val == 0xffff)
ocu[++u_len] = (uint8_t)(uni_char >> 8);
ocu[++u_len] = (uint8_t)(uni_char & 0xff);
ocu[u_len++] = (uint8_t)(uni_char >> 8);
ocu[u_len++] = (uint8_t)(uni_char & 0xff);
i += len - 1;
}

ocu[length - 1] = (uint8_t)u_len + 1;
return u_len + 1;
return u_len;
}

int udf_CS0toUTF8(struct ustr *utf_o, const struct ustr *ocu_i)
int udf_CS0toUTF8(uint8_t *utf_o, int o_len, const uint8_t *ocu_i, int i_len)
{
return udf_name_from_CS0(utf_o, ocu_i, udf_uni2char_utf8);
return udf_name_from_CS0(utf_o, o_len, ocu_i, i_len,
udf_uni2char_utf8);
}

int udf_get_filename(struct super_block *sb, uint8_t *sname, int slen,
int udf_get_filename(struct super_block *sb, const uint8_t *sname, int slen,
uint8_t *dname, int dlen)
{
struct ustr *filename, *unifilename;
uint8_t *filename;
int (*conv_f)(wchar_t, unsigned char *, int);
int ret;

if (!slen)
return -EIO;

filename = kmalloc(sizeof(struct ustr), GFP_NOFS);
if (dlen <= 0)
return 0;

filename = kmalloc(dlen, GFP_NOFS);
if (!filename)
return -ENOMEM;

unifilename = kmalloc(sizeof(struct ustr), GFP_NOFS);
if (!unifilename) {
ret = -ENOMEM;
goto out1;
}

udf_build_ustr_exact(unifilename, sname, slen);
if (UDF_QUERY_FLAG(sb, UDF_FLAG_UTF8)) {
conv_f = udf_uni2char_utf8;
} else if (UDF_QUERY_FLAG(sb, UDF_FLAG_NLS_MAP)) {
conv_f = UDF_SB(sb)->s_nls_map->uni2char;
} else
BUG();

ret = udf_name_from_CS0(filename, unifilename, conv_f);
ret = udf_name_from_CS0(filename, dlen, sname, slen, conv_f);
if (ret < 0) {
udf_debug("Failed in udf_get_filename: sname = %s\n", sname);
goto out2;
}

ret = udf_translate_to_linux(dname, dlen,
filename->u_name, filename->u_len,
unifilename->u_name, unifilename->u_len);
ret = udf_translate_to_linux(dname, dlen, filename, dlen,
sname + 1, slen - 1);
/* Zero length filename isn't valid... */
if (ret == 0)
ret = -EINVAL;
out2:
kfree(unifilename);
out1:
kfree(filename);
return ret;
}

int udf_put_filename(struct super_block *sb, const uint8_t *sname, int slen,
uint8_t *dname, int dlen)
{
struct ustr unifilename;
int (*conv_f)(const unsigned char *, int, wchar_t *);

if (!udf_char_to_ustr(&unifilename, sname, slen))
return 0;

if (UDF_QUERY_FLAG(sb, UDF_FLAG_UTF8)) {
conv_f = udf_char2uni_utf8;
} else if (UDF_QUERY_FLAG(sb, UDF_FLAG_NLS_MAP)) {
conv_f = UDF_SB(sb)->s_nls_map->char2uni;
} else
BUG();

return udf_name_to_CS0(dname, &unifilename, dlen, conv_f);
return udf_name_to_CS0(dname, dlen, sname, slen, conv_f);
}

#define ILLEGAL_CHAR_MARK '_'
Expand All @@ -329,8 +273,8 @@ int udf_put_filename(struct super_block *sb, const uint8_t *sname, int slen,
#define CRC_LEN 5

static int udf_translate_to_linux(uint8_t *newName, int newLen,
uint8_t *udfName, int udfLen,
uint8_t *fidName, int fidNameLen)
const uint8_t *udfName, int udfLen,
const uint8_t *fidName, int fidNameLen)
{
int index, newIndex = 0, needsCRC = 0;
int extIndex = 0, newExtIndex = 0, hasExt = 0;
Expand Down

0 comments on commit 9293fcf

Please sign in to comment.