Message-ID: <CAPj211vpoVt4si6Mi3kvrF4SW3NqfLJkQQm09NXz0BRHMWKTCQ@mail.gmail.com>
Date:   Fri, 25 Nov 2022 17:19:56 +0100
From:   "Fabio M. De Francesco" <fmdefrancesco@...il.com>
To:     Evgeniy Dushistov <dushistov@...l.ru>,
        Christian Brauner <brauner@...nel.org>
Cc:     linux-kernel@...r.kernel.org, bpf@...r.kernel.org,
        "Venkataramanan, Anirudh" <anirudh.venkataramanan@...el.com>,
        Ira Weiny <ira.weiny@...el.com>
Subject: Re: [RESEND PATCH v4] fs/ufs: Replace kmap() with kmap_local_page()

On domenica 16 ottobre 2022 18:38:55 CET Fabio M. De Francesco wrote:
> kmap() is being deprecated in favor of kmap_local_page().
>
> There are two main problems with kmap(): (1) It comes with an overhead as
> the mapping space is restricted and protected by a global lock for
> synchronization and (2) it also requires global TLB invalidation when the
> kmap’s pool wraps and it might block when the mapping space is fully
> utilized until a slot becomes available.
>
> With kmap_local_page() the mappings are per thread, CPU local, can take
> page faults, and can be called from any context (including interrupts).
> It is faster than kmap() in kernels with HIGHMEM enabled. Furthermore,
> the tasks can be preempted and, when they are scheduled to run again, the
> kernel virtual addresses are restored and still valid.
>
> Since its use in fs/ufs is safe everywhere, it should be preferred.
>
> Therefore, replace kmap() with kmap_local_page() in fs/ufs. kunmap_local()
> requires the mapping address, so return that address from ufs_get_page()
> to be used in ufs_put_page(). Where suited, use the standard helper
> memzero_page() instead of open coding kmap_local_page() plus memset().
>
> These changes are essentially ported from fs/ext2 and are largely based on
> commit 782b76d7abdf ("fs/ext2: Replace kmap() with kmap_local_page()").
>
> Cc: "Venkataramanan, Anirudh" <anirudh.venkataramanan@...el.com>
> Suggested-by: Ira Weiny <ira.weiny@...el.com>
> Reviewed-by: Ira Weiny <ira.weiny@...el.com>
> Signed-off-by: Fabio M. De Francesco <fmdefrancesco@...il.com>
> ---
>
> This code is not tested. I have no means to create an UFS filesystem.
> Despite nothing here seems to break the strict rules about the use of
> kmap_local_page(), any help with testing will be much appreciated :-)
>
> v3 -> v4: Convert another kmap() which was overlooked. Since the code
>         changed, remove the "Reviewed-by" tag from Ira.
>
> v2 -> v3: Rename a variable for consistency (Ira Weiny). Add a
>         "Reviewed-by" tag.
>
> v1 -> v2: Correct some style's issues reported by checkpatch.pl.
>           Remove an "inline" compiler directive from fs/ufs/ufs.h,
>           Reported-by: kernel test robot <lkp@...el.com>
>
>  fs/ufs/dir.c   | 116 +++++++++++++++++++++++++++++++------------------
>  fs/ufs/namei.c |  38 ++++++++--------
>  fs/ufs/ufs.h   |  12 +++--
>  3 files changed, 102 insertions(+), 64 deletions(-)

Evgeniy, Christian,

I'm again here to gently ping and remind this patch to both of you. I have no
idea about why it didn't yet deserve any reply. Is there anything I'm still
missing?

I'm looking forward to hear from you.

Thanks,

Fabio


