Signed-off-by: Joe Perches <joe@xxxxxxxxxxx>
---
drivers/staging/pohmelfs/config.c | 10 +-
drivers/staging/pohmelfs/crypto.c | 58 ++++++------
drivers/staging/pohmelfs/dir.c | 118 ++++++++++++------------
drivers/staging/pohmelfs/inode.c | 164 +++++++++++++++++----------------
drivers/staging/pohmelfs/lock.c | 24 +++---
drivers/staging/pohmelfs/net.c | 152 ++++++++++++++++---------------
drivers/staging/pohmelfs/netfs.h | 10 +-
drivers/staging/pohmelfs/path_entry.c | 9 +-
drivers/staging/pohmelfs/trans.c | 76 ++++++++--------
9 files changed, 315 insertions(+), 306 deletions(-)
diff --git a/drivers/staging/pohmelfs/config.c b/drivers/staging/pohmelfs/config.c
index 5d04bf5..dc5a04c 100644
--- a/drivers/staging/pohmelfs/config.c
+++ b/drivers/staging/pohmelfs/config.c
@@ -102,8 +102,8 @@ static int pohmelfs_move_config_entry(struct pohmelfs_sb *psb,
(dst->state.ctl.perm == new->state.ctl.perm))
return 0;
- dprintk("%s: dst: prio: %d, perm: %x, new: prio: %d, perm: %d.\n",
- __func__, dst->state.ctl.prio, dst->state.ctl.perm,
+ dprintk("dst: prio: %d, perm: %x, new: prio: %d, perm: %d.\n",
+ dst->state.ctl.prio, dst->state.ctl.perm,
new->state.ctl.prio, new->state.ctl.perm);
dst->state.ctl.prio = new->state.ctl.prio;
dst->state.ctl.perm = new->state.ctl.perm;
@@ -496,9 +496,9 @@ static int pohmelfs_cn_crypto(struct cn_msg *msg)
struct pohmelfs_config_group *g;
int err = 0;
- dprintk("%s: idx: %u, strlen: %u, type: %u, keysize: %u, algo: %s.\n",
- __func__, crypto->idx, crypto->strlen, crypto->type,
- crypto->keysize, (char *)crypto->data);
+ dprintk("idx: %u, strlen: %u, type: %u, keysize: %u, algo: %s.\n",
+ crypto->idx, crypto->strlen, crypto->type,
+ crypto->keysize, (char *)crypto->data);
mutex_lock(&pohmelfs_config_lock);
g = pohmelfs_find_create_config_group(crypto->idx);
diff --git a/drivers/staging/pohmelfs/crypto.c b/drivers/staging/pohmelfs/crypto.c
index 884183c..8303e04 100644
--- a/drivers/staging/pohmelfs/crypto.c
+++ b/drivers/staging/pohmelfs/crypto.c
@@ -29,8 +29,8 @@ static struct crypto_hash *pohmelfs_init_hash(struct pohmelfs_sb *psb)
hash = crypto_alloc_hash(psb->hash_string, 0, CRYPTO_ALG_ASYNC);
if (IS_ERR(hash)) {
err = PTR_ERR(hash);
- dprintk("%s: idx: %u: failed to allocate hash '%s', err: %d.\n",
- __func__, psb->idx, psb->hash_string, err);
+ dprintk("idx: %u: failed to allocate hash '%s', err: %d.\n",
+ psb->idx, psb->hash_string, err);
goto err_out_exit;
}
@@ -41,8 +41,8 @@ static struct crypto_hash *pohmelfs_init_hash(struct pohmelfs_sb *psb)
err = crypto_hash_setkey(hash, psb->hash_key, psb->hash_keysize);
if (err) {
- dprintk("%s: idx: %u: failed to set key for hash '%s', err: %d.\n",
- __func__, psb->idx, psb->hash_string, err);
+ dprintk("idx: %u: failed to set key for hash '%s', err: %d.\n",
+ psb->idx, psb->hash_string, err);
goto err_out_free;
}
@@ -65,8 +65,8 @@ static struct crypto_ablkcipher *pohmelfs_init_cipher(struct pohmelfs_sb *psb)
cipher = crypto_alloc_ablkcipher(psb->cipher_string, 0, 0);
if (IS_ERR(cipher)) {
err = PTR_ERR(cipher);
- dprintk("%s: idx: %u: failed to allocate cipher '%s', err: %d.\n",
- __func__, psb->idx, psb->cipher_string, err);
+ dprintk("idx: %u: failed to allocate cipher '%s', err: %d.\n",
+ psb->idx, psb->cipher_string, err);
goto err_out_exit;
}
@@ -74,8 +74,8 @@ static struct crypto_ablkcipher *pohmelfs_init_cipher(struct pohmelfs_sb *psb)
err = crypto_ablkcipher_setkey(cipher, psb->cipher_key, psb->cipher_keysize);
if (err) {
- dprintk("%s: idx: %u: failed to set key for cipher '%s', err: %d.\n",
- __func__, psb->idx, psb->cipher_string, err);
+ dprintk("idx: %u: failed to set key for cipher '%s', err: %d.\n",
+ psb->idx, psb->cipher_string, err);
goto err_out_free;
}
@@ -144,7 +144,7 @@ static void pohmelfs_crypto_complete(struct crypto_async_request *req, int err)
if (err == -EINPROGRESS)
return;
- dprintk("%s: req: %p, err: %d.\n", __func__, req, err);
+ dprintk("req: %p, err: %d.\n", req, err);
c->error = err;
complete(&c->complete);
}
@@ -195,8 +195,8 @@ int pohmelfs_crypto_process_input_data(struct pohmelfs_crypto_engine *e, u64 cmd
if (!e->cipher && !e->hash)
return 0;
- dprintk("%s: eng: %p, iv: %llx, data: %p, page: %p/%lu, size: %u.\n",
- __func__, e, cmd_iv, data, page, (page)?page->index:0, size);
+ dprintk("eng: %p, iv: %llx, data: %p, page: %p/%lu, size: %u.\n",
+ e, cmd_iv, data, page, (page)?page->index:0, size);
if (data) {
sg_init_one(&sg, data, size);
@@ -245,8 +245,8 @@ int pohmelfs_crypto_process_input_data(struct pohmelfs_crypto_engine *e, u64 cmd
unsigned int i;
unsigned char *recv = e->data, *calc = dst;
- dprintk("%s: eng: %p, hash: %p, cipher: %p: iv : %llx, hash mismatch (recv/calc): ",
- __func__, e, e->hash, e->cipher, cmd_iv);
+ dprintk("eng: %p, hash: %p, cipher: %p: iv : %llx, hash mismatch (recv/calc): ",
+ e, e->hash, e->cipher, cmd_iv);
for (i=0; i<crypto_hash_digestsize(e->hash); ++i) {
#if 0
dprintka("%02x ", recv[i]);
@@ -262,19 +262,19 @@ int pohmelfs_crypto_process_input_data(struct pohmelfs_crypto_engine *e, u64 cmd
#endif
goto err_out_exit;
} else {
- dprintk("%s: eng: %p, hash: %p, cipher: %p: hashes matched.\n",
- __func__, e, e->hash, e->cipher);
+ dprintk("eng: %p, hash: %p, cipher: %p: hashes matched.\n",
+ e, e->hash, e->cipher);
}
}
- dprintk("%s: eng: %p, size: %u, hash: %p, cipher: %p: completed.\n",
- __func__, e, e->size, e->hash, e->cipher);
+ dprintk("eng: %p, size: %u, hash: %p, cipher: %p: completed.\n",
+ e, e->size, e->hash, e->cipher);
return 0;
err_out_exit:
- dprintk("%s: eng: %p, hash: %p, cipher: %p: err: %d.\n",
- __func__, e, e->hash, e->cipher, err);
+ dprintk("eng: %p, hash: %p, cipher: %p: err: %d.\n",
+ e, e->hash, e->cipher, err);
return err;
}
@@ -301,8 +301,8 @@ static int pohmelfs_trans_iter(struct netfs_trans *t, struct pohmelfs_crypto_eng
sz = csize + __be16_to_cpu(cmd->cpad) + sizeof(struct netfs_cmd);
- dprintk("%s: size: %u, sz: %u, cmd_size: %u, cmd_cpad: %u.\n",
- __func__, size, sz, __be32_to_cpu(cmd->size), __be16_to_cpu(cmd->cpad));
+ dprintk("size: %u, sz: %u, cmd_size: %u, cmd_cpad: %u.\n",
+ size, sz, __be32_to_cpu(cmd->size), __be16_to_cpu(cmd->cpad));
data += sz;
size -= sz;
@@ -401,7 +401,7 @@ static int pohmelfs_hash(struct pohmelfs_crypto_thread *tc)
{
unsigned int i;
- dprintk("%s: ", __func__);
+ dprintk("");
for (i=0; i<tc->psb->crypto_attached_size; ++i)
dprintka("%02x ", dst[i]);
dprintka("\n");
@@ -555,8 +555,8 @@ static int pohmelfs_crypto_thread_func(void *data)
if (!t->trans && !t->page)
continue;
- dprintk("%s: thread: %p, trans: %p, page: %p.\n",
- __func__, t, t->trans, t->page);
+ dprintk("thread: %p, trans: %p, page: %p.\n",
+ t, t->trans, t->page);
if (t->trans)
pohmelfs_crypto_thread_trans(t);
@@ -587,7 +587,7 @@ static void pohmelfs_crypto_flush(struct pohmelfs_sb *psb, struct list_head *hea
static void pohmelfs_sys_crypto_exit(struct pohmelfs_sb *psb)
{
while (!list_empty(&psb->crypto_active_list) || !list_empty(&psb->crypto_ready_list)) {
- dprintk("%s: crypto_thread_num: %u.\n", __func__, psb->crypto_thread_num);
+ dprintk("crypto_thread_num: %u.\n", psb->crypto_thread_num);
pohmelfs_crypto_flush(psb, &psb->crypto_active_list);
pohmelfs_crypto_flush(psb, &psb->crypto_ready_list);
}
@@ -608,8 +608,8 @@ static int pohmelfs_sys_crypto_init(struct pohmelfs_sb *psb)
if (err)
goto err_out_exit;
- dprintk("%s: st: %p, eng: %p, hash: %p, cipher: %p.\n",
- __func__, st, &st->eng, &st->eng.hash, &st->eng.cipher);
+ dprintk("st: %p, eng: %p, hash: %p, cipher: %p.\n",
+ st, &st->eng, &st->eng.hash, &st->eng.cipher);
}
for (i=0; i<psb->crypto_thread_num; ++i) {
@@ -677,7 +677,7 @@ static int pohmelfs_crypt_init_complete(struct page **pages, unsigned int page_n
struct pohmelfs_sb *psb = private;
psb->flags = -err;
- dprintk("%s: err: %d.\n", __func__, err);
+ dprintk("err: %d.\n", err);
wake_up(&psb->wait);
@@ -818,7 +818,7 @@ static int pohmelfs_trans_crypt_action(struct pohmelfs_crypto_thread *t, void *d
netfs_trans_get(trans);
t->trans = trans;
- dprintk("%s: t: %p, gen: %u, thread: %p.\n", __func__, trans, trans->gen, t);
+ dprintk("t: %p, gen: %u, thread: %p.\n", trans, trans->gen, t);
return 0;
}
diff --git a/drivers/staging/pohmelfs/dir.c b/drivers/staging/pohmelfs/dir.c
index 6c5b261..28154da 100644
--- a/drivers/staging/pohmelfs/dir.c
+++ b/drivers/staging/pohmelfs/dir.c
@@ -103,11 +103,11 @@ static struct pohmelfs_name *pohmelfs_insert_hash(struct pohmelfs_inode *pi,
}
if (ret) {
- printk("%s: exist: parent: %llu, ino: %llu, hash: %x, len: %u, data: '%s', "
- "new: ino: %llu, hash: %x, len: %u, data: '%s'.\n",
- __func__, pi->ino,
- ret->ino, ret->hash, ret->len, ret->data,
- new->ino, new->hash, new->len, new->data);
+ pr_info("exist: parent: %llu, ino: %llu, hash: %x, len: %u, data: '%s', "
+ "new: ino: %llu, hash: %x, len: %u, data: '%s'.\n",
+ pi->ino,
+ ret->ino, ret->hash, ret->len, ret->data,
+ new->ino, new->hash, new->len, new->data);
ret->ino = new->ino;
return ret;
}
@@ -232,8 +232,8 @@ struct pohmelfs_inode *pohmelfs_new_inode(struct pohmelfs_sb *psb,
struct pohmelfs_inode *npi;
int err = -EEXIST;
- dprintk("%s: creating inode: parent: %llu, ino: %llu, str: %p.\n",
- __func__, (parent)?parent->ino:0, info->ino, str);
+ dprintk("creating inode: parent: %llu, ino: %llu, str: %p.\n",
+ (parent)?parent->ino:0, info->ino, str);
err = -ENOMEM;
new = iget_locked(psb->sb, info->ino);
@@ -245,8 +245,8 @@ struct pohmelfs_inode *pohmelfs_new_inode(struct pohmelfs_sb *psb,
err = 0;
if (new->i_state & I_NEW) {
- dprintk("%s: filling VFS inode: %lu/%llu.\n",
- __func__, new->i_ino, info->ino);
+ dprintk("filling VFS inode: %lu/%llu.\n",
+ new->i_ino, info->ino);
pohmelfs_fill_inode(new, info);
if (S_ISDIR(info->mode)) {
@@ -275,9 +275,9 @@ struct pohmelfs_inode *pohmelfs_new_inode(struct pohmelfs_sb *psb,
if (parent) {
err = pohmelfs_add_dir(psb, parent, npi, str, info->mode, link);
- dprintk("%s: %s inserted name: '%s', new_offset: %llu, ino: %llu, parent: %llu.\n",
- __func__, (err)?"unsuccessfully":"successfully",
- str->name, parent->total_len, info->ino, parent->ino);
+ dprintk("%s inserted name: '%s', new_offset: %llu, ino: %llu, parent: %llu.\n",
+ (err)?"unsuccessfully":"successfully",
+ str->name, parent->total_len, info->ino, parent->ino);
if (err && err != -EEXIST)
goto err_out_put;
@@ -297,7 +297,7 @@ struct pohmelfs_inode *pohmelfs_new_inode(struct pohmelfs_sb *psb,
return npi;
err_out_put:
- printk("%s: putting inode: %p, npi: %p, error: %d.\n", __func__, new, npi, err);
+ pr_info("putting inode: %p, npi: %p, error: %d.\n", new, npi, err);
iput(new);
err_out_exit:
return ERR_PTR(err);
@@ -309,7 +309,7 @@ static int pohmelfs_remote_sync_complete(struct page **pages, unsigned int page_
struct pohmelfs_inode *pi = private;
struct pohmelfs_sb *psb = POHMELFS_SB(pi->vfs_inode.i_sb);
- dprintk("%s: ino: %llu, err: %d.\n", __func__, pi->ino, err);
+ dprintk("ino: %llu, err: %d.\n", pi->ino, err);
if (err)
pi->error = err;
@@ -331,8 +331,8 @@ static int pohmelfs_sync_remote_dir(struct pohmelfs_inode *pi)
long ret = psb->wait_on_page_timeout;
int err;
- dprintk("%s: dir: %llu, state: %lx: remote_synced: %d.\n",
- __func__, pi->ino, pi->state, test_bit(NETFS_INODE_REMOTE_SYNCED, &pi->state));
+ dprintk("dir: %llu, state: %lx: remote_synced: %d.\n",
+ pi->ino, pi->state, test_bit(NETFS_INODE_REMOTE_SYNCED, &pi->state));
if (test_bit(NETFS_INODE_REMOTE_DIR_SYNCED, &pi->state))
return 0;
@@ -349,8 +349,8 @@ static int pohmelfs_sync_remote_dir(struct pohmelfs_inode *pi)
pi->error = 0;
ret = wait_event_interruptible_timeout(psb->wait,
- test_bit(NETFS_INODE_REMOTE_DIR_SYNCED, &pi->state) || pi->error, ret);
- dprintk("%s: awake dir: %llu, ret: %ld, err: %d.\n", __func__, pi->ino, ret, pi->error);
+ test_bit(NETFS_INODE_REMOTE_DIR_SYNCED, &pi->state) || pi->error, ret);
+ dprintk("awake dir: %llu, ret: %ld, err: %d.\n", pi->ino, ret, pi->error);
if (ret <= 0) {
err = ret;
if (!err)
@@ -388,9 +388,9 @@ static int pohmelfs_readdir(struct file *file, void *dirent, filldir_t filldir)
int err = 0, mode;
u64 len;
- dprintk("%s: parent: %llu, fpos: %llu, hash: %08lx.\n",
- __func__, pi->ino, (u64)file->f_pos,
- (unsigned long)file->private_data);
+ dprintk("parent: %llu, fpos: %llu, hash: %08lx.\n",
+ pi->ino, (u64)file->f_pos,
+ (unsigned long)file->private_data);
#if 0
err = pohmelfs_data_lock(pi, 0, ~0, POHMELFS_READ_LOCK);
if (err)
@@ -409,10 +409,10 @@ static int pohmelfs_readdir(struct file *file, void *dirent, filldir_t filldir)
while (n) {
mode = (n->mode >> 12) & 15;
- dprintk("%s: offset: %llu, parent ino: %llu, name: '%s', len: %u, ino: %llu, "
- "mode: %o/%o, fpos: %llu, hash: %08x.\n",
- __func__, file->f_pos, pi->ino, n->data, n->len,
- n->ino, n->mode, mode, file->f_pos, n->hash);
+ dprintk("offset: %llu, parent ino: %llu, name: '%s', len: %u, ino: %llu, "
+ "mode: %o/%o, fpos: %llu, hash: %08x.\n",
+ file->f_pos, pi->ino, n->data, n->len,
+ n->ino, n->mode, mode, file->f_pos, n->hash);
file->private_data = (void *)(unsigned long)n->hash;
@@ -420,7 +420,7 @@ static int pohmelfs_readdir(struct file *file, void *dirent, filldir_t filldir)
err = filldir(dirent, n->data, n->len, file->f_pos, n->ino, mode);
if (err < 0) {
- dprintk("%s: err: %d.\n", __func__, err);
+ dprintk("err: %d.\n", err);
err = 0;
break;
}
@@ -488,8 +488,8 @@ static int pohmelfs_lookup_single(struct pohmelfs_inode *parent,
err_out_exit:
clear_bit(NETFS_COMMAND_PENDING, &parent->state);
- printk("%s: failed: parent: %llu, ino: %llu, name: '%s', err: %d.\n",
- __func__, parent->ino, ino, str->name, err);
+ pr_info("failed: parent: %llu, ino: %llu, name: '%s', err: %d.\n",
+ parent->ino, ino, str->name, err);
return err;
}
@@ -532,8 +532,8 @@ struct dentry *pohmelfs_lookup(struct inode *dir, struct dentry *dentry, struct
ino = n->ino;
mutex_unlock(&parent->offset_lock);
- dprintk("%s: start ino: %lu, inode: %p, name: '%s', hash: %x, parent_state: %lx, need_lock: %d.\n",
- __func__, ino, inode, str.name, str.hash, parent->state, need_lock);
+ dprintk("start ino: %lu, inode: %p, name: '%s', hash: %x, parent_state: %lx, need_lock: %d.\n",
+ ino, inode, str.name, str.hash, parent->state, need_lock);
if (ino) {
inode = ilookup(dir->i_sb, ino);
@@ -541,9 +541,9 @@ struct dentry *pohmelfs_lookup(struct inode *dir, struct dentry *dentry, struct
goto out;
}
- dprintk("%s: no inode dir: %p, dir_ino: %llu, name: '%s', len: %u, dir_state: %lx, ino: %lu.\n",
- __func__, dir, parent->ino,
- str.name, str.len, parent->state, ino);
+ dprintk("no inode dir: %p, dir_ino: %llu, name: '%s', len: %u, dir_state: %lx, ino: %lu.\n",
+ dir, parent->ino,
+ str.name, str.len, parent->state, ino);
if (!ino) {
if (!need_lock)
@@ -568,17 +568,17 @@ struct dentry *pohmelfs_lookup(struct inode *dir, struct dentry *dentry, struct
if (ino) {
inode = ilookup(dir->i_sb, ino);
- dprintk("%s: second lookup ino: %lu, inode: %p, name: '%s', hash: %x.\n",
- __func__, ino, inode, str.name, str.hash);
+ dprintk("second lookup ino: %lu, inode: %p, name: '%s', hash: %x.\n",
+ ino, inode, str.name, str.hash);
if (!inode) {
- dprintk("%s: No inode for ino: %lu, name: '%s', hash: %x.\n",
- __func__, ino, str.name, str.hash);
+ dprintk("No inode for ino: %lu, name: '%s', hash: %x.\n",
+ ino, str.name, str.hash);
/* return NULL; */
return ERR_PTR(-EACCES);
}
} else {
- printk("%s: No inode number : name: '%s', hash: %x.\n",
- __func__, str.name, str.hash);
+ pr_info("No inode number : name: '%s', hash: %x.\n",
+ str.name, str.hash);
}
out:
return d_splice_alias(inode, dentry);
@@ -595,8 +595,8 @@ struct pohmelfs_inode *pohmelfs_create_entry_local(struct pohmelfs_sb *psb,
int err = -ENOMEM;
struct netfs_inode_info info;
- dprintk("%s: name: '%s', mode: %o, start: %llu.\n",
- __func__, str->name, mode, start);
+ dprintk("name: '%s', mode: %o, start: %llu.\n",
+ str->name, mode, start);
info.mode = mode;
info.ino = start;
@@ -622,7 +622,7 @@ struct pohmelfs_inode *pohmelfs_create_entry_local(struct pohmelfs_sb *psb,
return npi;
err_out_unlock:
- dprintk("%s: err: %d.\n", __func__, err);
+ dprintk("err: %d.\n", err);
return ERR_PTR(err);
}
@@ -650,9 +650,9 @@ static int pohmelfs_create_entry(struct inode *dir, struct dentry *dentry, u64 s
d_instantiate(dentry, &npi->vfs_inode);
- dprintk("%s: parent: %llu, inode: %llu, name: '%s', parent_nlink: %d, nlink: %d.\n",
- __func__, parent->ino, npi->ino, dentry->d_name.name,
- (signed)dir->i_nlink, (signed)npi->vfs_inode.i_nlink);
+ dprintk("parent: %llu, inode: %llu, name: '%s', parent_nlink: %d, nlink: %d.\n",
+ parent->ino, npi->ino, dentry->d_name.name,
+ (signed)dir->i_nlink, (signed)npi->vfs_inode.i_nlink);
return 0;
}
@@ -693,9 +693,9 @@ static int pohmelfs_remove_entry(struct inode *dir, struct dentry *dentry)
str.hash = jhash(dentry->d_name.name, dentry->d_name.len, 0);
- dprintk("%s: dir_ino: %llu, inode: %llu, name: '%s', nlink: %d.\n",
- __func__, parent->ino, pi->ino,
- str.name, (signed)inode->i_nlink);
+ dprintk("dir_ino: %llu, inode: %llu, name: '%s', nlink: %d.\n",
+ parent->ino, pi->ino,
+ str.name, (signed)inode->i_nlink);
BUG_ON(!inode);
@@ -722,8 +722,8 @@ static int pohmelfs_remove_entry(struct inode *dir, struct dentry *dentry)
if (inode->i_nlink)
inode_dec_link_count(inode);
}
- dprintk("%s: inode: %p, lock: %ld, unhashed: %d.\n",
- __func__, pi, inode->i_state & I_LOCK, hlist_unhashed(&inode->i_hash));
+ dprintk("inode: %p, lock: %ld, unhashed: %d.\n",
+ pi, inode->i_state & I_LOCK, hlist_unhashed(&inode->i_hash));
return err;
}
@@ -741,9 +741,9 @@ static int pohmelfs_rmdir(struct inode *dir, struct dentry *dentry)
int err;
struct inode *inode = dentry->d_inode;
- dprintk("%s: parent: %llu, inode: %llu, name: '%s', parent_nlink: %d, nlink: %d.\n",
- __func__, POHMELFS_I(dir)->ino, POHMELFS_I(inode)->ino,
- dentry->d_name.name, (signed)dir->i_nlink, (signed)inode->i_nlink);
+ dprintk("parent: %llu, inode: %llu, name: '%s', parent_nlink: %d, nlink: %d.\n",
+ POHMELFS_I(dir)->ino, POHMELFS_I(inode)->ino,
+ dentry->d_name.name, (signed)dir->i_nlink, (signed)inode->i_nlink);
err = pohmelfs_remove_entry(dir, dentry);
if (!err) {
@@ -849,9 +849,9 @@ static int pohmelfs_create_link(struct pohmelfs_inode *parent, struct qstr *obj,
cmd->start = 1;
}
- dprintk("%s: parent: %llu, obj: '%s', target_inode: %llu, target_str: '%s', full: '%s'.\n",
- __func__, parent->ino, obj->name, (target)?target->ino:0, (tstr)?tstr->name:NULL,
- (char *)data);
+ dprintk("parent: %llu, obj: '%s', target_inode: %llu, target_str: '%s', full: '%s'.\n",
+ parent->ino, obj->name, (target)?target->ino:0, (tstr)?tstr->name:NULL,
+ (char *)data);
cmd->cmd = NETFS_LINK;
cmd->size = path_size;
@@ -1038,9 +1038,9 @@ static int pohmelfs_rename(struct inode *old_dir, struct dentry *old_dentry,
new_parent = old_parent;
}
- dprintk("%s: ino: %llu, parent: %llu, name: '%s' -> parent: %llu, name: '%s', i_size: %llu.\n",
- __func__, pi->ino, old_parent->ino, old_dentry->d_name.name,
- new_parent->ino, new_dentry->d_name.name, inode->i_size);
+ dprintk("ino: %llu, parent: %llu, name: '%s' -> parent: %llu, name: '%s', i_size: %llu.\n",
+ pi->ino, old_parent->ino, old_dentry->d_name.name,
+ new_parent->ino, new_dentry->d_name.name, inode->i_size);
if (test_bit(NETFS_INODE_REMOTE_SYNCED, &pi->state) &&
test_bit(NETFS_INODE_OWNED, &pi->state)) {
diff --git a/drivers/staging/pohmelfs/inode.c b/drivers/staging/pohmelfs/inode.c
index c94de31..5ec1d61 100644
--- a/drivers/staging/pohmelfs/inode.c
+++ b/drivers/staging/pohmelfs/inode.c
@@ -47,7 +47,7 @@ void pohmelfs_inode_del_inode(struct pohmelfs_sb *psb, struct pohmelfs_inode *pi
pohmelfs_free_names(pi);
mutex_unlock(&pi->offset_lock);
- dprintk("%s: deleted stuff in ino: %llu.\n", __func__, pi->ino);
+ dprintk("deleted stuff in ino: %llu.\n", pi->ino);
}
/*
@@ -92,7 +92,7 @@ int pohmelfs_write_inode_create(struct inode *inode, struct netfs_trans *trans)
return 0;
err_out_exit:
- printk("%s: completed ino: %llu, err: %d.\n", __func__, pi->ino, err);
+ pr_info("completed ino: %llu, err: %d.\n", pi->ino, err);
return err;
}
@@ -101,9 +101,9 @@ static int pohmelfs_write_trans_complete(struct page **pages, unsigned int page_
{
unsigned i;
- dprintk("%s: pages: %lu-%lu, page_num: %u, err: %d.\n",
- __func__, pages[0]->index, pages[page_num-1]->index,
- page_num, err);
+ dprintk("pages: %lu-%lu, page_num: %u, err: %d.\n",
+ pages[0]->index, pages[page_num-1]->index,
+ page_num, err);
for (i = 0; i < page_num; i++) {
struct page *page = pages[i];
@@ -121,7 +121,7 @@ static int pohmelfs_write_trans_complete(struct page **pages, unsigned int page_
unlock_page(page);
page_cache_release(page);
- /* dprintk("%s: %3u/%u: page: %p.\n", __func__, i, page_num, page); */
+ /* dprintk("%3u/%u: page: %p.\n", i, page_num, page); */
}
return err;
}
@@ -199,8 +199,8 @@ retry:
PAGECACHE_TAG_DIRTY, trans->page_num,
trans->pages);
- dprintk("%s: t: %p, nr_pages: %u, end: %lu, index: %lu, max: %u.\n",
- __func__, trans, nr_pages, end, index, trans->page_num);
+ dprintk("t: %p, nr_pages: %u, end: %lu, index: %lu, max: %u.\n",
+ trans, nr_pages, end, index, trans->page_num);
if (!nr_pages)
goto err_out_reset;
@@ -230,8 +230,8 @@ retry:
if (PageWriteback(page) ||
!clear_page_dirty_for_io(page)) {
- dprintk("%s: not clear for io page: %p, writeback: %d.\n",
- __func__, page, PageWriteback(page));
+ dprintk("not clear for io page: %p, writeback: %d.\n",
+ page, PageWriteback(page));
goto out_continue;
}
@@ -240,9 +240,9 @@ retry:
trans->attached_size += page_private(page);
trans->attached_pages++;
#if 0
- dprintk("%s: %u/%u added trans: %p, gen: %u, page: %p, [High: %d], size: %lu, idx: %lu.\n",
- __func__, i, trans->page_num, trans, trans->gen, page,
- !!PageHighMem(page), page_private(page), page->index);
+ dprintk("%u/%u added trans: %p, gen: %u, page: %p, [High: %d], size: %lu, idx: %lu.\n",
+ i, trans->page_num, trans, trans->gen, page,
+ !!PageHighMem(page), page_private(page), page->index);
#endif
wbc->nr_to_write--;
@@ -323,7 +323,7 @@ int pohmelfs_write_create_inode(struct pohmelfs_inode *pi)
if (test_bit(NETFS_INODE_REMOTE_SYNCED, &pi->state))
return 0;
- dprintk("%s: started ino: %llu.\n", __func__, pi->ino);
+ dprintk("started ino: %llu.\n", pi->ino);
err = pohmelfs_path_length(pi);
if (err < 0)
@@ -380,8 +380,8 @@ static int pohmelfs_write_inode_create_children(struct inode *inode)
inode = ilookup(sb, n->ino);
- dprintk("%s: parent: %llu, ino: %llu, inode: %p.\n",
- __func__, parent->ino, n->ino, inode);
+ dprintk("parent: %llu, ino: %llu, inode: %p.\n",
+ parent->ino, n->ino, inode);
if (inode && (inode->i_state & I_DIRTY)) {
struct pohmelfs_inode *pi = POHMELFS_I(inode);
@@ -439,9 +439,9 @@ static int pohmelfs_wait_on_page_locked(struct page *page)
prepare_to_wait(page_waitqueue(page),
&wait.wait, TASK_INTERRUPTIBLE);
- dprintk("%s: page: %p, locked: %d, uptodate: %d, error: %d, flags: %lx.\n",
- __func__, page, PageLocked(page), PageUptodate(page),
- PageError(page), page->flags);
+ dprintk("page: %p, locked: %d, uptodate: %d, error: %d, flags: %lx.\n",
+ page, PageLocked(page), PageUptodate(page),
+ PageError(page), page->flags);
if (!PageLocked(page))
break;
@@ -465,8 +465,8 @@ static int pohmelfs_wait_on_page_locked(struct page *page)
SetPageUptodate(page);
if (err)
- printk("%s: page: %p, uptodate: %d, locked: %d, err: %d.\n",
- __func__, page, PageUptodate(page), PageLocked(page), err);
+ pr_info("page: %p, uptodate: %d, locked: %d, err: %d.\n",
+ page, PageUptodate(page), PageLocked(page), err);
return err;
}
@@ -480,7 +480,7 @@ static int pohmelfs_read_page_complete(struct page **pages, unsigned int page_nu
return err;
if (err < 0) {
- dprintk("%s: page: %p, err: %d.\n", __func__, page, err);
+ dprintk("page: %p, err: %d.\n", page, err);
SetPageError(page);
}
@@ -547,8 +547,8 @@ static int pohmelfs_readpage(struct file *file, struct page *page)
cmd->cmd = NETFS_READ_PAGE;
cmd->ext = path_len;
- dprintk("%s: path: '%s', page: %p, ino: %llu, start: %llu, size: %lu.\n",
- __func__, (char *)data, page, pi->ino, cmd->start, PAGE_CACHE_SIZE);
+ dprintk("path: '%s', page: %p, ino: %llu, start: %llu, size: %lu.\n",
+ (char *)data, page, pi->ino, cmd->start, PAGE_CACHE_SIZE);
netfs_convert_cmd(cmd);
netfs_trans_update(cmd, t, path_len);
@@ -567,8 +567,8 @@ err_out_exit:
if (PageLocked(page))
unlock_page(page);
err_out_return:
- printk("%s: page: %p, start: %lu, size: %lu, err: %d.\n",
- __func__, page, page->index << PAGE_CACHE_SHIFT, PAGE_CACHE_SIZE, err);
+ pr_info("page: %p, start: %lu, size: %lu, err: %d.\n",
+ page, page->index << PAGE_CACHE_SHIFT, PAGE_CACHE_SIZE, err);
return err;
}
@@ -595,8 +595,8 @@ static int pohmelfs_write_begin(struct file *file, struct address_space *mapping
page = grab_cache_page(mapping, index);
#if 0
- dprintk("%s: page: %p pos: %llu, len: %u, index: %lu, start: %u, end: %u, uptodate: %d.\n",
- __func__, page, pos, len, index, start, end, PageUptodate(page));
+ dprintk("page: %p pos: %llu, len: %u, index: %lu, start: %u, end: %u, uptodate: %d.\n",
+ page, pos, len, index, start, end, PageUptodate(page));
#endif
if (!page) {
err = -ENOMEM;
@@ -654,10 +654,10 @@ static int pohmelfs_write_end(struct file *file, struct address_space *mapping,
SetPageUptodate(page);
set_page_dirty(page);
#if 0
- dprintk("%s: page: %p [U: %d, D: %d, L: %d], pos: %llu, len: %u, copied: %u.\n",
- __func__, page,
- PageUptodate(page), PageDirty(page), PageLocked(page),
- pos, len, copied);
+ dprintk("page: %p [U: %d, D: %d, L: %d], pos: %llu, len: %u, copied: %u.\n",
+ page,
+ PageUptodate(page), PageDirty(page), PageLocked(page),
+ pos, len, copied);
#endif
flush_dcache_page(page);
@@ -697,8 +697,8 @@ static int pohmelfs_readpages_trans_complete(struct page **__pages, unsigned int
page = pages[i];
if (err)
- printk("%s: %u/%u: page: %p, index: %lu, uptodate: %d, locked: %d, err: %d.\n",
- __func__, i, num, page, page->index,
+ pr_info("%u/%u: page: %p, index: %lu, uptodate: %d, locked: %d, err: %d.\n",
+ i, num, page, page->index,
PageUptodate(page), PageLocked(page), err);
if (!PageChecked(page)) {
@@ -761,10 +761,9 @@ static int pohmelfs_send_readpages(struct pohmelfs_inode *pi, struct page *first
cmd->id = pi->ino;
cmd->ext = path_len;
- dprintk("%s: t: %p, gen: %u, path: '%s', path_len: %u, "
- "start: %lu, num: %u.\n",
- __func__, t, t->gen, (char *)data, path_len,
- first->index, num);
+ dprintk("t: %p, gen: %u, path: '%s', path_len: %u, start: %lu, num: %u.\n",
+ t, t->gen, (char *)data, path_len,
+ first->index, num);
netfs_convert_cmd(cmd);
netfs_trans_update(cmd, t, path_len);
@@ -801,8 +800,8 @@ static int pohmelfs_readpages(struct file *file, struct address_space *mapping,
continue;
}
- dprintk("%s: added to lru page: %p, page_index: %lu, first_index: %lu.\n",
- __func__, page, page->index, first->index);
+ dprintk("added to lru page: %p, page_index: %lu, first_index: %lu.\n",
+ page, page->index, first->index);
if (unlikely(first->index + num != page->index) || (num > 500)) {
pohmelfs_send_readpages(POHMELFS_I(mapping->host),
@@ -849,8 +848,8 @@ static void pohmelfs_destroy_inode(struct inode *inode)
pohmelfs_inode_del_inode(psb, pi);
- dprintk("%s: pi: %p, inode: %p, ino: %llu.\n",
- __func__, pi, &pi->vfs_inode, pi->ino);
+ dprintk("pi: %p, inode: %p, ino: %llu.\n",
+ pi, &pi->vfs_inode, pi->ino);
kmem_cache_free(pohmelfs_inode_cache, pi);
atomic_long_dec(&psb->total_inodes);
}
@@ -878,7 +877,7 @@ static struct inode *pohmelfs_alloc_inode(struct super_block *sb)
pi->total_len = 0;
pi->drop_count = 0;
- dprintk("%s: pi: %p, inode: %p.\n", __func__, pi, &pi->vfs_inode);
+ dprintk("pi: %p, inode: %p.\n", pi, &pi->vfs_inode);
atomic_long_inc(&POHMELFS_SB(sb)->total_inodes);
@@ -914,7 +913,7 @@ ssize_t pohmelfs_write(struct file *file, const char __user *buf,
kiocb.ki_pos = pos;
kiocb.ki_left = len;
- dprintk("%s: len: %zu, pos: %llu.\n", __func__, len, pos);
+ dprintk("len: %zu, pos: %llu.\n", len, pos);
mutex_lock(&inode->i_mutex);
ret = pohmelfs_data_lock(pi, pos, len, POHMELFS_WRITE_LOCK);
@@ -973,7 +972,8 @@ int pohmelfs_setattr_raw(struct inode *inode, struct iattr *attr)
err = inode_change_ok(inode, attr);
if (err) {
- dprintk("%s: ino: %llu, inode changes are not allowed.\n", __func__, POHMELFS_I(inode)->ino);
+ dprintk("ino: %llu, inode changes are not allowed.\n",
+ POHMELFS_I(inode)->ino);
goto err_out_exit;
}
@@ -986,13 +986,15 @@ int pohmelfs_setattr_raw(struct inode *inode, struct iattr *attr)
err = inode_setattr(inode, attr);
if (err) {
- dprintk("%s: ino: %llu, failed to set the attributes.\n", __func__, POHMELFS_I(inode)->ino);
+ dprintk("ino: %llu, failed to set the attributes.\n",
+ POHMELFS_I(inode)->ino);
goto err_out_exit;
}
- dprintk("%s: ino: %llu, mode: %o -> %o, uid: %u -> %u, gid: %u -> %u, size: %llu -> %llu.\n",
- __func__, POHMELFS_I(inode)->ino, inode->i_mode, attr->ia_mode,
- inode->i_uid, attr->ia_uid, inode->i_gid, attr->ia_gid, inode->i_size, attr->ia_size);
+ dprintk("ino: %llu, mode: %o -> %o, uid: %u -> %u, gid: %u -> %u, size: %llu -> %llu.\n",
+ POHMELFS_I(inode)->ino, inode->i_mode, attr->ia_mode,
+ inode->i_uid, attr->ia_uid, inode->i_gid, attr->ia_gid,
+ inode->i_size, attr->ia_size);
return 0;
@@ -1033,8 +1035,8 @@ static int pohmelfs_send_xattr_req(struct pohmelfs_inode *pi, u64 id, u64 start,
struct netfs_cmd *cmd;
void *data;
- dprintk("%s: id: %llu, start: %llu, name: '%s', attrsize: %zu, cmd: %d.\n",
- __func__, id, start, name, attrsize, command);
+ dprintk("id: %llu, start: %llu, name: '%s', attrsize: %zu, cmd: %d.\n",
+ id, start, name, attrsize, command);
path_len = pohmelfs_path_length(pi);
if (path_len < 0) {
@@ -1118,8 +1120,8 @@ static ssize_t pohmelfs_getxattr(struct dentry *dentry, const char *name,
if (IS_ERR(m))
return PTR_ERR(m);
- dprintk("%s: ino: %llu, name: '%s', size: %zu.\n",
- __func__, pi->ino, name, attrsize);
+ dprintk("ino: %llu, name: '%s', size: %zu.\n",
+ pi->ino, name, attrsize);
err = pohmelfs_send_xattr_req(pi, m->gen, attrsize, name, value, 0, NETFS_XATTR_GET);
if (err)
@@ -1157,7 +1159,7 @@ static ssize_t pohmelfs_getxattr(struct dentry *dentry, const char *name,
pohmelfs_mcache_put(psb, m);
- dprintk("%s: ino: %llu, err: %d.\n", __func__, pi->ino, err);
+ dprintk("ino: %llu, err: %d.\n", pi->ino, err);
return err;
@@ -1176,9 +1178,9 @@ static int pohmelfs_getattr(struct vfsmount *mnt, struct dentry *dentry, struct
err = pohmelfs_data_lock(pi, 0, ~0, POHMELFS_READ_LOCK);
if (err)
return err;
- dprintk("%s: ino: %llu, mode: %o, uid: %u, gid: %u, size: %llu.\n",
- __func__, pi->ino, inode->i_mode, inode->i_uid,
- inode->i_gid, inode->i_size);
+ dprintk("ino: %llu, mode: %o, uid: %u, gid: %u, size: %llu.\n",
+ pi->ino, inode->i_mode, inode->i_uid,
+ inode->i_gid, inode->i_size);
#endif
generic_fillattr(inode, stat);
@@ -1207,10 +1209,10 @@ void pohmelfs_fill_inode(struct inode *inode, struct netfs_inode_info *info)
inode->i_version = info->version;
inode->i_blkbits = ffs(info->blocksize);
- dprintk("%s: inode: %p, num: %lu/%llu inode is regular: %d, dir: %d, link: %d, mode: %o, size: %llu.\n",
- __func__, inode, inode->i_ino, info->ino,
- S_ISREG(inode->i_mode), S_ISDIR(inode->i_mode),
- S_ISLNK(inode->i_mode), inode->i_mode, inode->i_size);
+ dprintk("inode: %p, num: %lu/%llu inode is regular: %d, dir: %d, link: %d, mode: %o, size: %llu.\n",
+ inode, inode->i_ino, info->ino,
+ S_ISREG(inode->i_mode), S_ISDIR(inode->i_mode),
+ S_ISLNK(inode->i_mode), inode->i_mode, inode->i_size);
inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME_SEC;
@@ -1286,7 +1288,7 @@ static void pohmelfs_put_super(struct super_block *sb)
unsigned int in_drop_list = 0;
struct inode *inode, *tmp;
- dprintk("%s.\n", __func__);
+ dprintk("\n");
/*
* Kill pending transactions, which could affect inodes in-flight.
@@ -1296,13 +1298,13 @@ static void pohmelfs_put_super(struct super_block *sb)
while ((pi = pohmelfs_get_inode_from_list(psb, &psb->drop_list, &count))) {
inode = &pi->vfs_inode;
- dprintk("%s: ino: %llu, pi: %p, inode: %p, count: %u.\n",
- __func__, pi->ino, pi, inode, count);
+ dprintk("ino: %llu, pi: %p, inode: %p, count: %u.\n",
+ pi->ino, pi, inode, count);
if (atomic_read(&inode->i_count) != count) {
- printk("%s: ino: %llu, pi: %p, inode: %p, count: %u, i_count: %d.\n",
- __func__, pi->ino, pi, inode, count,
- atomic_read(&inode->i_count));
+ pr_info("ino: %llu, pi: %p, inode: %p, count: %u, i_count: %d.\n",
+ pi->ino, pi, inode, count,
+ atomic_read(&inode->i_count));
count = atomic_read(&inode->i_count);
in_drop_list++;
}
@@ -1314,8 +1316,8 @@ static void pohmelfs_put_super(struct super_block *sb)
list_for_each_entry_safe(inode, tmp, &sb->s_inodes, i_sb_list) {
pi = POHMELFS_I(inode);
- dprintk("%s: ino: %llu, pi: %p, inode: %p, i_count: %u.\n",
- __func__, pi->ino, pi, inode, atomic_read(&inode->i_count));
+ dprintk("ino: %llu, pi: %p, inode: %p, i_count: %u.\n",
+ pi->ino, pi, inode, atomic_read(&inode->i_count));
/*
* These are special inodes, they were created during
@@ -1336,7 +1338,7 @@ static void pohmelfs_put_super(struct super_block *sb)
cancel_rearming_delayed_work(&psb->drop_dwork);
flush_scheduled_work();
- dprintk("%s: stopped workqueues.\n", __func__);
+ dprintk("stopped workqueues.\n");
pohmelfs_crypto_exit(psb);
pohmelfs_state_exit(psb);
@@ -1363,8 +1365,8 @@ static int pohmelfs_statfs(struct dentry *dentry, struct kstatfs *buf)
buf->f_bfree = buf->f_bavail = psb->avail_size >> PAGE_SHIFT;
buf->f_blocks = psb->total_size >> PAGE_SHIFT;
- dprintk("%s: total: %llu, avail: %llu, inodes: %llu, bsize: %lu.\n",
- __func__, psb->total_size, psb->avail_size, buf->f_files, sb->s_blocksize);
+ dprintk("total: %llu, avail: %llu, inodes: %llu, bsize: %lu.\n",
+ psb->total_size, psb->avail_size, buf->f_files, sb->s_blocksize);
return 0;
}
@@ -1495,8 +1497,8 @@ static void pohmelfs_flush_inode(struct pohmelfs_inode *pi, unsigned int count)
{
struct inode *inode = &pi->vfs_inode;
- dprintk("%s: %p: ino: %llu, owned: %d.\n",
- __func__, inode, pi->ino, test_bit(NETFS_INODE_OWNED, &pi->state));
+ dprintk("%p: ino: %llu, owned: %d.\n",
+ inode, pi->ino, test_bit(NETFS_INODE_OWNED, &pi->state));
mutex_lock(&inode->i_mutex);
if (test_and_clear_bit(NETFS_INODE_OWNED, &pi->state)) {
@@ -1514,8 +1516,8 @@ static void pohmelfs_flush_inode(struct pohmelfs_inode *pi, unsigned int count)
static void pohmelfs_put_inode_count(struct pohmelfs_inode *pi, unsigned int count)
{
- dprintk("%s: ino: %llu, pi: %p, inode: %p, count: %u.\n",
- __func__, pi->ino, pi, &pi->vfs_inode, count);
+ dprintk("ino: %llu, pi: %p, inode: %p, count: %u.\n",
+ pi->ino, pi, &pi->vfs_inode, count);
if (test_and_clear_bit(NETFS_INODE_NEED_FLUSH, &pi->state))
pohmelfs_flush_inode(pi, count);
@@ -1563,8 +1565,8 @@ static void pohmelfs_trans_scan_state(struct netfs_state *st)
&& dst->retries == 0)
break;
- dprintk("%s: t: %p, gen: %u, st: %p, retries: %u, max: %u.\n",
- __func__, t, t->gen, st, dst->retries, psb->trans_retries);
+ dprintk("t: %p, gen: %u, st: %p, retries: %u, max: %u.\n",
+ t, t->gen, st, dst->retries, psb->trans_retries);
netfs_trans_get(t);
rb_node = rb_next(rb_node);
@@ -1623,7 +1625,7 @@ int pohmelfs_meta_command_data(struct pohmelfs_inode *pi, u64 id, unsigned int c
struct netfs_inode_info *info;
struct netfs_cmd *cmd;
- dprintk("%s: ino: %llu, cmd: %u, addon: %p.\n", __func__, pi->ino, cmd_op, addon);
+ dprintk("ino: %llu, cmd: %u, addon: %p.\n", pi->ino, cmd_op, addon);
path_len = pohmelfs_path_length(pi);
if (path_len < 0) {
@@ -1672,7 +1674,7 @@ int pohmelfs_meta_command_data(struct pohmelfs_inode *pi, u64 id, unsigned int c
if (path_len < 0)
goto err_out_free;
- dprintk("%s: path_len: %d.\n", __func__, path_len);
+ dprintk("path_len: %d.\n", path_len);
if (addon) {
path_len--; /* Do not place null-byte before the addon */
@@ -1930,7 +1932,7 @@ err_out_free_sb:
kfree(psb);
err_out_exit:
- dprintk("%s: err: %d.\n", __func__, err);
+ dprintk("err: %d.\n", err);
return err;
}
diff --git a/drivers/staging/pohmelfs/lock.c b/drivers/staging/pohmelfs/lock.c
index 22fef18..1017290 100644
--- a/drivers/staging/pohmelfs/lock.c
+++ b/drivers/staging/pohmelfs/lock.c
@@ -93,7 +93,7 @@ static int pohmelfs_send_lock_trans(struct pohmelfs_inode *pi,
err_out_free:
netfs_trans_free(t);
err_out_exit:
- printk("%s: err: %d.\n", __func__, err);
+ pr_info("err: %d.\n", err);
return err;
}
@@ -105,11 +105,11 @@ int pohmelfs_data_lock(struct pohmelfs_inode *pi, u64 start, u32 size, int type)
struct iattr iattr;
struct inode *inode = &pi->vfs_inode;
- dprintk("%s: %p: ino: %llu, start: %llu, size: %u, "
- "type: %d, locked as: %d, owned: %d.\n",
- __func__, &pi->vfs_inode, pi->ino,
- start, size, type, pi->lock_type,
- !!test_bit(NETFS_INODE_OWNED, &pi->state));
+ dprintk("%p: ino: %llu, start: %llu, size: %u, "
+ "type: %d, locked as: %d, owned: %d.\n",
+ &pi->vfs_inode, pi->ino,
+ start, size, type, pi->lock_type,
+ !!test_bit(NETFS_INODE_OWNED, &pi->state));
if (!pohmelfs_need_lock(pi, type))
return 0;
@@ -130,8 +130,8 @@ int pohmelfs_data_lock(struct pohmelfs_inode *pi, u64 start, u32 size, int type)
err = -ETIMEDOUT;
if (err) {
- printk("%s: %p: ino: %llu, mgen: %llu, start: %llu, size: %u, err: %d.\n",
- __func__, &pi->vfs_inode, pi->ino, m->gen, start, size, err);
+ pr_info("%p: ino: %llu, mgen: %llu, start: %llu, size: %u, err: %d.\n",
+ &pi->vfs_inode, pi->ino, m->gen, start, size, err);
}
if (err && (err != -ENOENT))
@@ -147,8 +147,8 @@ int pohmelfs_data_lock(struct pohmelfs_inode *pi, u64 start, u32 size, int type)
iattr.ia_size = m->info.size;
iattr.ia_atime = CURRENT_TIME;
- dprintk("%s: %p: ino: %llu, mgen: %llu, start: %llu, isize: %llu -> %llu.\n",
- __func__, &pi->vfs_inode, pi->ino, m->gen, start, inode->i_size, m->info.size);
+ dprintk("%p: ino: %llu, mgen: %llu, start: %llu, isize: %llu -> %llu.\n",
+ &pi->vfs_inode, pi->ino, m->gen, start, inode->i_size, m->info.size);
err = pohmelfs_setattr_raw(inode, &iattr);
if (!err) {
@@ -174,8 +174,8 @@ err_out_put:
int pohmelfs_data_unlock(struct pohmelfs_inode *pi, u64 start, u32 size, int type)
{
- dprintk("%s: %p: ino: %llu, start: %llu, size: %u, type: %d.\n",
- __func__, &pi->vfs_inode, pi->ino, start, size, type);
+ dprintk("%p: ino: %llu, start: %llu, size: %u, type: %d.\n",
+ &pi->vfs_inode, pi->ino, start, size, type);
pi->lock_type = 0;
clear_bit(NETFS_INODE_REMOTE_DIR_SYNCED, &pi->state);
clear_bit(NETFS_INODE_OWNED, &pi->state);
diff --git a/drivers/staging/pohmelfs/net.c b/drivers/staging/pohmelfs/net.c
index af7f262..d4fd4a4 100644
--- a/drivers/staging/pohmelfs/net.c
+++ b/drivers/staging/pohmelfs/net.c
@@ -13,6 +13,8 @@
* GNU General Public License for more details.
*/
+#define pr_fmt(fmt) "pohmelfs: " fmt
+
#include <linux/fsnotify.h>
#include <linux/jhash.h>
#include <linux/in.h>
@@ -68,7 +70,8 @@ static int netfs_data_recv(struct netfs_state *st, void *buf, u64 size)
err = kernel_recvmsg(st->socket, &msg, &iov, 1, iov.iov_len,
msg.msg_flags);
if (err <= 0) {
- printk("%s: failed to recv data: size: %llu, err: %d.\n", __func__, size, err);
+ pr_info("failed to recv data: size: %llu, err: %d.\n",
+ size, err);
if (err == 0)
err = -ECONNRESET;
}
@@ -121,8 +124,8 @@ static int pohmelfs_data_recv(struct netfs_state *st, void *data, unsigned int s
}
if (revents & err_mask) {
- printk("%s: revents: %x, socket: %p, size: %u, err: %d.\n",
- __func__, revents, st->socket, size, err);
+ pr_info("revents: %x, socket: %p, size: %u, err: %d.\n",
+ revents, st->socket, size, err);
err = -ECONNRESET;
}
netfs_state_unlock(st);
@@ -143,9 +146,9 @@ static int pohmelfs_data_recv(struct netfs_state *st, void *data, unsigned int s
err = -ENODEV;
if (err)
- printk("%s: socket: %p, read_socket: %p, revents: %x, rev_error: %d, "
- "should_stop: %d, size: %u, err: %d.\n",
- __func__, st->socket, st->read_socket,
+ pr_info("socket: %p, read_socket: %p, revents: %x, rev_error: %d, "
+ "should_stop: %d, size: %u, err: %d.\n",
+ st->socket, st->read_socket,
revents, revents & err_mask, kthread_should_stop(), size, err);
}
@@ -233,15 +236,15 @@ static int pohmelfs_read_page_response(struct netfs_state *st)
inode = ilookup(st->psb->sb, cmd->id);
if (!inode) {
- printk("%s: failed to find inode: id: %llu.\n", __func__, cmd->id);
+ pr_info("failed to find inode: id: %llu.\n", cmd->id);
err = -ENOENT;
goto err_out_exit;
}
page = find_get_page(inode->i_mapping, cmd->start >> PAGE_CACHE_SHIFT);
if (!page || !PageLocked(page)) {
- printk("%s: failed to find/lock page: page: %p, id: %llu, start: %llu, index: %llu.\n",
- __func__, page, cmd->id, cmd->start, cmd->start >> PAGE_CACHE_SHIFT);
+ pr_info("failed to find/lock page: page: %p, id: %llu, start: %llu, index: %llu.\n",
+ page, cmd->id, cmd->start, cmd->start >> PAGE_CACHE_SHIFT);
while (cmd->size) {
unsigned int sz = min(cmd->size, st->size);
@@ -270,8 +273,8 @@ static int pohmelfs_read_page_response(struct netfs_state *st)
goto err_out_page_unlock;
}
- dprintk("%s: page: %p, start: %llu, size: %u, locked: %d.\n",
- __func__, page, cmd->start, cmd->size, PageLocked(page));
+ dprintk("page: %p, start: %llu, size: %u, locked: %d.\n",
+ page, cmd->start, cmd->size, PageLocked(page));
SetPageChecked(page);
if ((psb->hash_string || psb->cipher_string) && psb->perform_crypto && cmd->size) {
@@ -322,7 +325,7 @@ static int pohmelfs_check_name(struct pohmelfs_inode *parent, struct qstr *str,
if (!inode)
goto out;
- dprintk("%s: parent: %llu, inode: %llu.\n", __func__, parent->ino, ino);
+ dprintk("parent: %llu, inode: %llu.\n", parent->ino, ino);
pohmelfs_fill_inode(inode, info);
pohmelfs_put_inode(POHMELFS_I(inode));
@@ -349,7 +352,7 @@ static int pohmelfs_readdir_response(struct netfs_state *st)
inode = ilookup(st->psb->sb, cmd->id);
if (!inode) {
- printk("%s: failed to find inode: id: %llu.\n", __func__, cmd->id);
+ pr_info("failed to find inode: id: %llu.\n", cmd->id);
return -ENOENT;
}
parent = POHMELFS_I(inode);
@@ -389,9 +392,9 @@ static int pohmelfs_readdir_response(struct netfs_state *st)
if (!info->ino)
info->ino = pohmelfs_new_ino(st->psb);
- dprintk("%s: parent: %llu, ino: %llu, name: '%s', hash: %x, len: %u, mode: %o.\n",
- __func__, parent->ino, info->ino, str.name, str.hash, str.len,
- info->mode);
+ dprintk("parent: %llu, ino: %llu, name: '%s', hash: %x, len: %u, mode: %o.\n",
+ parent->ino, info->ino, str.name, str.hash, str.len,
+ info->mode);
npi = pohmelfs_new_inode(st->psb, parent, &str, info, 0);
if (IS_ERR(npi)) {
@@ -432,7 +435,8 @@ out:
err_out_put:
clear_bit(NETFS_INODE_REMOTE_DIR_SYNCED, &parent->state);
- printk("%s: parent: %llu, ino: %llu, cmd_id: %llu.\n", __func__, parent->ino, cmd->start, cmd->id);
+ pr_info("parent: %llu, ino: %llu, cmd_id: %llu.\n",
+ parent->ino, cmd->start, cmd->id);
pohmelfs_put_inode(parent);
wake_up(&st->psb->wait);
return err;
@@ -455,8 +459,8 @@ static int pohmelfs_lookup_response(struct netfs_state *st)
inode = ilookup(st->psb->sb, cmd->id);
if (!inode) {
- printk("%s: lookup response: id: %llu, start: %llu, size: %u.\n",
- __func__, cmd->id, cmd->start, cmd->size);
+ pr_info("lookup response: id: %llu, start: %llu, size: %u.\n",
+ cmd->id, cmd->start, cmd->size);
err = -ENOENT;
goto err_out_exit;
}
@@ -468,8 +472,8 @@ static int pohmelfs_lookup_response(struct netfs_state *st)
}
if (cmd->size < sizeof(struct netfs_inode_info)) {
- printk("%s: broken lookup response: id: %llu, start: %llu, size: %u.\n",
- __func__, cmd->id, cmd->start, cmd->size);
+ pr_info("broken lookup response: id: %llu, start: %llu, size: %u.\n",
+ cmd->id, cmd->start, cmd->size);
err = -EINVAL;
goto err_out_put;
}
@@ -487,8 +491,8 @@ static int pohmelfs_lookup_response(struct netfs_state *st)
if (!info->ino)
info->ino = pohmelfs_new_ino(st->psb);
- dprintk("%s: parent: %llu, ino: %llu, name: '%s', start: %llu.\n",
- __func__, parent->ino, info->ino, name, cmd->start);
+ dprintk("parent: %llu, ino: %llu, name: '%s', start: %llu.\n",
+ parent->ino, info->ino, name, cmd->start);
if (cmd->start)
npi = pohmelfs_new_inode(st->psb, parent, NULL, info, 0);
@@ -523,8 +527,8 @@ err_out_put:
err_out_exit:
clear_bit(NETFS_COMMAND_PENDING, &parent->state);
wake_up(&st->psb->wait);
- printk("%s: inode: %p, id: %llu, start: %llu, size: %u, err: %d.\n",
- __func__, inode, cmd->id, cmd->start, cmd->size, err);
+ pr_info("inode: %p, id: %llu, start: %llu, size: %u, err: %d.\n",
+ inode, cmd->id, cmd->start, cmd->size, err);
return err;
}
@@ -540,8 +544,8 @@ static int pohmelfs_create_response(struct netfs_state *st)
inode = ilookup(st->psb->sb, cmd->id);
if (!inode) {
- printk("%s: failed to find inode: id: %llu, start: %llu.\n",
- __func__, cmd->id, cmd->start);
+ pr_info("failed to find inode: id: %llu, start: %llu.\n",
+ cmd->id, cmd->start);
goto err_out_exit;
}
@@ -578,7 +582,7 @@ static int pohmelfs_remove_response(struct netfs_state *st)
if (err)
return err;
- dprintk("%s: parent: %llu, path: '%s'.\n", __func__, cmd->id, (char *)st->data);
+ dprintk("parent: %llu, path: '%s'.\n", cmd->id, (char *)st->data);
return 0;
}
@@ -608,8 +612,8 @@ static int pohmelfs_transaction_response(struct netfs_state *st)
mutex_unlock(&st->trans_lock);
if (!t) {
- printk("%s: failed to find transaction: start: %llu: id: %llu, size: %u, ext: %u.\n",
- __func__, cmd->start, cmd->id, cmd->size, cmd->ext);
+ pr_info("failed to find transaction: start: %llu: id: %llu, size: %u, ext: %u.\n",
+ cmd->start, cmd->id, cmd->size, cmd->ext);
err = -EINVAL;
goto out;
}
@@ -630,11 +634,11 @@ static int pohmelfs_page_cache_response(struct netfs_state *st)
struct netfs_cmd *cmd = &st->cmd;
struct inode *inode;
- dprintk("%s: st: %p, id: %llu, start: %llu, size: %u.\n", __func__, st, cmd->id, cmd->start, cmd->size);
+ dprintk("st: %p, id: %llu, start: %llu, size: %u.\n", st, cmd->id, cmd->start, cmd->size);
inode = ilookup(st->psb->sb, cmd->id);
if (!inode) {
- printk("%s: failed to find inode: id: %llu.\n", __func__, cmd->id);
+ pr_info("failed to find inode: id: %llu.\n", cmd->id);
return -ENOENT;
}
@@ -673,18 +677,17 @@ static int pohmelfs_root_cap_response(struct netfs_state *st)
if (psb->state_flags & POHMELFS_FLAGS_RO) {
psb->sb->s_flags |= MS_RDONLY;
- printk(KERN_INFO "Mounting POHMELFS (%d) read-only.\n", psb->idx);
+ pr_info("Mounting (%d) read-only.\n", psb->idx);
}
if (psb->state_flags & POHMELFS_FLAGS_XATTR)
- printk(KERN_INFO "Mounting POHMELFS (%d) "
- "with extended attributes support.\n", psb->idx);
+ pr_info("Mounting (%d) with extended attributes support.\n", psb->idx);
if (atomic_long_read(&psb->total_inodes) <= 1)
atomic_long_set(&psb->total_inodes, cap->nr_files);
- dprintk("%s: total: %llu, avail: %llu, flags: %llx, inodes: %llu.\n",
- __func__, psb->total_size, psb->avail_size, psb->state_flags, cap->nr_files);
+ dprintk("total: %llu, avail: %llu, flags: %llx, inodes: %llu.\n",
+ psb->total_size, psb->avail_size, psb->state_flags, cap->nr_files);
psb->flags = 0;
wake_up(&psb->wait);
@@ -710,10 +713,9 @@ static int pohmelfs_crypto_cap_response(struct netfs_state *st)
cap = st->data;
- dprintk("%s: cipher '%s': %s, hash: '%s': %s.\n",
- __func__,
- psb->cipher_string, (cap->cipher_strlen)?"SUPPORTED":"NOT SUPPORTED",
- psb->hash_string, (cap->hash_strlen)?"SUPPORTED":"NOT SUPPORTED");
+ dprintk("cipher '%s': %s, hash: '%s': %s.\n",
+ psb->cipher_string, (cap->cipher_strlen)?"SUPPORTED":"NOT SUPPORTED",
+ psb->hash_string, (cap->hash_strlen)?"SUPPORTED":"NOT SUPPORTED");
if (!cap->hash_strlen) {
if (psb->hash_strlen && psb->crypto_fail_unsupported)
@@ -772,11 +774,12 @@ static int pohmelfs_getxattr_response(struct netfs_state *st)
m = pohmelfs_mcache_search(psb, cmd->id);
- dprintk("%s: id: %llu, gen: %llu, err: %d.\n",
- __func__, cmd->id, (m)?m->gen:0, error);
+ dprintk("id: %llu, gen: %llu, err: %d.\n",
+ cmd->id, (m)?m->gen:0, error);
if (!m) {
- printk("%s: failed to find getxattr cache entry: id: %llu.\n", __func__, cmd->id);
+ pr_info("failed to find getxattr cache entry: id: %llu.\n",
+ cmd->id);
return -ENOENT;
}
@@ -822,12 +825,13 @@ int pohmelfs_data_lock_response(struct netfs_state *st)
m = pohmelfs_mcache_search(psb, id);
- dprintk("%s: id: %llu, gen: %llu, err: %d.\n",
- __func__, cmd->id, (m)?m->gen:0, err);
+ dprintk("id: %llu, gen: %llu, err: %d.\n",
+ cmd->id, (m)?m->gen:0, err);
if (!m) {
pohmelfs_data_recv(st, st->data, cmd->size);
- printk("%s: failed to find data lock response: id: %llu.\n", __func__, cmd->id);
+ pr_info("failed to find data lock response: id: %llu.\n",
+ cmd->id);
return -ENOENT;
}
@@ -880,10 +884,10 @@ static int pohmelfs_recv(void *data)
netfs_convert_cmd(cmd);
- dprintk("%s: cmd: %u, id: %llu, start: %llu, size: %u, "
- "ext: %u, csize: %u, cpad: %u.\n",
- __func__, cmd->cmd, cmd->id, cmd->start,
- cmd->size, cmd->ext, cmd->csize, cmd->cpad);
+ dprintk("cmd: %u, id: %llu, start: %llu, size: %u, "
+ "ext: %u, csize: %u, cpad: %u.\n",
+ cmd->cmd, cmd->id, cmd->start,
+ cmd->size, cmd->ext, cmd->csize, cmd->cpad);
if (cmd->csize) {
struct pohmelfs_crypto_engine *e = &st->eng;
@@ -894,10 +898,10 @@ static int pohmelfs_recv(void *data)
}
if (e->hash && unlikely(cmd->csize != st->psb->crypto_attached_size)) {
- dprintk("%s: cmd: cmd: %u, id: %llu, start: %llu, size: %u, "
- "csize: %u != digest size %u.\n",
- __func__, cmd->cmd, cmd->id, cmd->start, cmd->size,
- cmd->csize, st->psb->crypto_attached_size);
+ dprintk("cmd: cmd: %u, id: %llu, start: %llu, size: %u, "
+ "csize: %u != digest size %u.\n",
+ cmd->cmd, cmd->id, cmd->start, cmd->size,
+ cmd->csize, st->psb->crypto_attached_size);
netfs_state_reset(st);
continue;
}
@@ -913,11 +917,11 @@ static int pohmelfs_recv(void *data)
unsigned int i;
unsigned char *hash = e->data;
- dprintk("%s: received hash: ", __func__);
+ dprintk("received hash: ");
for (i=0; i<cmd->csize; ++i)
- printk("%02x ", hash[i]);
+ pr_cont("%02x ", hash[i]);
- printk("\n");
+ pr_cont("\n");
}
#endif
cmd->size -= cmd->csize;
@@ -963,8 +967,8 @@ static int pohmelfs_recv(void *data)
err = pohmelfs_getxattr_response(st);
break;
default:
- printk("%s: wrong cmd: %u, id: %llu, start: %llu, size: %u, ext: %u.\n",
- __func__, cmd->cmd, cmd->id, cmd->start, cmd->size, cmd->ext);
+ pr_info("wrong cmd: %u, id: %llu, start: %llu, size: %u, ext: %u.\n",
+ cmd->cmd, cmd->id, cmd->start, cmd->size, cmd->ext);
netfs_state_reset(st);
break;
}
@@ -983,8 +987,8 @@ int netfs_state_init(struct netfs_state *st)
err = sock_create(ctl->addr.sa_family, ctl->type, ctl->proto, &st->socket);
if (err) {
- printk("%s: failed to create a socket: family: %d, type: %d, proto: %d, err: %d.\n",
- __func__, ctl->addr.sa_family, ctl->type, ctl->proto, err);
+ pr_info("failed to create a socket: family: %d, type: %d, proto: %d, err: %d.\n",
+ ctl->addr.sa_family, ctl->type, ctl->proto, err);
goto err_out_exit;
}
@@ -993,8 +997,8 @@ int netfs_state_init(struct netfs_state *st)
err = kernel_connect(st->socket, (struct sockaddr *)&ctl->addr, ctl->addrlen, 0);
if (err) {
- printk("%s: failed to connect to server: idx: %u, err: %d.\n",
- __func__, st->psb->idx, err);
+ pr_info("failed to connect to server: idx: %u, err: %d.\n",
+ st->psb->idx, err);
goto err_out_release;
}
st->socket->sk->sk_sndtimeo = st->socket->sk->sk_rcvtimeo = msecs_to_jiffies(60000);
@@ -1005,12 +1009,12 @@ int netfs_state_init(struct netfs_state *st)
if (st->socket->ops->family == AF_INET) {
struct sockaddr_in *sin = (struct sockaddr_in *)&ctl->addr;
- printk(KERN_INFO "%s: (re)connected to peer %pi4:%d.\n", __func__,
+ pr_info("%s: (re)connected to peer %pi4:%d.\n", __func__,
&sin->sin_addr.s_addr, ntohs(sin->sin_port));
} else if (st->socket->ops->family == AF_INET6) {
struct sockaddr_in6 *sin = (struct sockaddr_in6 *)&ctl->addr;
- printk(KERN_INFO "%s: (re)connected to peer %pi6:%d", __func__,
- &sin->sin6_addr, ntohs(sin->sin6_port));
+ pr_info("%s: (re)connected to peer %pi6:%d", __func__,
+ &sin->sin6_addr, ntohs(sin->sin6_port));
}
return 0;
@@ -1030,11 +1034,11 @@ void netfs_state_exit(struct netfs_state *st)
if (st->socket->ops->family == AF_INET) {
struct sockaddr_in *sin = (struct sockaddr_in *)&st->ctl.addr;
- printk(KERN_INFO "%s: disconnected from peer %pi4:%d.\n", __func__,
+ pr_info("%s: disconnected from peer %pi4:%d.\n", __func__,
&sin->sin_addr.s_addr, ntohs(sin->sin_port));
} else if (st->socket->ops->family == AF_INET6) {
struct sockaddr_in6 *sin = (struct sockaddr_in6 *)&st->ctl.addr;
- printk(KERN_INFO "%s: disconnected from peer %pi6:%d", __func__,
+ pr_info("%s: disconnected from peer %pi6:%d", __func__,
&sin->sin6_addr, ntohs(sin->sin6_port));
}
@@ -1082,8 +1086,8 @@ int pohmelfs_state_init_one(struct pohmelfs_sb *psb, struct pohmelfs_config *con
if (!psb->active_state)
psb->active_state = conf;
- dprintk("%s: conf: %p, st: %p, socket: %p.\n",
- __func__, conf, st, st->socket);
+ dprintk("conf: %p, st: %p, socket: %p.\n",
+ conf, st, st->socket);
return 0;
err_out_netfs_exit:
@@ -1118,7 +1122,7 @@ static void pohmelfs_state_exit_one(struct pohmelfs_config *c)
{
struct netfs_state *st = &c->state;
- dprintk("%s: exiting, st: %p.\n", __func__, st);
+ dprintk("exiting, st: %p.\n", st);
if (st->thread) {
kthread_stop(st->thread);
st->thread = NULL;
@@ -1177,8 +1181,8 @@ void pohmelfs_switch_active(struct pohmelfs_sb *psb)
struct pohmelfs_config, config_entry);
}
- dprintk("%s: empty: %d, active %p -> %p.\n",
- __func__, list_empty(&psb->state_list), c,
+ dprintk("empty: %d, active %p -> %p.\n",
+ list_empty(&psb->state_list), c,
psb->active_state);
} else
psb->active_state = NULL;
diff --git a/drivers/staging/pohmelfs/netfs.h b/drivers/staging/pohmelfs/netfs.h
index 623a07d..c5e94a3 100644
--- a/drivers/staging/pohmelfs/netfs.h
+++ b/drivers/staging/pohmelfs/netfs.h
@@ -850,8 +850,10 @@ void pohmelfs_mcache_exit(void);
/* #define CONFIG_POHMELFS_DEBUG */
#ifdef CONFIG_POHMELFS_DEBUG
-#define dprintka(f, a...) printk(f, ##a)
-#define dprintk(f, a...) printk("%d: " f, task_pid_vnr(current), ##a)
+#define dprintka(f, a...) \
+ pr_cont(f, ##a)
+#define dprintk(f, a...) \
+ pr_info("%s: %d: " f, __func__, task_pid_vnr(current), ##a)
#else
#define dprintka(f, a...) do {} while (0)
#define dprintk(f, a...) do {} while (0)
@@ -865,8 +867,8 @@ static inline void netfs_trans_get(struct netfs_trans *t)
static inline void netfs_trans_put(struct netfs_trans *t)
{
if (atomic_dec_and_test(&t->refcnt)) {
- dprintk("%s: t: %p, gen: %u, err: %d.\n",
- __func__, t, t->gen, t->result);
+ dprintk("t: %p, gen: %u, err: %d.\n",
+ t, t->gen, t->result);
if (t->complete)
t->complete(t->pages, t->page_num,
t->private, t->result);
diff --git a/drivers/staging/pohmelfs/path_entry.c b/drivers/staging/pohmelfs/path_entry.c
index 3bad888..6ebcd61 100644
--- a/drivers/staging/pohmelfs/path_entry.c
+++ b/drivers/staging/pohmelfs/path_entry.c
@@ -41,7 +41,8 @@ int pohmelfs_construct_path_string(struct pohmelfs_inode *pi, void *data, int le
d = d_find_alias(&pi->vfs_inode);
if (!d) {
- printk("%s: no alias, list_empty: %d.\n", __func__, list_empty(&pi->vfs_inode.i_dentry));
+ pr_info("no alias, list_empty: %d.\n",
+ list_empty(&pi->vfs_inode.i_dentry));
return -ENOENT;
}
@@ -71,8 +72,8 @@ int pohmelfs_construct_path_string(struct pohmelfs_inode *pi, void *data, int le
err = strlen;
- dprintk("%s: dname: '%s', len: %u, maxlen: %u, name: '%s', strlen: %d.\n",
- __func__, d->d_name.name, d->d_name.len, len, ptr, strlen);
+ dprintk("dname: '%s', len: %u, maxlen: %u, name: '%s', strlen: %d.\n",
+ d->d_name.name, d->d_name.len, len, ptr, strlen);
out:
dput(d);
@@ -88,7 +89,7 @@ int pohmelfs_path_length(struct pohmelfs_inode *pi)
first = d = d_find_alias(&pi->vfs_inode);
if (!d) {
- dprintk("%s: ino: %llu, mode: %o.\n", __func__, pi->ino, pi->vfs_inode.i_mode);
+ dprintk("ino: %llu, mode: %o.\n", pi->ino, pi->vfs_inode.i_mode);
return -ENOENT;
}
diff --git a/drivers/staging/pohmelfs/trans.c b/drivers/staging/pohmelfs/trans.c
index 36a2535..d033b60 100644
--- a/drivers/staging/pohmelfs/trans.c
+++ b/drivers/staging/pohmelfs/trans.c
@@ -94,8 +94,8 @@ static int netfs_trans_send_pages(struct netfs_trans *t, struct netfs_state *st)
err = kernel_sendmsg(st->socket, &msg, (struct kvec *)msg.msg_iov, 1, sizeof(struct netfs_cmd));
if (err <= 0) {
- printk("%s: %d/%d failed to send transaction header: t: %p, gen: %u, err: %d.\n",
- __func__, i, t->page_num, t, t->gen, err);
+ pr_info("%d/%d failed to send transaction header: t: %p, gen: %u, err: %d.\n",
+ i, t->page_num, t, t->gen, err);
if (err == 0)
err = -ECONNRESET;
goto err_out;
@@ -106,15 +106,15 @@ static int netfs_trans_send_pages(struct netfs_trans *t, struct netfs_state *st)
err = kernel_sendpage(st->socket, page, 0, size, msg.msg_flags);
if (err <= 0) {
- printk("%s: %d/%d failed to send transaction page: t: %p, gen: %u, size: %u, err: %d.\n",
- __func__, i, t->page_num, t, t->gen, size, err);
+ pr_info("%d/%d failed to send transaction page: t: %p, gen: %u, size: %u, err: %d.\n",
+ i, t->page_num, t, t->gen, size, err);
if (err == 0)
err = -ECONNRESET;
goto err_out;
}
- dprintk("%s: %d/%d sent t: %p, gen: %u, page: %p/%p, size: %u.\n",
- __func__, i, t->page_num, t, t->gen, page, p, size);
+ dprintk("%d/%d sent t: %p, gen: %u, page: %p/%p, size: %u.\n",
+ i, t->page_num, t, t->gen, page, p, size);
err = 0;
attached_pages--;
@@ -124,8 +124,8 @@ static int netfs_trans_send_pages(struct netfs_trans *t, struct netfs_state *st)
continue;
-err_out:
- printk("%s: t: %p, gen: %u, err: %d.\n", __func__, t, t->gen, err);
+ err_out:
+ pr_info("t: %p, gen: %u, err: %d.\n", t, t->gen, err);
netfs_state_exit(st);
break;
}
@@ -161,16 +161,16 @@ int netfs_trans_send(struct netfs_trans *t, struct netfs_state *st)
err = kernel_sendmsg(st->socket, &msg, (struct kvec *)msg.msg_iov, 1, t->iovec.iov_len);
if (err <= 0) {
- printk("%s: failed to send contig transaction: t: %p, gen: %u, size: %zu, err: %d.\n",
- __func__, t, t->gen, t->iovec.iov_len, err);
+ pr_info("failed to send contig transaction: t: %p, gen: %u, size: %zu, err: %d.\n",
+ t, t->gen, t->iovec.iov_len, err);
if (err == 0)
err = -ECONNRESET;
goto err_out_unlock_return;
}
- dprintk("%s: sent %s transaction: t: %p, gen: %u, size: %zu, page_num: %u.\n",
- __func__, (t->page_num)?"partial":"full",
- t, t->gen, t->iovec.iov_len, t->page_num);
+ dprintk("sent %s transaction: t: %p, gen: %u, size: %zu, page_num: %u.\n",
+ (t->page_num)?"partial":"full",
+ t, t->gen, t->iovec.iov_len, t->page_num);
err = 0;
if (t->attached_pages)
@@ -183,8 +183,8 @@ err_out_unlock_return:
netfs_state_unlock_send(st);
- dprintk("%s: t: %p, gen: %u, err: %d.\n",
- __func__, t, t->gen, err);
+ dprintk("t: %p, gen: %u, err: %d.\n",
+ t, t->gen, err);
t->result = err;
return err;
@@ -251,9 +251,9 @@ static int netfs_trans_insert(struct netfs_trans_dst *ndst, struct netfs_state *
}
if (ret) {
- printk("%s: exist: old: gen: %u, flags: %x, send_time: %lu, "
- "new: gen: %u, flags: %x, send_time: %lu.\n",
- __func__, t->gen, t->flags, ret->send_time,
+ pr_info("exist: old: gen: %u, flags: %x, send_time: %lu, "
+ "new: gen: %u, flags: %x, send_time: %lu.\n",
+ t->gen, t->flags, ret->send_time,
new->gen, new->flags, ndst->send_time);
return -EEXIST;
}
@@ -453,8 +453,8 @@ int netfs_trans_finish_send(struct netfs_trans *t, struct pohmelfs_sb *psb)
int err = -ENODEV;
struct netfs_state *st;
#if 0
- dprintk("%s: t: %p, gen: %u, size: %u, page_num: %u, active: %p.\n",
- __func__, t, t->gen, t->iovec.iov_len, t->page_num, psb->active_state);
+ dprintk("t: %p, gen: %u, size: %u, page_num: %u, active: %p.\n",
+ t, t->gen, t->iovec.iov_len, t->page_num, psb->active_state);
#endif
mutex_lock(&psb->state_lock);
list_for_each_entry(c, &psb->state_list, config_entry) {
@@ -479,8 +479,8 @@ int netfs_trans_finish_send(struct netfs_trans *t, struct pohmelfs_sb *psb)
mutex_unlock(&psb->state_lock);
#if 0
- dprintk("%s: fully sent t: %p, gen: %u, size: %u, page_num: %u, err: %d.\n",
- __func__, t, t->gen, t->iovec.iov_len, t->page_num, err);
+ dprintk("fully sent t: %p, gen: %u, size: %u, page_num: %u, err: %d.\n",
+ t, t->gen, t->iovec.iov_len, t->page_num, err);
#endif
if (err)
t->result = err;
@@ -505,14 +505,14 @@ int netfs_trans_finish(struct netfs_trans *t, struct pohmelfs_sb *psb)
cmd->csize = psb->crypto_attached_size;
}
- dprintk("%s: t: %u, size: %u, iov_len: %zu, attached_size: %u, attached_pages: %u.\n",
- __func__, t->gen, cmd->size, t->iovec.iov_len, t->attached_size, t->attached_pages);
+ dprintk("t: %u, size: %u, iov_len: %zu, attached_size: %u, attached_pages: %u.\n",
+ t->gen, cmd->size, t->iovec.iov_len, t->attached_size, t->attached_pages);
err = pohmelfs_trans_crypt(t, psb);
if (err) {
t->result = err;
netfs_convert_cmd(cmd);
- dprintk("%s: trans: %llu, crypto_attached_size: %u, attached_size: %u, attached_pages: %d, trans_size: %u, err: %d.\n",
- __func__, cmd->start, psb->crypto_attached_size, t->attached_size, t->attached_pages, cmd->size, err);
+ dprintk("trans: %llu, crypto_attached_size: %u, attached_size: %u, attached_pages: %d, trans_size: %u, err: %d.\n",
+ cmd->start, psb->crypto_attached_size, t->attached_size, t->attached_pages, cmd->size, err);
}
netfs_trans_put(t);
return err;
@@ -554,8 +554,8 @@ int netfs_trans_resend(struct netfs_trans *t, struct pohmelfs_sb *psb)
if (exist) {
if (!(t->flags & NETFS_TRANS_SINGLE_DST) ||
(c->config_entry.next == &psb->state_list)) {
- dprintk("%s: resending st: %p, t: %p, gen: %u.\n",
- __func__, st, t, t->gen);
+ dprintk("resending st: %p, t: %p, gen: %u.\n",
+ st, t, t->gen);
err = netfs_trans_send(t, st);
if (!err)
error = 0;
@@ -563,8 +563,8 @@ int netfs_trans_resend(struct netfs_trans *t, struct pohmelfs_sb *psb)
continue;
}
- dprintk("%s: pushing/resending st: %p, t: %p, gen: %u.\n",
- __func__, st, t, t->gen);
+ dprintk("pushing/resending st: %p, t: %p, gen: %u.\n",
+ st, t, t->gen);
err = netfs_trans_push(t, st);
if (err)
continue;
@@ -588,8 +588,8 @@ void *netfs_trans_add(struct netfs_trans *t, unsigned int size)
}
if (io->iov_len + size > t->total_size) {
- dprintk("%s: too big size t: %p, gen: %u, iov_len: %zu, size: %u, total: %u.\n",
- __func__, t, t->gen, io->iov_len, size, t->total_size);
+ dprintk("too big size t: %p, gen: %u, iov_len: %zu, size: %u, total: %u.\n",
+ t, t->gen, io->iov_len, size, t->total_size);
ptr = ERR_PTR(-E2BIG);
goto out;
}
@@ -598,8 +598,8 @@ void *netfs_trans_add(struct netfs_trans *t, unsigned int size)
io->iov_len += size;
out:
- dprintk("%s: t: %p, gen: %u, size: %u, total: %zu.\n",
- __func__, t, t->gen, size, io->iov_len);
+ dprintk("t: %p, gen: %u, size: %u, total: %zu.\n",
+ t, t->gen, size, io->iov_len);
return ptr;
}
@@ -667,10 +667,10 @@ struct netfs_trans *netfs_trans_alloc(struct pohmelfs_sb *psb, unsigned int size
cmd->cpad = pad;
cmd->csize = crypto_added;
- dprintk("%s: t: %p, gen: %u, size: %u, padding: %u, align_size: %u, flags: %x, "
- "page_num: %u, base: %p, pages: %p.\n",
- __func__, t, t->gen, size, pad, psb->crypto_align_size, flags, nr,
- t->iovec.iov_base, t->pages);
+ dprintk("t: %p, gen: %u, size: %u, padding: %u, align_size: %u, flags: %x, "
+ "page_num: %u, base: %p, pages: %p.\n",
+ t, t->gen, size, pad, psb->crypto_align_size, flags, nr,
+ t->iovec.iov_base, t->pages);
return t;
--
1.6.5.rc3.dirty
_______________________________________________
devel mailing list
devel@xxxxxxxxxxxxxxxxxxxxxx
http://driverdev.linuxdriverproject.org/mailman/listinfo/devel