> diff --git a/fs/ufs/dir.c b/fs/ufs/dir.c
> index 391efaf1d528..db7564852391 100644
> --- a/fs/ufs/dir.c
> +++ b/fs/ufs/dir.c
> @@ -61,9 +61,9 @@ static int ufs_commit_chunk(struct page *page, loff_t pos,
> unsigned len) return err;
>  }
>
> -static inline void ufs_put_page(struct page *page)
> +inline void ufs_put_page(struct page *page, void *page_addr)
>  {
> -     kunmap(page);
> +     kunmap_local(page_addr);
>       put_page(page);
>  }
>
> @@ -72,11 +72,12 @@ ino_t ufs_inode_by_name(struct inode *dir, const struct
> qstr *qstr) ino_t res = 0;
>       struct ufs_dir_entry *de;
>       struct page *page;
> -
> -     de = ufs_find_entry(dir, qstr, &page);
> +     void *page_addr;
> +
> +     de = ufs_find_entry(dir, qstr, &page, &page_addr);
>       if (de) {
>               res = fs32_to_cpu(dir->i_sb, de->d_ino);
> -             ufs_put_page(page);
> +             ufs_put_page(page, page_addr);
>       }
>       return res;
>  }
> @@ -84,11 +85,11 @@ ino_t ufs_inode_by_name(struct inode *dir, const struct
> qstr *qstr)
>
>  /* Releases the page */
>  void ufs_set_link(struct inode *dir, struct ufs_dir_entry *de,
> -               struct page *page, struct inode *inode,
> -               bool update_times)
> +               struct page *page, void *page_addr,
> +               struct inode *inode, bool update_times)
>  {
>       loff_t pos = page_offset(page) +
> -                     (char *) de - (char *) page_address(page);
> +                     (char *)de - (char *)page_addr;
>       unsigned len = fs16_to_cpu(dir->i_sb, de->d_reclen);
>       int err;
>
> @@ -100,18 +101,17 @@ void ufs_set_link(struct inode *dir, struct
> ufs_dir_entry *de, ufs_set_de_type(dir->i_sb, de, inode->i_mode);
>
>       err = ufs_commit_chunk(page, pos, len);
> -     ufs_put_page(page);
> +     ufs_put_page(page, page_addr);
>       if (update_times)
>               dir->i_mtime = dir->i_ctime = current_time(dir);
>       mark_inode_dirty(dir);
>  }
>
>
> -static bool ufs_check_page(struct page *page)
> +static bool ufs_check_page(struct page *page, char *kaddr)
>  {
>       struct inode *dir = page->mapping->host;
>       struct super_block *sb = dir->i_sb;
> -     char *kaddr = page_address(page);
>       unsigned offs, rec_len;
>       unsigned limit = PAGE_SIZE;
>       const unsigned chunk_mask = UFS_SB(sb)->s_uspi->s_dirblksize - 1;
> @@ -186,21 +186,28 @@ static bool ufs_check_page(struct page *page)
>       return false;
>  }
>
> -static struct page *ufs_get_page(struct inode *dir, unsigned long n)
> +/*
> + * Calls to ufs_get_page()/ufs_put_page() must be nested according to the
> + * rules documented in kmap_local_page()/kunmap_local().
> + *
> + * NOTE: ufs_find_entry() and ufs_dotdot() act as calls to ufs_get_page()
> + * and must be treated accordingly for nesting purposes.
> + */
> +static struct page *ufs_get_page(struct inode *dir, unsigned long n, void
> **page_addr) {
>       struct address_space *mapping = dir->i_mapping;
>       struct page *page = read_mapping_page(mapping, n, NULL);
>       if (!IS_ERR(page)) {
> -             kmap(page);
> +             *page_addr = kmap_local_page(page);
>               if (unlikely(!PageChecked(page))) {
> -                     if (!ufs_check_page(page))
> +                     if (!ufs_check_page(page, *page_addr))
>                               goto fail;
>               }
>       }
>       return page;
>
>  fail:
> -     ufs_put_page(page);
> +     ufs_put_page(page, *page_addr);
>       return ERR_PTR(-EIO);
>  }
>
> @@ -226,15 +233,29 @@ ufs_next_entry(struct super_block *sb, struct
> ufs_dir_entry *p) fs16_to_cpu(sb, p->d_reclen));
>  }
>
> -struct ufs_dir_entry *ufs_dotdot(struct inode *dir, struct page **p)
> +/*
> + * Return the '..' directory entry and the page in which the entry was
found
> + * (as a parameter - p).
> + *
> + * On Success ufs_put_page() should be called on *p.
> + *
> + * NOTE: Calls to ufs_get_page()/ufs_put_page() must be nested according to
> + * the rules documented in kmap_local_page()/kunmap_local().
> + *
> + * ufs_find_entry() and ufs_dotdot() act as calls to ufs_get_page() and
> + * must be treated accordingly for nesting purposes.
> + */
> +struct ufs_dir_entry *ufs_dotdot(struct inode *dir, struct page **p, void
> **pa) {
> -     struct page *page = ufs_get_page(dir, 0);
> +     void *page_addr;
> +     struct page *page = ufs_get_page(dir, 0, &page_addr);
>       struct ufs_dir_entry *de = NULL;
>
>       if (!IS_ERR(page)) {
>               de = ufs_next_entry(dir->i_sb,
> -                                 (struct ufs_dir_entry
*)page_address(page));
> +                                 (struct ufs_dir_entry
*)page_addr);
>               *p = page;
> +             *pa = page_addr;
>       }
>       return de;
>  }
> @@ -246,9 +267,17 @@ struct ufs_dir_entry *ufs_dotdot(struct inode *dir,
> struct page **p) * returns the page in which the entry was found, and the
> entry itself * (as a parameter - res_dir). Page is returned mapped and
> unlocked. * Entry is guaranteed to be valid.
> + *
> + * On Success ufs_put_page() should be called on *res_page.
> + *
> + * NOTE: Calls to ufs_get_page()/ufs_put_page() must be nested according to
> + * the rules documented in kmap_local_page()/kunmap_local().
> + *
> + * ufs_find_entry() and ufs_dotdot() act as calls to ufs_get_page() and
> + * must be treated accordingly for nesting purposes.
>   */
>  struct ufs_dir_entry *ufs_find_entry(struct inode *dir, const struct qstr
> *qstr, -                                   struct page **res_page)
> +                                  struct page **res_page, void
**res_page_addr)
>  {
>       struct super_block *sb = dir->i_sb;
>       const unsigned char *name = qstr->name;
> @@ -259,6 +288,7 @@ struct ufs_dir_entry *ufs_find_entry(struct inode *dir,
> const struct qstr *qstr, struct page *page = NULL;
>       struct ufs_inode_info *ui = UFS_I(dir);
>       struct ufs_dir_entry *de;
> +     void *page_addr;
>
>       UFSD("ENTER, dir_ino %lu, name %s, namlen %u\n", dir->i_ino, name,
namelen);
>
> @@ -267,6 +297,7 @@ struct ufs_dir_entry *ufs_find_entry(struct inode *dir,
> const struct qstr *qstr,
>
>       /* OFFSET_CACHE */
>       *res_page = NULL;
> +     *res_page_addr = NULL;
>
>       start = ui->i_dir_start_lookup;
>
> @@ -275,9 +306,10 @@ struct ufs_dir_entry *ufs_find_entry(struct inode *dir,
> const struct qstr *qstr, n = start;
>       do {
>               char *kaddr;
> -             page = ufs_get_page(dir, n);
> +
> +             page = ufs_get_page(dir, n, &page_addr);
>               if (!IS_ERR(page)) {
> -                     kaddr = page_address(page);
> +                     kaddr = page_addr;
>                       de = (struct ufs_dir_entry *) kaddr;
>                       kaddr += ufs_last_byte(dir, n) - reclen;
>                       while ((char *) de <= kaddr) {
> @@ -285,7 +317,7 @@ struct ufs_dir_entry *ufs_find_entry(struct inode *dir,
> const struct qstr *qstr, goto found;
>                               de = ufs_next_entry(sb, de);
>                       }
> -                     ufs_put_page(page);
> +                     ufs_put_page(page, page_addr);
>               }
>               if (++n >= npages)
>                       n = 0;
> @@ -295,6 +327,7 @@ struct ufs_dir_entry *ufs_find_entry(struct inode *dir,
> const struct qstr *qstr,
>
>  found:
>       *res_page = page;
> +     *res_page_addr = page_addr;
>       ui->i_dir_start_lookup = n;
>       return de;
>  }
> @@ -312,6 +345,7 @@ int ufs_add_link(struct dentry *dentry, struct inode
> *inode) const unsigned int chunk_size = UFS_SB(sb)->s_uspi->s_dirblksize;
>       unsigned short rec_len, name_len;
>       struct page *page = NULL;
> +     void *page_addr = NULL;
>       struct ufs_dir_entry *de;
>       unsigned long npages = dir_pages(dir);
>       unsigned long n;
> @@ -329,12 +363,12 @@ int ufs_add_link(struct dentry *dentry, struct inode
> *inode) for (n = 0; n <= npages; n++) {
>               char *dir_end;
>
> -             page = ufs_get_page(dir, n);
> +             page = ufs_get_page(dir, n, &page_addr);
>               err = PTR_ERR(page);
>               if (IS_ERR(page))
>                       goto out;
>               lock_page(page);
> -             kaddr = page_address(page);
> +             kaddr = page_addr;
>               dir_end = kaddr + ufs_last_byte(dir, n);
>               de = (struct ufs_dir_entry *)kaddr;
>               kaddr += PAGE_SIZE - reclen;
> @@ -365,14 +399,14 @@ int ufs_add_link(struct dentry *dentry, struct inode
> *inode) de = (struct ufs_dir_entry *) ((char *) de + rec_len);
>               }
>               unlock_page(page);
> -             ufs_put_page(page);
> +             ufs_put_page(page, page_addr);
>       }
>       BUG();
>       return -EINVAL;
>
>  got_it:
>       pos = page_offset(page) +
> -                     (char*)de - (char*)page_address(page);
> +                     (char *)de - (char *)page_addr;
>       err = ufs_prepare_chunk(page, pos, rec_len);
>       if (err)
>               goto out_unlock;
> @@ -396,7 +430,7 @@ int ufs_add_link(struct dentry *dentry, struct inode
> *inode) mark_inode_dirty(dir);
>       /* OFFSET_CACHE */
>  out_put:
> -     ufs_put_page(page);
> +     ufs_put_page(page, page_addr);
>  out:
>       return err;
>  out_unlock:
> @@ -441,7 +475,7 @@ ufs_readdir(struct file *file, struct dir_context *ctx)
>               char *kaddr, *limit;
>               struct ufs_dir_entry *de;
>
> -             struct page *page = ufs_get_page(inode, n);
> +             struct page *page = ufs_get_page(inode, n, (void
**)&kaddr);
>
>               if (IS_ERR(page)) {
>                       ufs_error(sb, __func__,
> @@ -450,7 +484,6 @@ ufs_readdir(struct file *file, struct dir_context *ctx)
>                       ctx->pos += PAGE_SIZE - offset;
>                       return -EIO;
>               }
> -             kaddr = page_address(page);
>               if (unlikely(need_revalidate)) {
>                       if (offset) {
>                               offset = ufs_validate_entry(sb, kaddr,
offset, chunk_mask);
> @@ -476,13 +509,13 @@ ufs_readdir(struct file *file, struct dir_context
*ctx)
>                                              ufs_get_de_namlen(sb,
de),
>                                              fs32_to_cpu(sb, de-
>d_ino),
>                                              d_type)) {
> -                                     ufs_put_page(page);
> +                                     ufs_put_page(page, kaddr);
>                                       return 0;
>                               }
>                       }
>                       ctx->pos += fs16_to_cpu(sb, de->d_reclen);
>               }
> -             ufs_put_page(page);
> +             ufs_put_page(page, kaddr);
>       }
>       return 0;
>  }
> @@ -493,10 +526,9 @@ ufs_readdir(struct file *file, struct dir_context *ctx)
>   * previous entry.
>   */
>  int ufs_delete_entry(struct inode *inode, struct ufs_dir_entry *dir,
> -                  struct page * page)
> +                  struct page *page, char *kaddr)
>  {
>       struct super_block *sb = inode->i_sb;
> -     char *kaddr = page_address(page);
>       unsigned from = ((char*)dir - kaddr) & ~(UFS_SB(sb)->s_uspi-
>s_dirblksize -
> 1); unsigned to = ((char*)dir - kaddr) + fs16_to_cpu(sb, dir->d_reclen);
> loff_t pos;
> @@ -522,7 +554,7 @@ int ufs_delete_entry(struct inode *inode, struct
> ufs_dir_entry *dir, de = ufs_next_entry(sb, de);
>       }
>       if (pde)
> -             from = (char*)pde - (char*)page_address(page);
> +             from = (char *)pde - kaddr;
>
>       pos = page_offset(page) + from;
>       lock_page(page);
> @@ -535,7 +567,7 @@ int ufs_delete_entry(struct inode *inode, struct
> ufs_dir_entry *dir, inode->i_ctime = inode->i_mtime = current_time(inode);
>       mark_inode_dirty(inode);
>  out:
> -     ufs_put_page(page);
> +     ufs_put_page(page, kaddr);
>       UFSD("EXIT\n");
>       return err;
>  }
> @@ -559,8 +591,7 @@ int ufs_make_empty(struct inode * inode, struct inode
> *dir) goto fail;
>       }
>
> -     kmap(page);
> -     base = (char*)page_address(page);
> +     base = kmap_local_page(page);
>       memset(base, 0, PAGE_SIZE);
>
>       de = (struct ufs_dir_entry *) base;
> @@ -577,7 +608,7 @@ int ufs_make_empty(struct inode * inode, struct inode
> *dir) de->d_reclen = cpu_to_fs16(sb, chunk_size - UFS_DIR_REC_LEN(1));
>       ufs_set_de_namlen(sb, de, 2);
>       strcpy (de->d_name, "..");
> -     kunmap(page);
> +     kunmap_local(base);
>
>       err = ufs_commit_chunk(page, 0, chunk_size);
>  fail:
> @@ -592,17 +623,18 @@ int ufs_empty_dir(struct inode * inode)
>  {
>       struct super_block *sb = inode->i_sb;
>       struct page *page = NULL;
> +     void *page_addr;
>       unsigned long i, npages = dir_pages(inode);
>
>       for (i = 0; i < npages; i++) {
>               char *kaddr;
>               struct ufs_dir_entry *de;
> -             page = ufs_get_page(inode, i);
>
> +             page = ufs_get_page(inode, i, &page_addr);
>               if (IS_ERR(page))
>                       continue;
>
> -             kaddr = page_address(page);
> +             kaddr = page_addr;
>               de = (struct ufs_dir_entry *)kaddr;
>               kaddr += ufs_last_byte(inode, i) - UFS_DIR_REC_LEN(1);
>
> @@ -629,12 +661,12 @@ int ufs_empty_dir(struct inode * inode)
>                       }
>                       de = ufs_next_entry(sb, de);
>               }
> -             ufs_put_page(page);
> +             ufs_put_page(page, page_addr);
>       }
>       return 1;
>
>  not_empty:
> -     ufs_put_page(page);
> +     ufs_put_page(page, page_addr);
>       return 0;
>  }
>
> diff --git a/fs/ufs/namei.c b/fs/ufs/namei.c
> index 29d5a0e0c8f0..cdf3bcf9d02e 100644
> --- a/fs/ufs/namei.c
> +++ b/fs/ufs/namei.c
> @@ -210,13 +210,14 @@ static int ufs_unlink(struct inode *dir, struct dentry
> *dentry) struct inode * inode = d_inode(dentry);
>       struct ufs_dir_entry *de;
>       struct page *page;
> +     void *page_addr;
>       int err = -ENOENT;
>
> -     de = ufs_find_entry(dir, &dentry->d_name, &page);
> +     de = ufs_find_entry(dir, &dentry->d_name, &page, &page_addr);
>       if (!de)
>               goto out;
>
> -     err = ufs_delete_entry(dir, de, page);
> +     err = ufs_delete_entry(dir, de, page, page_addr);
>       if (err)
>               goto out;
>
> @@ -250,27 +251,31 @@ static int ufs_rename(struct user_namespace
*mnt_userns,
> struct inode *old_dir, struct inode *old_inode = d_inode(old_dentry);
>       struct inode *new_inode = d_inode(new_dentry);
>       struct page *dir_page = NULL;
> +     void *dir_page_addr;
>       struct ufs_dir_entry * dir_de = NULL;
>       struct page *old_page;
> +     void *old_page_addr;
>       struct ufs_dir_entry *old_de;
>       int err = -ENOENT;
>
>       if (flags & ~RENAME_NOREPLACE)
>               return -EINVAL;
>
> -     old_de = ufs_find_entry(old_dir, &old_dentry->d_name, &old_page);
> +     old_de = ufs_find_entry(old_dir, &old_dentry->d_name, &old_page,
> +                             &old_page_addr);
>       if (!old_de)
>               goto out;
>
>       if (S_ISDIR(old_inode->i_mode)) {
>               err = -EIO;
> -             dir_de = ufs_dotdot(old_inode, &dir_page);
> +             dir_de = ufs_dotdot(old_inode, &dir_page, &dir_page_addr);
>               if (!dir_de)
>                       goto out_old;
>       }
>
>       if (new_inode) {
>               struct page *new_page;
> +             void *new_page_addr;
>               struct ufs_dir_entry *new_de;
>
>               err = -ENOTEMPTY;
> @@ -278,10 +283,11 @@ static int ufs_rename(struct user_namespace
*mnt_userns,
> struct inode *old_dir, goto out_dir;
>
>               err = -ENOENT;
> -             new_de = ufs_find_entry(new_dir, &new_dentry->d_name,
&new_page);
> +             new_de = ufs_find_entry(new_dir, &new_dentry->d_name,
&new_page,
> +                                     &new_page_addr);
>               if (!new_de)
>                       goto out_dir;
> -             ufs_set_link(new_dir, new_de, new_page, old_inode, 1);
> +             ufs_set_link(new_dir, new_de, new_page, new_page_addr,
old_inode, 1);
>               new_inode->i_ctime = current_time(new_inode);
>               if (dir_de)
>                       drop_nlink(new_inode);
> @@ -300,29 +306,25 @@ static int ufs_rename(struct user_namespace
*mnt_userns,
> struct inode *old_dir, */
>       old_inode->i_ctime = current_time(old_inode);
>
> -     ufs_delete_entry(old_dir, old_de, old_page);
> +     ufs_delete_entry(old_dir, old_de, old_page, old_page_addr);
>       mark_inode_dirty(old_inode);
>
>       if (dir_de) {
>               if (old_dir != new_dir)
> -                     ufs_set_link(old_inode, dir_de, dir_page,
new_dir, 0);
> -             else {
> -                     kunmap(dir_page);
> -                     put_page(dir_page);
> -             }
> +                     ufs_set_link(old_inode, dir_de, dir_page,
> +                                  dir_page_addr, new_dir, 0);
> +             else
> +                     ufs_put_page(dir_page, dir_page_addr);
>               inode_dec_link_count(old_dir);
>       }
>       return 0;
>
>
>  out_dir:
> -     if (dir_de) {
> -             kunmap(dir_page);
> -             put_page(dir_page);
> -     }
> +     if (dir_de)
> +             ufs_put_page(dir_page, dir_page_addr);
>  out_old:
> -     kunmap(old_page);
> -     put_page(old_page);
> +     ufs_put_page(old_page, old_page_addr);
>  out:
>       return err;
>  }
> diff --git a/fs/ufs/ufs.h b/fs/ufs/ufs.h
> index 550f7c5a3636..20d224c163ab 100644
> --- a/fs/ufs/ufs.h
> +++ b/fs/ufs/ufs.h
> @@ -102,12 +102,16 @@ extern const struct inode_operations
> ufs_dir_inode_operations; extern int ufs_add_link (struct dentry *, struct
> inode *);
>  extern ino_t ufs_inode_by_name(struct inode *, const struct qstr *);
>  extern int ufs_make_empty(struct inode *, struct inode *);
> -extern struct ufs_dir_entry *ufs_find_entry(struct inode *, const struct
qstr
> *, struct page **); -extern int ufs_delete_entry(struct inode *, struct
> ufs_dir_entry *, struct page *); +extern struct ufs_dir_entry
> *ufs_find_entry(struct inode *dir, const struct qstr *qstr, +
                            struct
> page **res_page, void **res_page_addr);
> +extern int ufs_delete_entry(struct inode *inode, struct ufs_dir_entry *dir,
> +                         struct page *page, char *kaddr);
>  extern int ufs_empty_dir (struct inode *);
> -extern struct ufs_dir_entry *ufs_dotdot(struct inode *, struct page **);
> +extern struct ufs_dir_entry *ufs_dotdot(struct inode *dir, struct page **p,
> void **pa); extern void ufs_set_link(struct inode *dir, struct ufs_dir_entry
> *de, -                         struct page *page, struct inode *inode, bool
update_times);
> +                      struct page *page, void *page_addr,
> +                      struct inode *inode, bool update_times);
> +extern void ufs_put_page(struct page *page, void *page_addr);
>
>  /* file.c */
>  extern const struct inode_operations ufs_file_inode_operations;
> --
> 2.37.1

Powered by blists - more mailing lists