17336d0e6SThomas Gleixner // SPDX-License-Identifier: GPL-2.0-only 2b3b94faaSDavid Teigland /* 3b3b94faaSDavid Teigland * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved. 4da6dd40dSBob Peterson * Copyright (C) 2004-2007 Red Hat, Inc. All rights reserved. 5b3b94faaSDavid Teigland */ 6b3b94faaSDavid Teigland 7d77d1b58SJoe Perches #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 8d77d1b58SJoe Perches 99e6e0a12SSteven Whitehouse #include <linux/bio.h> 10174cd4b1SIngo Molnar #include <linux/sched/signal.h> 11b3b94faaSDavid Teigland #include <linux/slab.h> 12b3b94faaSDavid Teigland #include <linux/spinlock.h> 13b3b94faaSDavid Teigland #include <linux/completion.h> 14b3b94faaSDavid Teigland #include <linux/buffer_head.h> 159e6e0a12SSteven Whitehouse #include <linux/statfs.h> 169e6e0a12SSteven Whitehouse #include <linux/seq_file.h> 179e6e0a12SSteven Whitehouse #include <linux/mount.h> 189e6e0a12SSteven Whitehouse #include <linux/kthread.h> 199e6e0a12SSteven Whitehouse #include <linux/delay.h> 205c676f6dSSteven Whitehouse #include <linux/gfs2_ondisk.h> 219e6e0a12SSteven Whitehouse #include <linux/crc32.h> 229e6e0a12SSteven Whitehouse #include <linux/time.h> 23e402746aSSteven Whitehouse #include <linux/wait.h> 24a9185b41SChristoph Hellwig #include <linux/writeback.h> 254667a0ecSSteven Whitehouse #include <linux/backing-dev.h> 262e60d768SBenjamin Marzinski #include <linux/kernel.h> 27b3b94faaSDavid Teigland 28b3b94faaSDavid Teigland #include "gfs2.h" 295c676f6dSSteven Whitehouse #include "incore.h" 30b3b94faaSDavid Teigland #include "bmap.h" 31b3b94faaSDavid Teigland #include "dir.h" 32b3b94faaSDavid Teigland #include "glock.h" 33b3b94faaSDavid Teigland #include "glops.h" 34b3b94faaSDavid Teigland #include "inode.h" 35b3b94faaSDavid Teigland #include "log.h" 36b3b94faaSDavid Teigland #include "meta_io.h" 37b3b94faaSDavid Teigland #include "quota.h" 38b3b94faaSDavid Teigland #include "recovery.h" 39b3b94faaSDavid Teigland #include "rgrp.h" 40b3b94faaSDavid Teigland #include "super.h" 41b3b94faaSDavid Teigland #include "trans.h" 425c676f6dSSteven Whitehouse #include "util.h" 439e6e0a12SSteven Whitehouse #include "sys.h" 44307cf6e6SSteven Whitehouse #include "xattr.h" 45f4686c26SAbhi Das #include "lops.h" 469e6e0a12SSteven Whitehouse 4753dbc27eSBob Peterson enum dinode_demise { 4853dbc27eSBob Peterson SHOULD_DELETE_DINODE, 4953dbc27eSBob Peterson SHOULD_NOT_DELETE_DINODE, 5053dbc27eSBob Peterson SHOULD_DEFER_EVICTION, 5153dbc27eSBob Peterson }; 5253dbc27eSBob Peterson 53fefc03bfSSteven Whitehouse /** 54fefc03bfSSteven Whitehouse * gfs2_jindex_free - Clear all the journal index information 55fefc03bfSSteven Whitehouse * @sdp: The GFS2 superblock 56fefc03bfSSteven Whitehouse * 57fefc03bfSSteven Whitehouse */ 58fefc03bfSSteven Whitehouse 59fefc03bfSSteven Whitehouse void gfs2_jindex_free(struct gfs2_sbd *sdp) 60fefc03bfSSteven Whitehouse { 61b50f227bSSteven Whitehouse struct list_head list; 62fefc03bfSSteven Whitehouse struct gfs2_jdesc *jd; 63fefc03bfSSteven Whitehouse 64fefc03bfSSteven Whitehouse spin_lock(&sdp->sd_jindex_spin); 65fefc03bfSSteven Whitehouse list_add(&list, &sdp->sd_jindex_list); 66fefc03bfSSteven Whitehouse list_del_init(&sdp->sd_jindex_list); 67fefc03bfSSteven Whitehouse sdp->sd_journals = 0; 68fefc03bfSSteven Whitehouse spin_unlock(&sdp->sd_jindex_spin); 69fefc03bfSSteven Whitehouse 70601ef0d5SBob Peterson sdp->sd_jdesc = NULL; 71fefc03bfSSteven Whitehouse while (!list_empty(&list)) { 72969183bcSAndreas Gruenbacher jd = list_first_entry(&list, struct gfs2_jdesc, jd_list); 73b50f227bSSteven Whitehouse gfs2_free_journal_extents(jd); 74fefc03bfSSteven Whitehouse list_del(&jd->jd_list); 75fefc03bfSSteven Whitehouse iput(jd->jd_inode); 76601ef0d5SBob Peterson jd->jd_inode = NULL; 77fefc03bfSSteven Whitehouse kfree(jd); 78fefc03bfSSteven Whitehouse } 79fefc03bfSSteven Whitehouse } 80fefc03bfSSteven Whitehouse 81b3b94faaSDavid Teigland static struct gfs2_jdesc *jdesc_find_i(struct list_head *head, unsigned int jid) 82b3b94faaSDavid Teigland { 83b3b94faaSDavid Teigland struct gfs2_jdesc *jd; 84b3b94faaSDavid Teigland int found = 0; 85b3b94faaSDavid Teigland 86b3b94faaSDavid Teigland list_for_each_entry(jd, head, jd_list) { 87b3b94faaSDavid Teigland if (jd->jd_jid == jid) { 88b3b94faaSDavid Teigland found = 1; 89b3b94faaSDavid Teigland break; 90b3b94faaSDavid Teigland } 91b3b94faaSDavid Teigland } 92b3b94faaSDavid Teigland 93b3b94faaSDavid Teigland if (!found) 94b3b94faaSDavid Teigland jd = NULL; 95b3b94faaSDavid Teigland 96b3b94faaSDavid Teigland return jd; 97b3b94faaSDavid Teigland } 98b3b94faaSDavid Teigland 99b3b94faaSDavid Teigland struct gfs2_jdesc *gfs2_jdesc_find(struct gfs2_sbd *sdp, unsigned int jid) 100b3b94faaSDavid Teigland { 101b3b94faaSDavid Teigland struct gfs2_jdesc *jd; 102b3b94faaSDavid Teigland 103b3b94faaSDavid Teigland spin_lock(&sdp->sd_jindex_spin); 104b3b94faaSDavid Teigland jd = jdesc_find_i(&sdp->sd_jindex_list, jid); 105b3b94faaSDavid Teigland spin_unlock(&sdp->sd_jindex_spin); 106b3b94faaSDavid Teigland 107b3b94faaSDavid Teigland return jd; 108b3b94faaSDavid Teigland } 109b3b94faaSDavid Teigland 110b3b94faaSDavid Teigland int gfs2_jdesc_check(struct gfs2_jdesc *jd) 111b3b94faaSDavid Teigland { 112feaa7bbaSSteven Whitehouse struct gfs2_inode *ip = GFS2_I(jd->jd_inode); 113feaa7bbaSSteven Whitehouse struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode); 114a2e0f799SSteven Whitehouse u64 size = i_size_read(jd->jd_inode); 115b3b94faaSDavid Teigland 11647a9a527SFabian Frederick if (gfs2_check_internal_file_size(jd->jd_inode, 8 << 20, BIT(30))) 117b3b94faaSDavid Teigland return -EIO; 118b3b94faaSDavid Teigland 119a2e0f799SSteven Whitehouse jd->jd_blocks = size >> sdp->sd_sb.sb_bsize_shift; 120a2e0f799SSteven Whitehouse 121a2e0f799SSteven Whitehouse if (gfs2_write_alloc_required(ip, 0, size)) { 122b3b94faaSDavid Teigland gfs2_consist_inode(ip); 123461cb419SBob Peterson return -EIO; 124b3b94faaSDavid Teigland } 125b3b94faaSDavid Teigland 126461cb419SBob Peterson return 0; 127b3b94faaSDavid Teigland } 128b3b94faaSDavid Teigland 1298ad151c2SSteven Whitehouse static int init_threads(struct gfs2_sbd *sdp) 1308ad151c2SSteven Whitehouse { 1318ad151c2SSteven Whitehouse struct task_struct *p; 1328ad151c2SSteven Whitehouse int error = 0; 1338ad151c2SSteven Whitehouse 1348ad151c2SSteven Whitehouse p = kthread_run(gfs2_logd, sdp, "gfs2_logd"); 1358ad151c2SSteven Whitehouse if (IS_ERR(p)) { 1368ad151c2SSteven Whitehouse error = PTR_ERR(p); 1378ad151c2SSteven Whitehouse fs_err(sdp, "can't start logd thread: %d\n", error); 1388ad151c2SSteven Whitehouse return error; 1398ad151c2SSteven Whitehouse } 1408ad151c2SSteven Whitehouse sdp->sd_logd_process = p; 1418ad151c2SSteven Whitehouse 1428ad151c2SSteven Whitehouse p = kthread_run(gfs2_quotad, sdp, "gfs2_quotad"); 1438ad151c2SSteven Whitehouse if (IS_ERR(p)) { 1448ad151c2SSteven Whitehouse error = PTR_ERR(p); 1458ad151c2SSteven Whitehouse fs_err(sdp, "can't start quotad thread: %d\n", error); 1468ad151c2SSteven Whitehouse goto fail; 1478ad151c2SSteven Whitehouse } 1488ad151c2SSteven Whitehouse sdp->sd_quotad_process = p; 1498ad151c2SSteven Whitehouse return 0; 1508ad151c2SSteven Whitehouse 1518ad151c2SSteven Whitehouse fail: 1528ad151c2SSteven Whitehouse kthread_stop(sdp->sd_logd_process); 1535b3a9f34SBob Peterson sdp->sd_logd_process = NULL; 1548ad151c2SSteven Whitehouse return error; 1558ad151c2SSteven Whitehouse } 1568ad151c2SSteven Whitehouse 157b3b94faaSDavid Teigland /** 158b3b94faaSDavid Teigland * gfs2_make_fs_rw - Turn a Read-Only FS into a Read-Write one 159b3b94faaSDavid Teigland * @sdp: the filesystem 160b3b94faaSDavid Teigland * 161b3b94faaSDavid Teigland * Returns: errno 162b3b94faaSDavid Teigland */ 163b3b94faaSDavid Teigland 164b3b94faaSDavid Teigland int gfs2_make_fs_rw(struct gfs2_sbd *sdp) 165b3b94faaSDavid Teigland { 166feaa7bbaSSteven Whitehouse struct gfs2_inode *ip = GFS2_I(sdp->sd_jdesc->jd_inode); 1675c676f6dSSteven Whitehouse struct gfs2_glock *j_gl = ip->i_gl; 1682e60d768SBenjamin Marzinski struct gfs2_holder freeze_gh; 16955167622SAl Viro struct gfs2_log_header_host head; 170b3b94faaSDavid Teigland int error; 171b3b94faaSDavid Teigland 1728ad151c2SSteven Whitehouse error = init_threads(sdp); 173b3b94faaSDavid Teigland if (error) 174b3b94faaSDavid Teigland return error; 175b3b94faaSDavid Teigland 176c860f8ffSBob Peterson error = gfs2_glock_nq_init(sdp->sd_freeze_gl, LM_ST_SHARED, 177c860f8ffSBob Peterson LM_FLAG_NOEXP | GL_EXACT, 1782e60d768SBenjamin Marzinski &freeze_gh); 1798ad151c2SSteven Whitehouse if (error) 1808ad151c2SSteven Whitehouse goto fail_threads; 1818ad151c2SSteven Whitehouse 1821a14d3a6SSteven Whitehouse j_gl->gl_ops->go_inval(j_gl, DIO_METADATA); 183601ef0d5SBob Peterson if (gfs2_withdrawn(sdp)) { 184601ef0d5SBob Peterson error = -EIO; 185601ef0d5SBob Peterson goto fail; 186601ef0d5SBob Peterson } 187b3b94faaSDavid Teigland 188f4686c26SAbhi Das error = gfs2_find_jhead(sdp->sd_jdesc, &head, false); 189601ef0d5SBob Peterson if (error || gfs2_withdrawn(sdp)) 190b3b94faaSDavid Teigland goto fail; 191b3b94faaSDavid Teigland 192b3b94faaSDavid Teigland if (!(head.lh_flags & GFS2_LOG_HEAD_UNMOUNT)) { 193b3b94faaSDavid Teigland gfs2_consist(sdp); 194b3b94faaSDavid Teigland error = -EIO; 195b3b94faaSDavid Teigland goto fail; 196b3b94faaSDavid Teigland } 197b3b94faaSDavid Teigland 198b3b94faaSDavid Teigland /* Initialize some head of the log stuff */ 199b3b94faaSDavid Teigland sdp->sd_log_sequence = head.lh_sequence + 1; 200b3b94faaSDavid Teigland gfs2_log_pointers_init(sdp, head.lh_blkno); 201b3b94faaSDavid Teigland 202b3b94faaSDavid Teigland error = gfs2_quota_init(sdp); 203601ef0d5SBob Peterson if (error || gfs2_withdrawn(sdp)) 204a91ea69fSSteven Whitehouse goto fail; 205b3b94faaSDavid Teigland 206b3b94faaSDavid Teigland set_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags); 207b3b94faaSDavid Teigland 2082e60d768SBenjamin Marzinski gfs2_glock_dq_uninit(&freeze_gh); 209b3b94faaSDavid Teigland 210b3b94faaSDavid Teigland return 0; 211b3b94faaSDavid Teigland 212b3b94faaSDavid Teigland fail: 2132e60d768SBenjamin Marzinski gfs2_glock_dq_uninit(&freeze_gh); 2148ad151c2SSteven Whitehouse fail_threads: 2155b3a9f34SBob Peterson if (sdp->sd_quotad_process) 2168ad151c2SSteven Whitehouse kthread_stop(sdp->sd_quotad_process); 2175b3a9f34SBob Peterson sdp->sd_quotad_process = NULL; 2185b3a9f34SBob Peterson if (sdp->sd_logd_process) 2198ad151c2SSteven Whitehouse kthread_stop(sdp->sd_logd_process); 2205b3a9f34SBob Peterson sdp->sd_logd_process = NULL; 221b3b94faaSDavid Teigland return error; 222b3b94faaSDavid Teigland } 223b3b94faaSDavid Teigland 2241946f70aSBenjamin Marzinski void gfs2_statfs_change_in(struct gfs2_statfs_change_host *sc, const void *buf) 225bb8d8a6fSSteven Whitehouse { 226bb8d8a6fSSteven Whitehouse const struct gfs2_statfs_change *str = buf; 227bb8d8a6fSSteven Whitehouse 228bb8d8a6fSSteven Whitehouse sc->sc_total = be64_to_cpu(str->sc_total); 229bb8d8a6fSSteven Whitehouse sc->sc_free = be64_to_cpu(str->sc_free); 230bb8d8a6fSSteven Whitehouse sc->sc_dinodes = be64_to_cpu(str->sc_dinodes); 231bb8d8a6fSSteven Whitehouse } 232bb8d8a6fSSteven Whitehouse 23373092698SAbhi Das void gfs2_statfs_change_out(const struct gfs2_statfs_change_host *sc, void *buf) 234bb8d8a6fSSteven Whitehouse { 235bb8d8a6fSSteven Whitehouse struct gfs2_statfs_change *str = buf; 236bb8d8a6fSSteven Whitehouse 237bb8d8a6fSSteven Whitehouse str->sc_total = cpu_to_be64(sc->sc_total); 238bb8d8a6fSSteven Whitehouse str->sc_free = cpu_to_be64(sc->sc_free); 239bb8d8a6fSSteven Whitehouse str->sc_dinodes = cpu_to_be64(sc->sc_dinodes); 240bb8d8a6fSSteven Whitehouse } 241bb8d8a6fSSteven Whitehouse 242b3b94faaSDavid Teigland int gfs2_statfs_init(struct gfs2_sbd *sdp) 243b3b94faaSDavid Teigland { 244feaa7bbaSSteven Whitehouse struct gfs2_inode *m_ip = GFS2_I(sdp->sd_statfs_inode); 245bd209cc0SAl Viro struct gfs2_statfs_change_host *m_sc = &sdp->sd_statfs_master; 246feaa7bbaSSteven Whitehouse struct gfs2_inode *l_ip = GFS2_I(sdp->sd_sc_inode); 247bd209cc0SAl Viro struct gfs2_statfs_change_host *l_sc = &sdp->sd_statfs_local; 248b3b94faaSDavid Teigland struct buffer_head *m_bh, *l_bh; 249b3b94faaSDavid Teigland struct gfs2_holder gh; 250b3b94faaSDavid Teigland int error; 251b3b94faaSDavid Teigland 252b3b94faaSDavid Teigland error = gfs2_glock_nq_init(m_ip->i_gl, LM_ST_EXCLUSIVE, GL_NOCACHE, 253b3b94faaSDavid Teigland &gh); 254b3b94faaSDavid Teigland if (error) 255b3b94faaSDavid Teigland return error; 256b3b94faaSDavid Teigland 257b3b94faaSDavid Teigland error = gfs2_meta_inode_buffer(m_ip, &m_bh); 258b3b94faaSDavid Teigland if (error) 259b3b94faaSDavid Teigland goto out; 260b3b94faaSDavid Teigland 261b3b94faaSDavid Teigland if (sdp->sd_args.ar_spectator) { 262b3b94faaSDavid Teigland spin_lock(&sdp->sd_statfs_spin); 263b3b94faaSDavid Teigland gfs2_statfs_change_in(m_sc, m_bh->b_data + 264b3b94faaSDavid Teigland sizeof(struct gfs2_dinode)); 265b3b94faaSDavid Teigland spin_unlock(&sdp->sd_statfs_spin); 266b3b94faaSDavid Teigland } else { 267b3b94faaSDavid Teigland error = gfs2_meta_inode_buffer(l_ip, &l_bh); 268b3b94faaSDavid Teigland if (error) 269b3b94faaSDavid Teigland goto out_m_bh; 270b3b94faaSDavid Teigland 271b3b94faaSDavid Teigland spin_lock(&sdp->sd_statfs_spin); 272b3b94faaSDavid Teigland gfs2_statfs_change_in(m_sc, m_bh->b_data + 273b3b94faaSDavid Teigland sizeof(struct gfs2_dinode)); 274b3b94faaSDavid Teigland gfs2_statfs_change_in(l_sc, l_bh->b_data + 275b3b94faaSDavid Teigland sizeof(struct gfs2_dinode)); 276b3b94faaSDavid Teigland spin_unlock(&sdp->sd_statfs_spin); 277b3b94faaSDavid Teigland 278b3b94faaSDavid Teigland brelse(l_bh); 279b3b94faaSDavid Teigland } 280b3b94faaSDavid Teigland 281b3b94faaSDavid Teigland out_m_bh: 282b3b94faaSDavid Teigland brelse(m_bh); 283b3b94faaSDavid Teigland out: 284b3b94faaSDavid Teigland gfs2_glock_dq_uninit(&gh); 285b3b94faaSDavid Teigland return 0; 286b3b94faaSDavid Teigland } 287b3b94faaSDavid Teigland 288cd915493SSteven Whitehouse void gfs2_statfs_change(struct gfs2_sbd *sdp, s64 total, s64 free, 289cd915493SSteven Whitehouse s64 dinodes) 290b3b94faaSDavid Teigland { 291feaa7bbaSSteven Whitehouse struct gfs2_inode *l_ip = GFS2_I(sdp->sd_sc_inode); 292bd209cc0SAl Viro struct gfs2_statfs_change_host *l_sc = &sdp->sd_statfs_local; 2933d3c10f2SBenjamin Marzinski struct gfs2_statfs_change_host *m_sc = &sdp->sd_statfs_master; 294b3b94faaSDavid Teigland struct buffer_head *l_bh; 295c14f5735SBenjamin Marzinski s64 x, y; 296c14f5735SBenjamin Marzinski int need_sync = 0; 297b3b94faaSDavid Teigland int error; 298b3b94faaSDavid Teigland 299b3b94faaSDavid Teigland error = gfs2_meta_inode_buffer(l_ip, &l_bh); 300b3b94faaSDavid Teigland if (error) 301b3b94faaSDavid Teigland return; 302b3b94faaSDavid Teigland 303350a9b0aSSteven Whitehouse gfs2_trans_add_meta(l_ip->i_gl, l_bh); 304b3b94faaSDavid Teigland 305b3b94faaSDavid Teigland spin_lock(&sdp->sd_statfs_spin); 306b3b94faaSDavid Teigland l_sc->sc_total += total; 307b3b94faaSDavid Teigland l_sc->sc_free += free; 308b3b94faaSDavid Teigland l_sc->sc_dinodes += dinodes; 309907b9bceSSteven Whitehouse gfs2_statfs_change_out(l_sc, l_bh->b_data + sizeof(struct gfs2_dinode)); 310c14f5735SBenjamin Marzinski if (sdp->sd_args.ar_statfs_percent) { 311c14f5735SBenjamin Marzinski x = 100 * l_sc->sc_free; 312c14f5735SBenjamin Marzinski y = m_sc->sc_free * sdp->sd_args.ar_statfs_percent; 313c14f5735SBenjamin Marzinski if (x >= y || x <= -y) 314c14f5735SBenjamin Marzinski need_sync = 1; 315c14f5735SBenjamin Marzinski } 316b3b94faaSDavid Teigland spin_unlock(&sdp->sd_statfs_spin); 317b3b94faaSDavid Teigland 318b3b94faaSDavid Teigland brelse(l_bh); 319c14f5735SBenjamin Marzinski if (need_sync) 3203d3c10f2SBenjamin Marzinski gfs2_wake_up_statfs(sdp); 321b3b94faaSDavid Teigland } 322b3b94faaSDavid Teigland 3231946f70aSBenjamin Marzinski void update_statfs(struct gfs2_sbd *sdp, struct buffer_head *m_bh, 3241946f70aSBenjamin Marzinski struct buffer_head *l_bh) 3251946f70aSBenjamin Marzinski { 3261946f70aSBenjamin Marzinski struct gfs2_inode *m_ip = GFS2_I(sdp->sd_statfs_inode); 3271946f70aSBenjamin Marzinski struct gfs2_inode *l_ip = GFS2_I(sdp->sd_sc_inode); 3281946f70aSBenjamin Marzinski struct gfs2_statfs_change_host *m_sc = &sdp->sd_statfs_master; 3291946f70aSBenjamin Marzinski struct gfs2_statfs_change_host *l_sc = &sdp->sd_statfs_local; 3301946f70aSBenjamin Marzinski 331350a9b0aSSteven Whitehouse gfs2_trans_add_meta(l_ip->i_gl, l_bh); 332901c6c66SBob Peterson gfs2_trans_add_meta(m_ip->i_gl, m_bh); 3331946f70aSBenjamin Marzinski 3341946f70aSBenjamin Marzinski spin_lock(&sdp->sd_statfs_spin); 3351946f70aSBenjamin Marzinski m_sc->sc_total += l_sc->sc_total; 3361946f70aSBenjamin Marzinski m_sc->sc_free += l_sc->sc_free; 3371946f70aSBenjamin Marzinski m_sc->sc_dinodes += l_sc->sc_dinodes; 3381946f70aSBenjamin Marzinski memset(l_sc, 0, sizeof(struct gfs2_statfs_change)); 3391946f70aSBenjamin Marzinski memset(l_bh->b_data + sizeof(struct gfs2_dinode), 3401946f70aSBenjamin Marzinski 0, sizeof(struct gfs2_statfs_change)); 3411946f70aSBenjamin Marzinski gfs2_statfs_change_out(m_sc, m_bh->b_data + sizeof(struct gfs2_dinode)); 342901c6c66SBob Peterson spin_unlock(&sdp->sd_statfs_spin); 3431946f70aSBenjamin Marzinski } 3441946f70aSBenjamin Marzinski 3458c42d637SSteven Whitehouse int gfs2_statfs_sync(struct super_block *sb, int type) 346b3b94faaSDavid Teigland { 3478c42d637SSteven Whitehouse struct gfs2_sbd *sdp = sb->s_fs_info; 348feaa7bbaSSteven Whitehouse struct gfs2_inode *m_ip = GFS2_I(sdp->sd_statfs_inode); 349feaa7bbaSSteven Whitehouse struct gfs2_inode *l_ip = GFS2_I(sdp->sd_sc_inode); 350bd209cc0SAl Viro struct gfs2_statfs_change_host *m_sc = &sdp->sd_statfs_master; 351bd209cc0SAl Viro struct gfs2_statfs_change_host *l_sc = &sdp->sd_statfs_local; 352b3b94faaSDavid Teigland struct gfs2_holder gh; 353b3b94faaSDavid Teigland struct buffer_head *m_bh, *l_bh; 354b3b94faaSDavid Teigland int error; 355b3b94faaSDavid Teigland 3562e60d768SBenjamin Marzinski sb_start_write(sb); 357b3b94faaSDavid Teigland error = gfs2_glock_nq_init(m_ip->i_gl, LM_ST_EXCLUSIVE, GL_NOCACHE, 358b3b94faaSDavid Teigland &gh); 359b3b94faaSDavid Teigland if (error) 3602e60d768SBenjamin Marzinski goto out; 361b3b94faaSDavid Teigland 362b3b94faaSDavid Teigland error = gfs2_meta_inode_buffer(m_ip, &m_bh); 363b3b94faaSDavid Teigland if (error) 3642e60d768SBenjamin Marzinski goto out_unlock; 365b3b94faaSDavid Teigland 366b3b94faaSDavid Teigland spin_lock(&sdp->sd_statfs_spin); 367b3b94faaSDavid Teigland gfs2_statfs_change_in(m_sc, m_bh->b_data + 368b3b94faaSDavid Teigland sizeof(struct gfs2_dinode)); 369b3b94faaSDavid Teigland if (!l_sc->sc_total && !l_sc->sc_free && !l_sc->sc_dinodes) { 370b3b94faaSDavid Teigland spin_unlock(&sdp->sd_statfs_spin); 371b3b94faaSDavid Teigland goto out_bh; 372b3b94faaSDavid Teigland } 373b3b94faaSDavid Teigland spin_unlock(&sdp->sd_statfs_spin); 374b3b94faaSDavid Teigland 375b3b94faaSDavid Teigland error = gfs2_meta_inode_buffer(l_ip, &l_bh); 376b3b94faaSDavid Teigland if (error) 377b3b94faaSDavid Teigland goto out_bh; 378b3b94faaSDavid Teigland 379b3b94faaSDavid Teigland error = gfs2_trans_begin(sdp, 2 * RES_DINODE, 0); 380b3b94faaSDavid Teigland if (error) 381b3b94faaSDavid Teigland goto out_bh2; 382b3b94faaSDavid Teigland 3831946f70aSBenjamin Marzinski update_statfs(sdp, m_bh, l_bh); 3843d3c10f2SBenjamin Marzinski sdp->sd_statfs_force_sync = 0; 385b3b94faaSDavid Teigland 386b3b94faaSDavid Teigland gfs2_trans_end(sdp); 387b3b94faaSDavid Teigland 388b3b94faaSDavid Teigland out_bh2: 389b3b94faaSDavid Teigland brelse(l_bh); 390b3b94faaSDavid Teigland out_bh: 391b3b94faaSDavid Teigland brelse(m_bh); 3922e60d768SBenjamin Marzinski out_unlock: 393b3b94faaSDavid Teigland gfs2_glock_dq_uninit(&gh); 3942e60d768SBenjamin Marzinski out: 3952e60d768SBenjamin Marzinski sb_end_write(sb); 396b3b94faaSDavid Teigland return error; 397b3b94faaSDavid Teigland } 398b3b94faaSDavid Teigland 399b3b94faaSDavid Teigland struct lfcc { 400b3b94faaSDavid Teigland struct list_head list; 401b3b94faaSDavid Teigland struct gfs2_holder gh; 402b3b94faaSDavid Teigland }; 403b3b94faaSDavid Teigland 404b3b94faaSDavid Teigland /** 405b3b94faaSDavid Teigland * gfs2_lock_fs_check_clean - Stop all writes to the FS and check that all 406b3b94faaSDavid Teigland * journals are clean 407b3b94faaSDavid Teigland * @sdp: the file system 408b3b94faaSDavid Teigland * @state: the state to put the transaction lock into 409b3b94faaSDavid Teigland * @t_gh: the hold on the transaction lock 410b3b94faaSDavid Teigland * 411b3b94faaSDavid Teigland * Returns: errno 412b3b94faaSDavid Teigland */ 413b3b94faaSDavid Teigland 41452b1cdcbSBob Peterson static int gfs2_lock_fs_check_clean(struct gfs2_sbd *sdp) 415b3b94faaSDavid Teigland { 4165c676f6dSSteven Whitehouse struct gfs2_inode *ip; 417b3b94faaSDavid Teigland struct gfs2_jdesc *jd; 418b3b94faaSDavid Teigland struct lfcc *lfcc; 419b3b94faaSDavid Teigland LIST_HEAD(list); 42055167622SAl Viro struct gfs2_log_header_host lh; 421b3b94faaSDavid Teigland int error; 422b3b94faaSDavid Teigland 423b3b94faaSDavid Teigland list_for_each_entry(jd, &sdp->sd_jindex_list, jd_list) { 424b3b94faaSDavid Teigland lfcc = kmalloc(sizeof(struct lfcc), GFP_KERNEL); 425b3b94faaSDavid Teigland if (!lfcc) { 426b3b94faaSDavid Teigland error = -ENOMEM; 427b3b94faaSDavid Teigland goto out; 428b3b94faaSDavid Teigland } 429feaa7bbaSSteven Whitehouse ip = GFS2_I(jd->jd_inode); 430feaa7bbaSSteven Whitehouse error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, 0, &lfcc->gh); 431b3b94faaSDavid Teigland if (error) { 432b3b94faaSDavid Teigland kfree(lfcc); 433b3b94faaSDavid Teigland goto out; 434b3b94faaSDavid Teigland } 435b3b94faaSDavid Teigland list_add(&lfcc->list, &list); 436b3b94faaSDavid Teigland } 437b3b94faaSDavid Teigland 43824972557SBenjamin Marzinski error = gfs2_glock_nq_init(sdp->sd_freeze_gl, LM_ST_EXCLUSIVE, 439c860f8ffSBob Peterson LM_FLAG_NOEXP, &sdp->sd_freeze_gh); 44052b1cdcbSBob Peterson if (error) 44152b1cdcbSBob Peterson goto out; 442b3b94faaSDavid Teigland 443b3b94faaSDavid Teigland list_for_each_entry(jd, &sdp->sd_jindex_list, jd_list) { 444b3b94faaSDavid Teigland error = gfs2_jdesc_check(jd); 445b3b94faaSDavid Teigland if (error) 446b3b94faaSDavid Teigland break; 447f4686c26SAbhi Das error = gfs2_find_jhead(jd, &lh, false); 448b3b94faaSDavid Teigland if (error) 449b3b94faaSDavid Teigland break; 450b3b94faaSDavid Teigland if (!(lh.lh_flags & GFS2_LOG_HEAD_UNMOUNT)) { 451b3b94faaSDavid Teigland error = -EBUSY; 452b3b94faaSDavid Teigland break; 453b3b94faaSDavid Teigland } 454b3b94faaSDavid Teigland } 455b3b94faaSDavid Teigland 456b3b94faaSDavid Teigland if (error) 45752b1cdcbSBob Peterson gfs2_glock_dq_uninit(&sdp->sd_freeze_gh); 458b3b94faaSDavid Teigland 459b3b94faaSDavid Teigland out: 460b3b94faaSDavid Teigland while (!list_empty(&list)) { 461969183bcSAndreas Gruenbacher lfcc = list_first_entry(&list, struct lfcc, list); 462b3b94faaSDavid Teigland list_del(&lfcc->list); 463b3b94faaSDavid Teigland gfs2_glock_dq_uninit(&lfcc->gh); 464b3b94faaSDavid Teigland kfree(lfcc); 465b3b94faaSDavid Teigland } 466b3b94faaSDavid Teigland return error; 467b3b94faaSDavid Teigland } 468b3b94faaSDavid Teigland 4699eed04cdSSteven Whitehouse void gfs2_dinode_out(const struct gfs2_inode *ip, void *buf) 4709eed04cdSSteven Whitehouse { 4719eed04cdSSteven Whitehouse struct gfs2_dinode *str = buf; 4729eed04cdSSteven Whitehouse 4739eed04cdSSteven Whitehouse str->di_header.mh_magic = cpu_to_be32(GFS2_MAGIC); 4749eed04cdSSteven Whitehouse str->di_header.mh_type = cpu_to_be32(GFS2_METATYPE_DI); 4759eed04cdSSteven Whitehouse str->di_header.mh_format = cpu_to_be32(GFS2_FORMAT_DI); 4769eed04cdSSteven Whitehouse str->di_num.no_addr = cpu_to_be64(ip->i_no_addr); 4779eed04cdSSteven Whitehouse str->di_num.no_formal_ino = cpu_to_be64(ip->i_no_formal_ino); 4789eed04cdSSteven Whitehouse str->di_mode = cpu_to_be32(ip->i_inode.i_mode); 479d0546426SEric W. Biederman str->di_uid = cpu_to_be32(i_uid_read(&ip->i_inode)); 480d0546426SEric W. Biederman str->di_gid = cpu_to_be32(i_gid_read(&ip->i_inode)); 4819eed04cdSSteven Whitehouse str->di_nlink = cpu_to_be32(ip->i_inode.i_nlink); 4829eed04cdSSteven Whitehouse str->di_size = cpu_to_be64(i_size_read(&ip->i_inode)); 4839eed04cdSSteven Whitehouse str->di_blocks = cpu_to_be64(gfs2_get_inode_blocks(&ip->i_inode)); 4849eed04cdSSteven Whitehouse str->di_atime = cpu_to_be64(ip->i_inode.i_atime.tv_sec); 4859eed04cdSSteven Whitehouse str->di_mtime = cpu_to_be64(ip->i_inode.i_mtime.tv_sec); 4869eed04cdSSteven Whitehouse str->di_ctime = cpu_to_be64(ip->i_inode.i_ctime.tv_sec); 4879eed04cdSSteven Whitehouse 4889eed04cdSSteven Whitehouse str->di_goal_meta = cpu_to_be64(ip->i_goal); 4899eed04cdSSteven Whitehouse str->di_goal_data = cpu_to_be64(ip->i_goal); 4909eed04cdSSteven Whitehouse str->di_generation = cpu_to_be64(ip->i_generation); 4919eed04cdSSteven Whitehouse 4929eed04cdSSteven Whitehouse str->di_flags = cpu_to_be32(ip->i_diskflags); 4939eed04cdSSteven Whitehouse str->di_height = cpu_to_be16(ip->i_height); 4949eed04cdSSteven Whitehouse str->di_payload_format = cpu_to_be32(S_ISDIR(ip->i_inode.i_mode) && 4959eed04cdSSteven Whitehouse !(ip->i_diskflags & GFS2_DIF_EXHASH) ? 4969eed04cdSSteven Whitehouse GFS2_FORMAT_DE : 0); 4979eed04cdSSteven Whitehouse str->di_depth = cpu_to_be16(ip->i_depth); 4989eed04cdSSteven Whitehouse str->di_entries = cpu_to_be32(ip->i_entries); 4999eed04cdSSteven Whitehouse 5009eed04cdSSteven Whitehouse str->di_eattr = cpu_to_be64(ip->i_eattr); 5019eed04cdSSteven Whitehouse str->di_atime_nsec = cpu_to_be32(ip->i_inode.i_atime.tv_nsec); 5029eed04cdSSteven Whitehouse str->di_mtime_nsec = cpu_to_be32(ip->i_inode.i_mtime.tv_nsec); 5039eed04cdSSteven Whitehouse str->di_ctime_nsec = cpu_to_be32(ip->i_inode.i_ctime.tv_nsec); 5049eed04cdSSteven Whitehouse } 5059e6e0a12SSteven Whitehouse 5069e6e0a12SSteven Whitehouse /** 5079e6e0a12SSteven Whitehouse * gfs2_write_inode - Make sure the inode is stable on the disk 5089e6e0a12SSteven Whitehouse * @inode: The inode 5091027efaaSSteven Whitehouse * @wbc: The writeback control structure 5109e6e0a12SSteven Whitehouse * 5119e6e0a12SSteven Whitehouse * Returns: errno 5129e6e0a12SSteven Whitehouse */ 5139e6e0a12SSteven Whitehouse 514a9185b41SChristoph Hellwig static int gfs2_write_inode(struct inode *inode, struct writeback_control *wbc) 5159e6e0a12SSteven Whitehouse { 5169e6e0a12SSteven Whitehouse struct gfs2_inode *ip = GFS2_I(inode); 5179e6e0a12SSteven Whitehouse struct gfs2_sbd *sdp = GFS2_SB(inode); 5181027efaaSSteven Whitehouse struct address_space *metamapping = gfs2_glock2aspace(ip->i_gl); 519de1414a6SChristoph Hellwig struct backing_dev_info *bdi = inode_to_bdi(metamapping->host); 520ab9bbda0SSteven Whitehouse int ret = 0; 521adbc3ddfSBob Peterson bool flush_all = (wbc->sync_mode == WB_SYNC_ALL || gfs2_is_jdata(ip)); 5229e6e0a12SSteven Whitehouse 523adbc3ddfSBob Peterson if (flush_all) 524c1696fb8SBob Peterson gfs2_log_flush(GFS2_SB(inode), ip->i_gl, 525805c0907SBob Peterson GFS2_LOG_HEAD_FLUSH_NORMAL | 526805c0907SBob Peterson GFS2_LFC_WRITE_INODE); 527a88a341aSTejun Heo if (bdi->wb.dirty_exceeded) 5284667a0ecSSteven Whitehouse gfs2_ail1_flush(sdp, wbc); 5291d4ec642SSteven Whitehouse else 5301d4ec642SSteven Whitehouse filemap_fdatawrite(metamapping); 531adbc3ddfSBob Peterson if (flush_all) 5321027efaaSSteven Whitehouse ret = filemap_fdatawait(metamapping); 5331027efaaSSteven Whitehouse if (ret) 5341027efaaSSteven Whitehouse mark_inode_dirty_sync(inode); 535957a7acdSAbhi Das else { 536957a7acdSAbhi Das spin_lock(&inode->i_lock); 537957a7acdSAbhi Das if (!(inode->i_flags & I_DIRTY)) 538957a7acdSAbhi Das gfs2_ordered_del_inode(ip); 539957a7acdSAbhi Das spin_unlock(&inode->i_lock); 540957a7acdSAbhi Das } 5419e6e0a12SSteven Whitehouse return ret; 5429e6e0a12SSteven Whitehouse } 5439e6e0a12SSteven Whitehouse 5449e6e0a12SSteven Whitehouse /** 545ab9bbda0SSteven Whitehouse * gfs2_dirty_inode - check for atime updates 546ab9bbda0SSteven Whitehouse * @inode: The inode in question 547ab9bbda0SSteven Whitehouse * @flags: The type of dirty 548ab9bbda0SSteven Whitehouse * 549ab9bbda0SSteven Whitehouse * Unfortunately it can be called under any combination of inode 550ab9bbda0SSteven Whitehouse * glock and transaction lock, so we have to check carefully. 551ab9bbda0SSteven Whitehouse * 552ab9bbda0SSteven Whitehouse * At the moment this deals only with atime - it should be possible 553ab9bbda0SSteven Whitehouse * to expand that role in future, once a review of the locking has 554ab9bbda0SSteven Whitehouse * been carried out. 555ab9bbda0SSteven Whitehouse */ 556ab9bbda0SSteven Whitehouse 557ab9bbda0SSteven Whitehouse static void gfs2_dirty_inode(struct inode *inode, int flags) 558ab9bbda0SSteven Whitehouse { 559ab9bbda0SSteven Whitehouse struct gfs2_inode *ip = GFS2_I(inode); 560ab9bbda0SSteven Whitehouse struct gfs2_sbd *sdp = GFS2_SB(inode); 561ab9bbda0SSteven Whitehouse struct buffer_head *bh; 562ab9bbda0SSteven Whitehouse struct gfs2_holder gh; 563ab9bbda0SSteven Whitehouse int need_unlock = 0; 564ab9bbda0SSteven Whitehouse int need_endtrans = 0; 565ab9bbda0SSteven Whitehouse int ret; 566ab9bbda0SSteven Whitehouse 5670e11f644SChristoph Hellwig if (!(flags & I_DIRTY_INODE)) 568ab9bbda0SSteven Whitehouse return; 569eb43e660SBob Peterson if (unlikely(gfs2_withdrawn(sdp))) 5700d1c7ae9SBob Peterson return; 571ab9bbda0SSteven Whitehouse if (!gfs2_glock_is_locked_by_me(ip->i_gl)) { 572ab9bbda0SSteven Whitehouse ret = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh); 573ab9bbda0SSteven Whitehouse if (ret) { 574ab9bbda0SSteven Whitehouse fs_err(sdp, "dirty_inode: glock %d\n", ret); 575e28c02b9SBob Peterson gfs2_dump_glock(NULL, ip->i_gl, true); 576ab9bbda0SSteven Whitehouse return; 577ab9bbda0SSteven Whitehouse } 578ab9bbda0SSteven Whitehouse need_unlock = 1; 5793d162688SBenjamin Marzinski } else if (WARN_ON_ONCE(ip->i_gl->gl_state != LM_ST_EXCLUSIVE)) 5803d162688SBenjamin Marzinski return; 581ab9bbda0SSteven Whitehouse 582ab9bbda0SSteven Whitehouse if (current->journal_info == NULL) { 583ab9bbda0SSteven Whitehouse ret = gfs2_trans_begin(sdp, RES_DINODE, 0); 584ab9bbda0SSteven Whitehouse if (ret) { 585ab9bbda0SSteven Whitehouse fs_err(sdp, "dirty_inode: gfs2_trans_begin %d\n", ret); 586ab9bbda0SSteven Whitehouse goto out; 587ab9bbda0SSteven Whitehouse } 588ab9bbda0SSteven Whitehouse need_endtrans = 1; 589ab9bbda0SSteven Whitehouse } 590ab9bbda0SSteven Whitehouse 591ab9bbda0SSteven Whitehouse ret = gfs2_meta_inode_buffer(ip, &bh); 592ab9bbda0SSteven Whitehouse if (ret == 0) { 593350a9b0aSSteven Whitehouse gfs2_trans_add_meta(ip->i_gl, bh); 594ab9bbda0SSteven Whitehouse gfs2_dinode_out(ip, bh->b_data); 595ab9bbda0SSteven Whitehouse brelse(bh); 596ab9bbda0SSteven Whitehouse } 597ab9bbda0SSteven Whitehouse 598ab9bbda0SSteven Whitehouse if (need_endtrans) 599ab9bbda0SSteven Whitehouse gfs2_trans_end(sdp); 600ab9bbda0SSteven Whitehouse out: 601ab9bbda0SSteven Whitehouse if (need_unlock) 602ab9bbda0SSteven Whitehouse gfs2_glock_dq_uninit(&gh); 603ab9bbda0SSteven Whitehouse } 604ab9bbda0SSteven Whitehouse 605ab9bbda0SSteven Whitehouse /** 6069e6e0a12SSteven Whitehouse * gfs2_make_fs_ro - Turn a Read-Write FS into a Read-Only one 6079e6e0a12SSteven Whitehouse * @sdp: the filesystem 6089e6e0a12SSteven Whitehouse * 6099e6e0a12SSteven Whitehouse * Returns: errno 6109e6e0a12SSteven Whitehouse */ 6119e6e0a12SSteven Whitehouse 6121f52aa08SAndrew Price int gfs2_make_fs_ro(struct gfs2_sbd *sdp) 6139e6e0a12SSteven Whitehouse { 6142e60d768SBenjamin Marzinski struct gfs2_holder freeze_gh; 615601ef0d5SBob Peterson int error = 0; 616601ef0d5SBob Peterson int log_write_allowed = test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags); 6179e6e0a12SSteven Whitehouse 618601ef0d5SBob Peterson gfs2_holder_mark_uninitialized(&freeze_gh); 619601ef0d5SBob Peterson if (sdp->sd_freeze_gl && 620601ef0d5SBob Peterson !gfs2_glock_is_locked_by_me(sdp->sd_freeze_gl)) { 621601ef0d5SBob Peterson if (!log_write_allowed) { 622601ef0d5SBob Peterson error = gfs2_glock_nq_init(sdp->sd_freeze_gl, 623c860f8ffSBob Peterson LM_ST_SHARED, LM_FLAG_TRY | 624c860f8ffSBob Peterson LM_FLAG_NOEXP | GL_EXACT, 625623ba664SBob Peterson &freeze_gh); 626601ef0d5SBob Peterson if (error == GLR_TRYFAILED) 627601ef0d5SBob Peterson error = 0; 628601ef0d5SBob Peterson } else { 629601ef0d5SBob Peterson error = gfs2_glock_nq_init(sdp->sd_freeze_gl, 630c860f8ffSBob Peterson LM_ST_SHARED, 631c860f8ffSBob Peterson LM_FLAG_NOEXP | GL_EXACT, 6322e60d768SBenjamin Marzinski &freeze_gh); 633eb43e660SBob Peterson if (error && !gfs2_withdrawn(sdp)) 63424972557SBenjamin Marzinski return error; 635601ef0d5SBob Peterson } 636601ef0d5SBob Peterson } 63724972557SBenjamin Marzinski 638a0e3cc65SAndreas Gruenbacher gfs2_flush_delete_work(sdp); 639601ef0d5SBob Peterson if (!log_write_allowed && current == sdp->sd_quotad_process) 640601ef0d5SBob Peterson fs_warn(sdp, "The quotad daemon is withdrawing.\n"); 641601ef0d5SBob Peterson else if (sdp->sd_quotad_process) 6428ad151c2SSteven Whitehouse kthread_stop(sdp->sd_quotad_process); 6435b3a9f34SBob Peterson sdp->sd_quotad_process = NULL; 644601ef0d5SBob Peterson 645601ef0d5SBob Peterson if (!log_write_allowed && current == sdp->sd_logd_process) 646601ef0d5SBob Peterson fs_warn(sdp, "The logd daemon is withdrawing.\n"); 647601ef0d5SBob Peterson else if (sdp->sd_logd_process) 6488ad151c2SSteven Whitehouse kthread_stop(sdp->sd_logd_process); 6495b3a9f34SBob Peterson sdp->sd_logd_process = NULL; 6508ad151c2SSteven Whitehouse 651601ef0d5SBob Peterson if (log_write_allowed) { 652ceed1723SJan Kara gfs2_quota_sync(sdp->sd_vfs, 0); 6538c42d637SSteven Whitehouse gfs2_statfs_sync(sdp->sd_vfs, 0); 6549e6e0a12SSteven Whitehouse 655805c0907SBob Peterson gfs2_log_flush(sdp, NULL, GFS2_LOG_HEAD_FLUSH_SHUTDOWN | 656805c0907SBob Peterson GFS2_LFC_MAKE_FS_RO); 657601ef0d5SBob Peterson wait_event(sdp->sd_reserving_log_wait, 658601ef0d5SBob Peterson atomic_read(&sdp->sd_reserving_log) == 0); 659601ef0d5SBob Peterson gfs2_assert_warn(sdp, atomic_read(&sdp->sd_log_blks_free) == 660601ef0d5SBob Peterson sdp->sd_jdesc->jd_blocks); 661601ef0d5SBob Peterson } else { 662601ef0d5SBob Peterson wait_event_timeout(sdp->sd_reserving_log_wait, 663601ef0d5SBob Peterson atomic_read(&sdp->sd_reserving_log) == 0, 664601ef0d5SBob Peterson HZ * 5); 665601ef0d5SBob Peterson } 6666df9f9a2SAndreas Gruenbacher if (gfs2_holder_initialized(&freeze_gh)) 6672e60d768SBenjamin Marzinski gfs2_glock_dq_uninit(&freeze_gh); 6689e6e0a12SSteven Whitehouse 6699e6e0a12SSteven Whitehouse gfs2_quota_cleanup(sdp); 6709e6e0a12SSteven Whitehouse 671601ef0d5SBob Peterson if (!log_write_allowed) 672601ef0d5SBob Peterson sdp->sd_vfs->s_flags |= SB_RDONLY; 673601ef0d5SBob Peterson 6749e6e0a12SSteven Whitehouse return error; 6759e6e0a12SSteven Whitehouse } 6769e6e0a12SSteven Whitehouse 6779e6e0a12SSteven Whitehouse /** 6789e6e0a12SSteven Whitehouse * gfs2_put_super - Unmount the filesystem 6799e6e0a12SSteven Whitehouse * @sb: The VFS superblock 6809e6e0a12SSteven Whitehouse * 6819e6e0a12SSteven Whitehouse */ 6829e6e0a12SSteven Whitehouse 6839e6e0a12SSteven Whitehouse static void gfs2_put_super(struct super_block *sb) 6849e6e0a12SSteven Whitehouse { 6859e6e0a12SSteven Whitehouse struct gfs2_sbd *sdp = sb->s_fs_info; 6869e6e0a12SSteven Whitehouse int error; 6879e6e0a12SSteven Whitehouse struct gfs2_jdesc *jd; 6889e6e0a12SSteven Whitehouse 6899e6e0a12SSteven Whitehouse /* No more recovery requests */ 6909e6e0a12SSteven Whitehouse set_bit(SDF_NORECOVERY, &sdp->sd_flags); 6919e6e0a12SSteven Whitehouse smp_mb(); 6929e6e0a12SSteven Whitehouse 6939e6e0a12SSteven Whitehouse /* Wait on outstanding recovery */ 6949e6e0a12SSteven Whitehouse restart: 6959e6e0a12SSteven Whitehouse spin_lock(&sdp->sd_jindex_spin); 6969e6e0a12SSteven Whitehouse list_for_each_entry(jd, &sdp->sd_jindex_list, jd_list) { 6979e6e0a12SSteven Whitehouse if (!test_bit(JDF_RECOVERY, &jd->jd_flags)) 6989e6e0a12SSteven Whitehouse continue; 6999e6e0a12SSteven Whitehouse spin_unlock(&sdp->sd_jindex_spin); 7009e6e0a12SSteven Whitehouse wait_on_bit(&jd->jd_flags, JDF_RECOVERY, 70174316201SNeilBrown TASK_UNINTERRUPTIBLE); 7029e6e0a12SSteven Whitehouse goto restart; 7039e6e0a12SSteven Whitehouse } 7049e6e0a12SSteven Whitehouse spin_unlock(&sdp->sd_jindex_spin); 7059e6e0a12SSteven Whitehouse 706bc98a42cSDavid Howells if (!sb_rdonly(sb)) { 7079e6e0a12SSteven Whitehouse error = gfs2_make_fs_ro(sdp); 7089e6e0a12SSteven Whitehouse if (error) 7099e6e0a12SSteven Whitehouse gfs2_io_error(sdp); 7109e6e0a12SSteven Whitehouse } 7115a61ae14SAndreas Gruenbacher WARN_ON(gfs2_withdrawing(sdp)); 7125a61ae14SAndreas Gruenbacher 7139e6e0a12SSteven Whitehouse /* At this point, we're through modifying the disk */ 7149e6e0a12SSteven Whitehouse 7159e6e0a12SSteven Whitehouse /* Release stuff */ 7169e6e0a12SSteven Whitehouse 7179e6e0a12SSteven Whitehouse iput(sdp->sd_jindex); 7189e6e0a12SSteven Whitehouse iput(sdp->sd_statfs_inode); 7199e6e0a12SSteven Whitehouse iput(sdp->sd_rindex); 7209e6e0a12SSteven Whitehouse iput(sdp->sd_quota_inode); 7219e6e0a12SSteven Whitehouse 7229e6e0a12SSteven Whitehouse gfs2_glock_put(sdp->sd_rename_gl); 72324972557SBenjamin Marzinski gfs2_glock_put(sdp->sd_freeze_gl); 7249e6e0a12SSteven Whitehouse 7259e6e0a12SSteven Whitehouse if (!sdp->sd_args.ar_spectator) { 726601ef0d5SBob Peterson if (gfs2_holder_initialized(&sdp->sd_journal_gh)) 7279e6e0a12SSteven Whitehouse gfs2_glock_dq_uninit(&sdp->sd_journal_gh); 728601ef0d5SBob Peterson if (gfs2_holder_initialized(&sdp->sd_jinode_gh)) 7299e6e0a12SSteven Whitehouse gfs2_glock_dq_uninit(&sdp->sd_jinode_gh); 7309e6e0a12SSteven Whitehouse gfs2_glock_dq_uninit(&sdp->sd_sc_gh); 7319e6e0a12SSteven Whitehouse gfs2_glock_dq_uninit(&sdp->sd_qc_gh); 7329e6e0a12SSteven Whitehouse iput(sdp->sd_sc_inode); 7339e6e0a12SSteven Whitehouse iput(sdp->sd_qc_inode); 7349e6e0a12SSteven Whitehouse } 7359e6e0a12SSteven Whitehouse 7369e6e0a12SSteven Whitehouse gfs2_glock_dq_uninit(&sdp->sd_live_gh); 7379e6e0a12SSteven Whitehouse gfs2_clear_rgrpd(sdp); 7389e6e0a12SSteven Whitehouse gfs2_jindex_free(sdp); 7399e6e0a12SSteven Whitehouse /* Take apart glock structures and buffer lists */ 7409e6e0a12SSteven Whitehouse gfs2_gl_hash_clear(sdp); 741b2fb7dabSBob Peterson gfs2_delete_debugfs_file(sdp); 7429e6e0a12SSteven Whitehouse /* Unmount the locking protocol */ 7439e6e0a12SSteven Whitehouse gfs2_lm_unmount(sdp); 7449e6e0a12SSteven Whitehouse 7459e6e0a12SSteven Whitehouse /* At this point, we're through participating in the lockspace */ 7469e6e0a12SSteven Whitehouse gfs2_sys_fs_del(sdp); 747c2a04b02SJamie Iles free_sbd(sdp); 7489e6e0a12SSteven Whitehouse } 7499e6e0a12SSteven Whitehouse 7509e6e0a12SSteven Whitehouse /** 7519e6e0a12SSteven Whitehouse * gfs2_sync_fs - sync the filesystem 7529e6e0a12SSteven Whitehouse * @sb: the superblock 7539e6e0a12SSteven Whitehouse * 7549e6e0a12SSteven Whitehouse * Flushes the log to disk. 7559e6e0a12SSteven Whitehouse */ 7569e6e0a12SSteven Whitehouse 7579e6e0a12SSteven Whitehouse static int gfs2_sync_fs(struct super_block *sb, int wait) 7589e6e0a12SSteven Whitehouse { 7591027efaaSSteven Whitehouse struct gfs2_sbd *sdp = sb->s_fs_info; 760a1177825SJan Kara 761a1177825SJan Kara gfs2_quota_sync(sb, -1); 762942b0cddSBob Peterson if (wait) 763805c0907SBob Peterson gfs2_log_flush(sdp, NULL, GFS2_LOG_HEAD_FLUSH_NORMAL | 764805c0907SBob Peterson GFS2_LFC_SYNC_FS); 765942b0cddSBob Peterson return sdp->sd_log_error; 7669e6e0a12SSteven Whitehouse } 7679e6e0a12SSteven Whitehouse 7682e60d768SBenjamin Marzinski void gfs2_freeze_func(struct work_struct *work) 7692e60d768SBenjamin Marzinski { 7702e60d768SBenjamin Marzinski int error; 7712e60d768SBenjamin Marzinski struct gfs2_holder freeze_gh; 7722e60d768SBenjamin Marzinski struct gfs2_sbd *sdp = container_of(work, struct gfs2_sbd, sd_freeze_work); 7732e60d768SBenjamin Marzinski struct super_block *sb = sdp->sd_vfs; 7742e60d768SBenjamin Marzinski 7752e60d768SBenjamin Marzinski atomic_inc(&sb->s_active); 776c860f8ffSBob Peterson error = gfs2_glock_nq_init(sdp->sd_freeze_gl, LM_ST_SHARED, 777c860f8ffSBob Peterson LM_FLAG_NOEXP | GL_EXACT, &freeze_gh); 7782e60d768SBenjamin Marzinski if (error) { 779f29e62eeSBob Peterson fs_info(sdp, "GFS2: couldn't get freeze lock : %d\n", error); 7802e60d768SBenjamin Marzinski gfs2_assert_withdraw(sdp, 0); 7818f918219SAbhi Das } else { 7822e60d768SBenjamin Marzinski atomic_set(&sdp->sd_freeze_state, SFS_UNFROZEN); 7832e60d768SBenjamin Marzinski error = thaw_super(sb); 7842e60d768SBenjamin Marzinski if (error) { 785f29e62eeSBob Peterson fs_info(sdp, "GFS2: couldn't thaw filesystem: %d\n", 7862e60d768SBenjamin Marzinski error); 7872e60d768SBenjamin Marzinski gfs2_assert_withdraw(sdp, 0); 7882e60d768SBenjamin Marzinski } 7892e60d768SBenjamin Marzinski gfs2_glock_dq_uninit(&freeze_gh); 7902e60d768SBenjamin Marzinski } 7912e60d768SBenjamin Marzinski deactivate_super(sb); 7928f918219SAbhi Das clear_bit_unlock(SDF_FS_FROZEN, &sdp->sd_flags); 7938f918219SAbhi Das wake_up_bit(&sdp->sd_flags, SDF_FS_FROZEN); 7942e60d768SBenjamin Marzinski return; 7952e60d768SBenjamin Marzinski } 7962e60d768SBenjamin Marzinski 7979e6e0a12SSteven Whitehouse /** 7989e6e0a12SSteven Whitehouse * gfs2_freeze - prevent further writes to the filesystem 7999e6e0a12SSteven Whitehouse * @sb: the VFS structure for the filesystem 8009e6e0a12SSteven Whitehouse * 8019e6e0a12SSteven Whitehouse */ 8029e6e0a12SSteven Whitehouse 8039e6e0a12SSteven Whitehouse static int gfs2_freeze(struct super_block *sb) 8049e6e0a12SSteven Whitehouse { 8059e6e0a12SSteven Whitehouse struct gfs2_sbd *sdp = sb->s_fs_info; 8062e60d768SBenjamin Marzinski int error = 0; 8079e6e0a12SSteven Whitehouse 8082e60d768SBenjamin Marzinski mutex_lock(&sdp->sd_freeze_mutex); 8092e60d768SBenjamin Marzinski if (atomic_read(&sdp->sd_freeze_state) != SFS_UNFROZEN) 8102e60d768SBenjamin Marzinski goto out; 8112e60d768SBenjamin Marzinski 81260528afaSBob Peterson for (;;) { 813eb43e660SBob Peterson if (gfs2_withdrawn(sdp)) { 8142e60d768SBenjamin Marzinski error = -EINVAL; 8152e60d768SBenjamin Marzinski goto out; 8162e60d768SBenjamin Marzinski } 8179e6e0a12SSteven Whitehouse 81852b1cdcbSBob Peterson error = gfs2_lock_fs_check_clean(sdp); 8199e6e0a12SSteven Whitehouse if (!error) 8209e6e0a12SSteven Whitehouse break; 8219e6e0a12SSteven Whitehouse 82255317f5bSBob Peterson if (error == -EBUSY) 8239e6e0a12SSteven Whitehouse fs_err(sdp, "waiting for recovery before freeze\n"); 82452b1cdcbSBob Peterson else if (error == -EIO) { 82552b1cdcbSBob Peterson fs_err(sdp, "Fatal IO error: cannot freeze gfs2 due " 82652b1cdcbSBob Peterson "to recovery error.\n"); 82752b1cdcbSBob Peterson goto out; 82852b1cdcbSBob Peterson } else { 8299e6e0a12SSteven Whitehouse fs_err(sdp, "error freezing FS: %d\n", error); 83052b1cdcbSBob Peterson } 8319e6e0a12SSteven Whitehouse fs_err(sdp, "retrying...\n"); 8329e6e0a12SSteven Whitehouse msleep(1000); 8339e6e0a12SSteven Whitehouse } 8348f918219SAbhi Das set_bit(SDF_FS_FROZEN, &sdp->sd_flags); 8352e60d768SBenjamin Marzinski out: 8362e60d768SBenjamin Marzinski mutex_unlock(&sdp->sd_freeze_mutex); 8372e60d768SBenjamin Marzinski return error; 8389e6e0a12SSteven Whitehouse } 8399e6e0a12SSteven Whitehouse 8409e6e0a12SSteven Whitehouse /** 8419e6e0a12SSteven Whitehouse * gfs2_unfreeze - reallow writes to the filesystem 8429e6e0a12SSteven Whitehouse * @sb: the VFS structure for the filesystem 8439e6e0a12SSteven Whitehouse * 8449e6e0a12SSteven Whitehouse */ 8459e6e0a12SSteven Whitehouse 8469e6e0a12SSteven Whitehouse static int gfs2_unfreeze(struct super_block *sb) 8479e6e0a12SSteven Whitehouse { 848d564053fSSteven Whitehouse struct gfs2_sbd *sdp = sb->s_fs_info; 849d564053fSSteven Whitehouse 8502e60d768SBenjamin Marzinski mutex_lock(&sdp->sd_freeze_mutex); 8512e60d768SBenjamin Marzinski if (atomic_read(&sdp->sd_freeze_state) != SFS_FROZEN || 8526df9f9a2SAndreas Gruenbacher !gfs2_holder_initialized(&sdp->sd_freeze_gh)) { 8532e60d768SBenjamin Marzinski mutex_unlock(&sdp->sd_freeze_mutex); 8542e60d768SBenjamin Marzinski return 0; 8552e60d768SBenjamin Marzinski } 8562e60d768SBenjamin Marzinski 857d564053fSSteven Whitehouse gfs2_glock_dq_uninit(&sdp->sd_freeze_gh); 8582e60d768SBenjamin Marzinski mutex_unlock(&sdp->sd_freeze_mutex); 8598f918219SAbhi Das return wait_on_bit(&sdp->sd_flags, SDF_FS_FROZEN, TASK_INTERRUPTIBLE); 8609e6e0a12SSteven Whitehouse } 8619e6e0a12SSteven Whitehouse 8629e6e0a12SSteven Whitehouse /** 8639e6e0a12SSteven Whitehouse * statfs_fill - fill in the sg for a given RG 8649e6e0a12SSteven Whitehouse * @rgd: the RG 8659e6e0a12SSteven Whitehouse * @sc: the sc structure 8669e6e0a12SSteven Whitehouse * 8679e6e0a12SSteven Whitehouse * Returns: 0 on success, -ESTALE if the LVB is invalid 8689e6e0a12SSteven Whitehouse */ 8699e6e0a12SSteven Whitehouse 8709e6e0a12SSteven Whitehouse static int statfs_slow_fill(struct gfs2_rgrpd *rgd, 8719e6e0a12SSteven Whitehouse struct gfs2_statfs_change_host *sc) 8729e6e0a12SSteven Whitehouse { 8739e6e0a12SSteven Whitehouse gfs2_rgrp_verify(rgd); 8749e6e0a12SSteven Whitehouse sc->sc_total += rgd->rd_data; 8759e6e0a12SSteven Whitehouse sc->sc_free += rgd->rd_free; 8769e6e0a12SSteven Whitehouse sc->sc_dinodes += rgd->rd_dinodes; 8779e6e0a12SSteven Whitehouse return 0; 8789e6e0a12SSteven Whitehouse } 8799e6e0a12SSteven Whitehouse 8809e6e0a12SSteven Whitehouse /** 8819e6e0a12SSteven Whitehouse * gfs2_statfs_slow - Stat a filesystem using asynchronous locking 8829e6e0a12SSteven Whitehouse * @sdp: the filesystem 8839e6e0a12SSteven Whitehouse * @sc: the sc info that will be returned 8849e6e0a12SSteven Whitehouse * 8859e6e0a12SSteven Whitehouse * Any error (other than a signal) will cause this routine to fall back 8869e6e0a12SSteven Whitehouse * to the synchronous version. 8879e6e0a12SSteven Whitehouse * 8889e6e0a12SSteven Whitehouse * FIXME: This really shouldn't busy wait like this. 8899e6e0a12SSteven Whitehouse * 8909e6e0a12SSteven Whitehouse * Returns: errno 8919e6e0a12SSteven Whitehouse */ 8929e6e0a12SSteven Whitehouse 8939e6e0a12SSteven Whitehouse static int gfs2_statfs_slow(struct gfs2_sbd *sdp, struct gfs2_statfs_change_host *sc) 8949e6e0a12SSteven Whitehouse { 8959e6e0a12SSteven Whitehouse struct gfs2_rgrpd *rgd_next; 8969e6e0a12SSteven Whitehouse struct gfs2_holder *gha, *gh; 8979e6e0a12SSteven Whitehouse unsigned int slots = 64; 8989e6e0a12SSteven Whitehouse unsigned int x; 8999e6e0a12SSteven Whitehouse int done; 9009e6e0a12SSteven Whitehouse int error = 0, err; 9019e6e0a12SSteven Whitehouse 9029e6e0a12SSteven Whitehouse memset(sc, 0, sizeof(struct gfs2_statfs_change_host)); 9036da2ec56SKees Cook gha = kmalloc_array(slots, sizeof(struct gfs2_holder), GFP_KERNEL); 9049e6e0a12SSteven Whitehouse if (!gha) 9059e6e0a12SSteven Whitehouse return -ENOMEM; 9066df9f9a2SAndreas Gruenbacher for (x = 0; x < slots; x++) 9076df9f9a2SAndreas Gruenbacher gfs2_holder_mark_uninitialized(gha + x); 9089e6e0a12SSteven Whitehouse 9099e6e0a12SSteven Whitehouse rgd_next = gfs2_rgrpd_get_first(sdp); 9109e6e0a12SSteven Whitehouse 9119e6e0a12SSteven Whitehouse for (;;) { 9129e6e0a12SSteven Whitehouse done = 1; 9139e6e0a12SSteven Whitehouse 9149e6e0a12SSteven Whitehouse for (x = 0; x < slots; x++) { 9159e6e0a12SSteven Whitehouse gh = gha + x; 9169e6e0a12SSteven Whitehouse 9176df9f9a2SAndreas Gruenbacher if (gfs2_holder_initialized(gh) && gfs2_glock_poll(gh)) { 9189e6e0a12SSteven Whitehouse err = gfs2_glock_wait(gh); 9199e6e0a12SSteven Whitehouse if (err) { 9209e6e0a12SSteven Whitehouse gfs2_holder_uninit(gh); 9219e6e0a12SSteven Whitehouse error = err; 9229e6e0a12SSteven Whitehouse } else { 9236f6597baSAndreas Gruenbacher if (!error) { 9246f6597baSAndreas Gruenbacher struct gfs2_rgrpd *rgd = 9256f6597baSAndreas Gruenbacher gfs2_glock2rgrp(gh->gh_gl); 9266f6597baSAndreas Gruenbacher 9276f6597baSAndreas Gruenbacher error = statfs_slow_fill(rgd, sc); 9286f6597baSAndreas Gruenbacher } 9299e6e0a12SSteven Whitehouse gfs2_glock_dq_uninit(gh); 9309e6e0a12SSteven Whitehouse } 9319e6e0a12SSteven Whitehouse } 9329e6e0a12SSteven Whitehouse 9336df9f9a2SAndreas Gruenbacher if (gfs2_holder_initialized(gh)) 9349e6e0a12SSteven Whitehouse done = 0; 9359e6e0a12SSteven Whitehouse else if (rgd_next && !error) { 9369e6e0a12SSteven Whitehouse error = gfs2_glock_nq_init(rgd_next->rd_gl, 9379e6e0a12SSteven Whitehouse LM_ST_SHARED, 9389e6e0a12SSteven Whitehouse GL_ASYNC, 9399e6e0a12SSteven Whitehouse gh); 9409e6e0a12SSteven Whitehouse rgd_next = gfs2_rgrpd_get_next(rgd_next); 9419e6e0a12SSteven Whitehouse done = 0; 9429e6e0a12SSteven Whitehouse } 9439e6e0a12SSteven Whitehouse 9449e6e0a12SSteven Whitehouse if (signal_pending(current)) 9459e6e0a12SSteven Whitehouse error = -ERESTARTSYS; 9469e6e0a12SSteven Whitehouse } 9479e6e0a12SSteven Whitehouse 9489e6e0a12SSteven Whitehouse if (done) 9499e6e0a12SSteven Whitehouse break; 9509e6e0a12SSteven Whitehouse 9519e6e0a12SSteven Whitehouse yield(); 9529e6e0a12SSteven Whitehouse } 9539e6e0a12SSteven Whitehouse 9549e6e0a12SSteven Whitehouse kfree(gha); 9559e6e0a12SSteven Whitehouse return error; 9569e6e0a12SSteven Whitehouse } 9579e6e0a12SSteven Whitehouse 9589e6e0a12SSteven Whitehouse /** 9599e6e0a12SSteven Whitehouse * gfs2_statfs_i - Do a statfs 9609e6e0a12SSteven Whitehouse * @sdp: the filesystem 9619e6e0a12SSteven Whitehouse * @sg: the sg structure 9629e6e0a12SSteven Whitehouse * 9639e6e0a12SSteven Whitehouse * Returns: errno 9649e6e0a12SSteven Whitehouse */ 9659e6e0a12SSteven Whitehouse 9669e6e0a12SSteven Whitehouse static int gfs2_statfs_i(struct gfs2_sbd *sdp, struct gfs2_statfs_change_host *sc) 9679e6e0a12SSteven Whitehouse { 9689e6e0a12SSteven Whitehouse struct gfs2_statfs_change_host *m_sc = &sdp->sd_statfs_master; 9699e6e0a12SSteven Whitehouse struct gfs2_statfs_change_host *l_sc = &sdp->sd_statfs_local; 9709e6e0a12SSteven Whitehouse 9719e6e0a12SSteven Whitehouse spin_lock(&sdp->sd_statfs_spin); 9729e6e0a12SSteven Whitehouse 9739e6e0a12SSteven Whitehouse *sc = *m_sc; 9749e6e0a12SSteven Whitehouse sc->sc_total += l_sc->sc_total; 9759e6e0a12SSteven Whitehouse sc->sc_free += l_sc->sc_free; 9769e6e0a12SSteven Whitehouse sc->sc_dinodes += l_sc->sc_dinodes; 9779e6e0a12SSteven Whitehouse 9789e6e0a12SSteven Whitehouse spin_unlock(&sdp->sd_statfs_spin); 9799e6e0a12SSteven Whitehouse 9809e6e0a12SSteven Whitehouse if (sc->sc_free < 0) 9819e6e0a12SSteven Whitehouse sc->sc_free = 0; 9829e6e0a12SSteven Whitehouse if (sc->sc_free > sc->sc_total) 9839e6e0a12SSteven Whitehouse sc->sc_free = sc->sc_total; 9849e6e0a12SSteven Whitehouse if (sc->sc_dinodes < 0) 9859e6e0a12SSteven Whitehouse sc->sc_dinodes = 0; 9869e6e0a12SSteven Whitehouse 9879e6e0a12SSteven Whitehouse return 0; 9889e6e0a12SSteven Whitehouse } 9899e6e0a12SSteven Whitehouse 9909e6e0a12SSteven Whitehouse /** 9919e6e0a12SSteven Whitehouse * gfs2_statfs - Gather and return stats about the filesystem 9929e6e0a12SSteven Whitehouse * @sb: The superblock 9939e6e0a12SSteven Whitehouse * @statfsbuf: The buffer 9949e6e0a12SSteven Whitehouse * 9959e6e0a12SSteven Whitehouse * Returns: 0 on success or error code 9969e6e0a12SSteven Whitehouse */ 9979e6e0a12SSteven Whitehouse 9989e6e0a12SSteven Whitehouse static int gfs2_statfs(struct dentry *dentry, struct kstatfs *buf) 9999e6e0a12SSteven Whitehouse { 1000fc64005cSAl Viro struct super_block *sb = dentry->d_sb; 10019e6e0a12SSteven Whitehouse struct gfs2_sbd *sdp = sb->s_fs_info; 10029e6e0a12SSteven Whitehouse struct gfs2_statfs_change_host sc; 10039e6e0a12SSteven Whitehouse int error; 10049e6e0a12SSteven Whitehouse 10058339ee54SSteven Whitehouse error = gfs2_rindex_update(sdp); 10068339ee54SSteven Whitehouse if (error) 10078339ee54SSteven Whitehouse return error; 10088339ee54SSteven Whitehouse 10099e6e0a12SSteven Whitehouse if (gfs2_tune_get(sdp, gt_statfs_slow)) 10109e6e0a12SSteven Whitehouse error = gfs2_statfs_slow(sdp, &sc); 10119e6e0a12SSteven Whitehouse else 10129e6e0a12SSteven Whitehouse error = gfs2_statfs_i(sdp, &sc); 10139e6e0a12SSteven Whitehouse 10149e6e0a12SSteven Whitehouse if (error) 10159e6e0a12SSteven Whitehouse return error; 10169e6e0a12SSteven Whitehouse 10179e6e0a12SSteven Whitehouse buf->f_type = GFS2_MAGIC; 10189e6e0a12SSteven Whitehouse buf->f_bsize = sdp->sd_sb.sb_bsize; 10199e6e0a12SSteven Whitehouse buf->f_blocks = sc.sc_total; 10209e6e0a12SSteven Whitehouse buf->f_bfree = sc.sc_free; 10219e6e0a12SSteven Whitehouse buf->f_bavail = sc.sc_free; 10229e6e0a12SSteven Whitehouse buf->f_files = sc.sc_dinodes + sc.sc_free; 10239e6e0a12SSteven Whitehouse buf->f_ffree = sc.sc_free; 10249e6e0a12SSteven Whitehouse buf->f_namelen = GFS2_FNAMESIZE; 10259e6e0a12SSteven Whitehouse 10269e6e0a12SSteven Whitehouse return 0; 10279e6e0a12SSteven Whitehouse } 10289e6e0a12SSteven Whitehouse 10299e6e0a12SSteven Whitehouse /** 10309e6e0a12SSteven Whitehouse * gfs2_drop_inode - Drop an inode (test for remote unlink) 10319e6e0a12SSteven Whitehouse * @inode: The inode to drop 10329e6e0a12SSteven Whitehouse * 103361b91cfdSAndreas Gruenbacher * If we've received a callback on an iopen lock then it's because a 10349e6e0a12SSteven Whitehouse * remote node tried to deallocate the inode but failed due to this node 10359e6e0a12SSteven Whitehouse * still having the inode open. Here we mark the link count zero 10369e6e0a12SSteven Whitehouse * since we know that it must have reached zero if the GLF_DEMOTE flag 10379e6e0a12SSteven Whitehouse * is set on the iopen glock. If we didn't do a disk read since the 10389e6e0a12SSteven Whitehouse * remote node removed the final link then we might otherwise miss 10399e6e0a12SSteven Whitehouse * this event. This check ensures that this node will deallocate the 10409e6e0a12SSteven Whitehouse * inode's blocks, or alternatively pass the baton on to another 10419e6e0a12SSteven Whitehouse * node for later deallocation. 10429e6e0a12SSteven Whitehouse */ 10439e6e0a12SSteven Whitehouse 104445321ac5SAl Viro static int gfs2_drop_inode(struct inode *inode) 10459e6e0a12SSteven Whitehouse { 10469e6e0a12SSteven Whitehouse struct gfs2_inode *ip = GFS2_I(inode); 10479e6e0a12SSteven Whitehouse 10486df9f9a2SAndreas Gruenbacher if (!test_bit(GIF_FREE_VFS_INODE, &ip->i_flags) && 10496df9f9a2SAndreas Gruenbacher inode->i_nlink && 10506df9f9a2SAndreas Gruenbacher gfs2_holder_initialized(&ip->i_iopen_gh)) { 10519e6e0a12SSteven Whitehouse struct gfs2_glock *gl = ip->i_iopen_gh.gh_gl; 10526df9f9a2SAndreas Gruenbacher if (test_bit(GLF_DEMOTE, &gl->gl_flags)) 10539e6e0a12SSteven Whitehouse clear_nlink(inode); 10549e6e0a12SSteven Whitehouse } 10556a1c8f6dSAndreas Gruenbacher 10566a1c8f6dSAndreas Gruenbacher /* 10576a1c8f6dSAndreas Gruenbacher * When under memory pressure when an inode's link count has dropped to 10586a1c8f6dSAndreas Gruenbacher * zero, defer deleting the inode to the delete workqueue. This avoids 10596a1c8f6dSAndreas Gruenbacher * calling into DLM under memory pressure, which can deadlock. 10606a1c8f6dSAndreas Gruenbacher */ 10616a1c8f6dSAndreas Gruenbacher if (!inode->i_nlink && 10626a1c8f6dSAndreas Gruenbacher unlikely(current->flags & PF_MEMALLOC) && 10636a1c8f6dSAndreas Gruenbacher gfs2_holder_initialized(&ip->i_iopen_gh)) { 10646a1c8f6dSAndreas Gruenbacher struct gfs2_glock *gl = ip->i_iopen_gh.gh_gl; 10656a1c8f6dSAndreas Gruenbacher 10666a1c8f6dSAndreas Gruenbacher gfs2_glock_hold(gl); 1067a0e3cc65SAndreas Gruenbacher if (!gfs2_queue_delete_work(gl, 0)) 10686a1c8f6dSAndreas Gruenbacher gfs2_glock_queue_put(gl); 10696a1c8f6dSAndreas Gruenbacher return false; 10706a1c8f6dSAndreas Gruenbacher } 10716a1c8f6dSAndreas Gruenbacher 107245321ac5SAl Viro return generic_drop_inode(inode); 10739e6e0a12SSteven Whitehouse } 10749e6e0a12SSteven Whitehouse 10759e6e0a12SSteven Whitehouse static int is_ancestor(const struct dentry *d1, const struct dentry *d2) 10769e6e0a12SSteven Whitehouse { 10779e6e0a12SSteven Whitehouse do { 10789e6e0a12SSteven Whitehouse if (d1 == d2) 10799e6e0a12SSteven Whitehouse return 1; 10809e6e0a12SSteven Whitehouse d1 = d1->d_parent; 10819e6e0a12SSteven Whitehouse } while (!IS_ROOT(d1)); 10829e6e0a12SSteven Whitehouse return 0; 10839e6e0a12SSteven Whitehouse } 10849e6e0a12SSteven Whitehouse 10859e6e0a12SSteven Whitehouse /** 10869e6e0a12SSteven Whitehouse * gfs2_show_options - Show mount options for /proc/mounts 10879e6e0a12SSteven Whitehouse * @s: seq_file structure 108834c80b1dSAl Viro * @root: root of this (sub)tree 10899e6e0a12SSteven Whitehouse * 10909e6e0a12SSteven Whitehouse * Returns: 0 on success or error code 10919e6e0a12SSteven Whitehouse */ 10929e6e0a12SSteven Whitehouse 109334c80b1dSAl Viro static int gfs2_show_options(struct seq_file *s, struct dentry *root) 10949e6e0a12SSteven Whitehouse { 109534c80b1dSAl Viro struct gfs2_sbd *sdp = root->d_sb->s_fs_info; 10969e6e0a12SSteven Whitehouse struct gfs2_args *args = &sdp->sd_args; 10973d3c10f2SBenjamin Marzinski int val; 10989e6e0a12SSteven Whitehouse 109934c80b1dSAl Viro if (is_ancestor(root, sdp->sd_master_dir)) 1100eaebdedcSFabian Frederick seq_puts(s, ",meta"); 11019e6e0a12SSteven Whitehouse if (args->ar_lockproto[0]) 1102a068acf2SKees Cook seq_show_option(s, "lockproto", args->ar_lockproto); 11039e6e0a12SSteven Whitehouse if (args->ar_locktable[0]) 1104a068acf2SKees Cook seq_show_option(s, "locktable", args->ar_locktable); 11059e6e0a12SSteven Whitehouse if (args->ar_hostdata[0]) 1106a068acf2SKees Cook seq_show_option(s, "hostdata", args->ar_hostdata); 11079e6e0a12SSteven Whitehouse if (args->ar_spectator) 1108eaebdedcSFabian Frederick seq_puts(s, ",spectator"); 11099e6e0a12SSteven Whitehouse if (args->ar_localflocks) 1110eaebdedcSFabian Frederick seq_puts(s, ",localflocks"); 11119e6e0a12SSteven Whitehouse if (args->ar_debug) 1112eaebdedcSFabian Frederick seq_puts(s, ",debug"); 11139e6e0a12SSteven Whitehouse if (args->ar_posix_acl) 1114eaebdedcSFabian Frederick seq_puts(s, ",acl"); 11159e6e0a12SSteven Whitehouse if (args->ar_quota != GFS2_QUOTA_DEFAULT) { 11169e6e0a12SSteven Whitehouse char *state; 11179e6e0a12SSteven Whitehouse switch (args->ar_quota) { 11189e6e0a12SSteven Whitehouse case GFS2_QUOTA_OFF: 11199e6e0a12SSteven Whitehouse state = "off"; 11209e6e0a12SSteven Whitehouse break; 11219e6e0a12SSteven Whitehouse case GFS2_QUOTA_ACCOUNT: 11229e6e0a12SSteven Whitehouse state = "account"; 11239e6e0a12SSteven Whitehouse break; 11249e6e0a12SSteven Whitehouse case GFS2_QUOTA_ON: 11259e6e0a12SSteven Whitehouse state = "on"; 11269e6e0a12SSteven Whitehouse break; 11279e6e0a12SSteven Whitehouse default: 11289e6e0a12SSteven Whitehouse state = "unknown"; 11299e6e0a12SSteven Whitehouse break; 11309e6e0a12SSteven Whitehouse } 11319e6e0a12SSteven Whitehouse seq_printf(s, ",quota=%s", state); 11329e6e0a12SSteven Whitehouse } 11339e6e0a12SSteven Whitehouse if (args->ar_suiddir) 1134eaebdedcSFabian Frederick seq_puts(s, ",suiddir"); 11359e6e0a12SSteven Whitehouse if (args->ar_data != GFS2_DATA_DEFAULT) { 11369e6e0a12SSteven Whitehouse char *state; 11379e6e0a12SSteven Whitehouse switch (args->ar_data) { 11389e6e0a12SSteven Whitehouse case GFS2_DATA_WRITEBACK: 11399e6e0a12SSteven Whitehouse state = "writeback"; 11409e6e0a12SSteven Whitehouse break; 11419e6e0a12SSteven Whitehouse case GFS2_DATA_ORDERED: 11429e6e0a12SSteven Whitehouse state = "ordered"; 11439e6e0a12SSteven Whitehouse break; 11449e6e0a12SSteven Whitehouse default: 11459e6e0a12SSteven Whitehouse state = "unknown"; 11469e6e0a12SSteven Whitehouse break; 11479e6e0a12SSteven Whitehouse } 11489e6e0a12SSteven Whitehouse seq_printf(s, ",data=%s", state); 11499e6e0a12SSteven Whitehouse } 11509e6e0a12SSteven Whitehouse if (args->ar_discard) 1151eaebdedcSFabian Frederick seq_puts(s, ",discard"); 11525e687eacSBenjamin Marzinski val = sdp->sd_tune.gt_logd_secs; 11535e687eacSBenjamin Marzinski if (val != 30) 11543d3c10f2SBenjamin Marzinski seq_printf(s, ",commit=%d", val); 11553d3c10f2SBenjamin Marzinski val = sdp->sd_tune.gt_statfs_quantum; 11563d3c10f2SBenjamin Marzinski if (val != 30) 11573d3c10f2SBenjamin Marzinski seq_printf(s, ",statfs_quantum=%d", val); 11582b9731e8SSteven Whitehouse else if (sdp->sd_tune.gt_statfs_slow) 11592b9731e8SSteven Whitehouse seq_puts(s, ",statfs_quantum=0"); 11603d3c10f2SBenjamin Marzinski val = sdp->sd_tune.gt_quota_quantum; 11613d3c10f2SBenjamin Marzinski if (val != 60) 11623d3c10f2SBenjamin Marzinski seq_printf(s, ",quota_quantum=%d", val); 11633d3c10f2SBenjamin Marzinski if (args->ar_statfs_percent) 11643d3c10f2SBenjamin Marzinski seq_printf(s, ",statfs_percent=%d", args->ar_statfs_percent); 1165d34843d0SBob Peterson if (args->ar_errors != GFS2_ERRORS_DEFAULT) { 1166d34843d0SBob Peterson const char *state; 1167d34843d0SBob Peterson 1168d34843d0SBob Peterson switch (args->ar_errors) { 1169d34843d0SBob Peterson case GFS2_ERRORS_WITHDRAW: 1170d34843d0SBob Peterson state = "withdraw"; 1171d34843d0SBob Peterson break; 1172d34843d0SBob Peterson case GFS2_ERRORS_PANIC: 1173d34843d0SBob Peterson state = "panic"; 1174d34843d0SBob Peterson break; 1175d34843d0SBob Peterson default: 1176d34843d0SBob Peterson state = "unknown"; 1177d34843d0SBob Peterson break; 1178d34843d0SBob Peterson } 1179d34843d0SBob Peterson seq_printf(s, ",errors=%s", state); 1180d34843d0SBob Peterson } 1181cdcfde62SSteven Whitehouse if (test_bit(SDF_NOBARRIERS, &sdp->sd_flags)) 1182eaebdedcSFabian Frederick seq_puts(s, ",nobarrier"); 1183913a71d2SSteven Whitehouse if (test_bit(SDF_DEMOTE, &sdp->sd_flags)) 1184eaebdedcSFabian Frederick seq_puts(s, ",demote_interface_used"); 118590306c41SBenjamin Marzinski if (args->ar_rgrplvb) 1186eaebdedcSFabian Frederick seq_puts(s, ",rgrplvb"); 1187471f3db2SBenjamin Marzinski if (args->ar_loccookie) 1188471f3db2SBenjamin Marzinski seq_puts(s, ",loccookie"); 11899e6e0a12SSteven Whitehouse return 0; 11909e6e0a12SSteven Whitehouse } 11919e6e0a12SSteven Whitehouse 1192f42ab085SSteven Whitehouse static void gfs2_final_release_pages(struct gfs2_inode *ip) 1193f42ab085SSteven Whitehouse { 1194f42ab085SSteven Whitehouse struct inode *inode = &ip->i_inode; 1195f42ab085SSteven Whitehouse struct gfs2_glock *gl = ip->i_gl; 1196f42ab085SSteven Whitehouse 1197f42ab085SSteven Whitehouse truncate_inode_pages(gfs2_glock2aspace(ip->i_gl), 0); 1198f42ab085SSteven Whitehouse truncate_inode_pages(&inode->i_data, 0); 1199f42ab085SSteven Whitehouse 1200638803d4SBob Peterson if (atomic_read(&gl->gl_revokes) == 0) { 1201f42ab085SSteven Whitehouse clear_bit(GLF_LFLUSH, &gl->gl_flags); 1202f42ab085SSteven Whitehouse clear_bit(GLF_DIRTY, &gl->gl_flags); 1203f42ab085SSteven Whitehouse } 1204f42ab085SSteven Whitehouse } 1205f42ab085SSteven Whitehouse 1206f42ab085SSteven Whitehouse static int gfs2_dinode_dealloc(struct gfs2_inode *ip) 1207f42ab085SSteven Whitehouse { 1208f42ab085SSteven Whitehouse struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode); 1209f42ab085SSteven Whitehouse struct gfs2_rgrpd *rgd; 1210564e12b1SBob Peterson struct gfs2_holder gh; 1211f42ab085SSteven Whitehouse int error; 1212f42ab085SSteven Whitehouse 1213f42ab085SSteven Whitehouse if (gfs2_get_inode_blocks(&ip->i_inode) != 1) { 121494fb763bSSteven Whitehouse gfs2_consist_inode(ip); 1215f42ab085SSteven Whitehouse return -EIO; 1216f42ab085SSteven Whitehouse } 1217f42ab085SSteven Whitehouse 12188e2e0047SBob Peterson error = gfs2_rindex_update(sdp); 12198e2e0047SBob Peterson if (error) 12208e2e0047SBob Peterson return error; 1221f42ab085SSteven Whitehouse 1222f4108a60SEric W. Biederman error = gfs2_quota_hold(ip, NO_UID_QUOTA_CHANGE, NO_GID_QUOTA_CHANGE); 1223f42ab085SSteven Whitehouse if (error) 12245407e242SBob Peterson return error; 1225f42ab085SSteven Whitehouse 122666fc061bSSteven Whitehouse rgd = gfs2_blk2rgrpd(sdp, ip->i_no_addr, 1); 1227f42ab085SSteven Whitehouse if (!rgd) { 1228f42ab085SSteven Whitehouse gfs2_consist_inode(ip); 1229f42ab085SSteven Whitehouse error = -EIO; 12308339ee54SSteven Whitehouse goto out_qs; 1231f42ab085SSteven Whitehouse } 1232f42ab085SSteven Whitehouse 1233564e12b1SBob Peterson error = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_EXCLUSIVE, 0, &gh); 1234f42ab085SSteven Whitehouse if (error) 12358339ee54SSteven Whitehouse goto out_qs; 1236f42ab085SSteven Whitehouse 12374667a0ecSSteven Whitehouse error = gfs2_trans_begin(sdp, RES_RG_BIT + RES_STATFS + RES_QUOTA, 12384667a0ecSSteven Whitehouse sdp->sd_jdesc->jd_blocks); 1239f42ab085SSteven Whitehouse if (error) 1240f42ab085SSteven Whitehouse goto out_rg_gunlock; 1241f42ab085SSteven Whitehouse 1242f42ab085SSteven Whitehouse gfs2_free_di(rgd, ip); 1243f42ab085SSteven Whitehouse 1244f42ab085SSteven Whitehouse gfs2_final_release_pages(ip); 1245f42ab085SSteven Whitehouse 1246f42ab085SSteven Whitehouse gfs2_trans_end(sdp); 1247f42ab085SSteven Whitehouse 1248f42ab085SSteven Whitehouse out_rg_gunlock: 1249564e12b1SBob Peterson gfs2_glock_dq_uninit(&gh); 1250f42ab085SSteven Whitehouse out_qs: 1251f42ab085SSteven Whitehouse gfs2_quota_unhold(ip); 1252f42ab085SSteven Whitehouse return error; 1253f42ab085SSteven Whitehouse } 1254f42ab085SSteven Whitehouse 1255380f7c65SSteven Whitehouse /** 125671c1b213SAndreas Gruenbacher * gfs2_glock_put_eventually 125771c1b213SAndreas Gruenbacher * @gl: The glock to put 125871c1b213SAndreas Gruenbacher * 125971c1b213SAndreas Gruenbacher * When under memory pressure, trigger a deferred glock put to make sure we 126071c1b213SAndreas Gruenbacher * won't call into DLM and deadlock. Otherwise, put the glock directly. 126171c1b213SAndreas Gruenbacher */ 126271c1b213SAndreas Gruenbacher 126371c1b213SAndreas Gruenbacher static void gfs2_glock_put_eventually(struct gfs2_glock *gl) 126471c1b213SAndreas Gruenbacher { 126571c1b213SAndreas Gruenbacher if (current->flags & PF_MEMALLOC) 126671c1b213SAndreas Gruenbacher gfs2_glock_queue_put(gl); 126771c1b213SAndreas Gruenbacher else 126871c1b213SAndreas Gruenbacher gfs2_glock_put(gl); 126971c1b213SAndreas Gruenbacher } 127071c1b213SAndreas Gruenbacher 12719e73330fSAndreas Gruenbacher static bool gfs2_upgrade_iopen_glock(struct inode *inode) 12729e73330fSAndreas Gruenbacher { 12739e73330fSAndreas Gruenbacher struct gfs2_inode *ip = GFS2_I(inode); 12749e73330fSAndreas Gruenbacher struct gfs2_sbd *sdp = GFS2_SB(inode); 12759e73330fSAndreas Gruenbacher struct gfs2_holder *gh = &ip->i_iopen_gh; 12769e73330fSAndreas Gruenbacher long timeout = 5 * HZ; 12779e73330fSAndreas Gruenbacher int error; 12789e73330fSAndreas Gruenbacher 12799e73330fSAndreas Gruenbacher gh->gh_flags |= GL_NOCACHE; 12809e73330fSAndreas Gruenbacher gfs2_glock_dq_wait(gh); 12819e73330fSAndreas Gruenbacher 12829e73330fSAndreas Gruenbacher /* 12839e73330fSAndreas Gruenbacher * If there are no other lock holders, we'll get the lock immediately. 12849e73330fSAndreas Gruenbacher * Otherwise, the other nodes holding the lock will be notified about 12859e73330fSAndreas Gruenbacher * our locking request. If they don't have the inode open, they'll 12869e8990deSAndreas Gruenbacher * evict the cached inode and release the lock. Otherwise, if they 12879e8990deSAndreas Gruenbacher * poke the inode glock, we'll take this as an indication that they 12889e8990deSAndreas Gruenbacher * still need the iopen glock and that they'll take care of deleting 12899e8990deSAndreas Gruenbacher * the inode when they're done. As a last resort, if another node 12909e8990deSAndreas Gruenbacher * keeps holding the iopen glock without showing any activity on the 12919e8990deSAndreas Gruenbacher * inode glock, we'll eventually time out. 12929e73330fSAndreas Gruenbacher * 12939e73330fSAndreas Gruenbacher * Note that we're passing the LM_FLAG_TRY_1CB flag to the first 12949e73330fSAndreas Gruenbacher * locking request as an optimization to notify lock holders as soon as 12959e73330fSAndreas Gruenbacher * possible. Without that flag, they'd be notified implicitly by the 12969e73330fSAndreas Gruenbacher * second locking request. 12979e73330fSAndreas Gruenbacher */ 12989e73330fSAndreas Gruenbacher 12999e73330fSAndreas Gruenbacher gfs2_holder_reinit(LM_ST_EXCLUSIVE, LM_FLAG_TRY_1CB | GL_NOCACHE, gh); 13009e73330fSAndreas Gruenbacher error = gfs2_glock_nq(gh); 13019e73330fSAndreas Gruenbacher if (error != GLR_TRYFAILED) 13029e73330fSAndreas Gruenbacher return !error; 13039e73330fSAndreas Gruenbacher 13049e73330fSAndreas Gruenbacher gfs2_holder_reinit(LM_ST_EXCLUSIVE, GL_ASYNC | GL_NOCACHE, gh); 13059e73330fSAndreas Gruenbacher error = gfs2_glock_nq(gh); 13069e73330fSAndreas Gruenbacher if (error) 13079e73330fSAndreas Gruenbacher return false; 13089e73330fSAndreas Gruenbacher 13099e73330fSAndreas Gruenbacher timeout = wait_event_interruptible_timeout(sdp->sd_async_glock_wait, 13109e8990deSAndreas Gruenbacher !test_bit(HIF_WAIT, &gh->gh_iflags) || 13119e8990deSAndreas Gruenbacher test_bit(GLF_DEMOTE, &ip->i_gl->gl_flags), 13129e73330fSAndreas Gruenbacher timeout); 13139e73330fSAndreas Gruenbacher if (!test_bit(HIF_HOLDER, &gh->gh_iflags)) { 13149e73330fSAndreas Gruenbacher gfs2_glock_dq(gh); 13159e73330fSAndreas Gruenbacher return false; 13169e73330fSAndreas Gruenbacher } 13179e73330fSAndreas Gruenbacher return true; 13189e73330fSAndreas Gruenbacher } 13199e73330fSAndreas Gruenbacher 132071c1b213SAndreas Gruenbacher /** 132153dbc27eSBob Peterson * evict_should_delete - determine whether the inode is eligible for deletion 132253dbc27eSBob Peterson * @inode: The inode to evict 132353dbc27eSBob Peterson * 132453dbc27eSBob Peterson * This function determines whether the evicted inode is eligible to be deleted 132553dbc27eSBob Peterson * and locks the inode glock. 132653dbc27eSBob Peterson * 132753dbc27eSBob Peterson * Returns: the fate of the dinode 132853dbc27eSBob Peterson */ 132953dbc27eSBob Peterson static enum dinode_demise evict_should_delete(struct inode *inode, 133053dbc27eSBob Peterson struct gfs2_holder *gh) 133153dbc27eSBob Peterson { 133253dbc27eSBob Peterson struct gfs2_inode *ip = GFS2_I(inode); 133353dbc27eSBob Peterson struct super_block *sb = inode->i_sb; 133453dbc27eSBob Peterson struct gfs2_sbd *sdp = sb->s_fs_info; 133553dbc27eSBob Peterson int ret; 133653dbc27eSBob Peterson 133753dbc27eSBob Peterson if (test_bit(GIF_ALLOC_FAILED, &ip->i_flags)) { 133853dbc27eSBob Peterson BUG_ON(!gfs2_glock_is_locked_by_me(ip->i_gl)); 133953dbc27eSBob Peterson goto should_delete; 134053dbc27eSBob Peterson } 134153dbc27eSBob Peterson 134253dbc27eSBob Peterson if (test_bit(GIF_DEFERRED_DELETE, &ip->i_flags)) 134353dbc27eSBob Peterson return SHOULD_DEFER_EVICTION; 134453dbc27eSBob Peterson 134553dbc27eSBob Peterson /* Deletes should never happen under memory pressure anymore. */ 134653dbc27eSBob Peterson if (WARN_ON_ONCE(current->flags & PF_MEMALLOC)) 134753dbc27eSBob Peterson return SHOULD_DEFER_EVICTION; 134853dbc27eSBob Peterson 134953dbc27eSBob Peterson /* Must not read inode block until block type has been verified */ 135053dbc27eSBob Peterson ret = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, GL_SKIP, gh); 135153dbc27eSBob Peterson if (unlikely(ret)) { 135253dbc27eSBob Peterson glock_clear_object(ip->i_iopen_gh.gh_gl, ip); 135353dbc27eSBob Peterson ip->i_iopen_gh.gh_flags |= GL_NOCACHE; 135453dbc27eSBob Peterson gfs2_glock_dq_uninit(&ip->i_iopen_gh); 135553dbc27eSBob Peterson return SHOULD_DEFER_EVICTION; 135653dbc27eSBob Peterson } 135753dbc27eSBob Peterson 135853dbc27eSBob Peterson if (gfs2_inode_already_deleted(ip->i_gl, ip->i_no_formal_ino)) 135953dbc27eSBob Peterson return SHOULD_NOT_DELETE_DINODE; 136053dbc27eSBob Peterson ret = gfs2_check_blk_type(sdp, ip->i_no_addr, GFS2_BLKST_UNLINKED); 136153dbc27eSBob Peterson if (ret) 136253dbc27eSBob Peterson return SHOULD_NOT_DELETE_DINODE; 136353dbc27eSBob Peterson 136453dbc27eSBob Peterson if (test_bit(GIF_INVALID, &ip->i_flags)) { 136553dbc27eSBob Peterson ret = gfs2_inode_refresh(ip); 136653dbc27eSBob Peterson if (ret) 136753dbc27eSBob Peterson return SHOULD_NOT_DELETE_DINODE; 136853dbc27eSBob Peterson } 136953dbc27eSBob Peterson 137053dbc27eSBob Peterson /* 137153dbc27eSBob Peterson * The inode may have been recreated in the meantime. 137253dbc27eSBob Peterson */ 137353dbc27eSBob Peterson if (inode->i_nlink) 137453dbc27eSBob Peterson return SHOULD_NOT_DELETE_DINODE; 137553dbc27eSBob Peterson 137653dbc27eSBob Peterson should_delete: 137753dbc27eSBob Peterson if (gfs2_holder_initialized(&ip->i_iopen_gh) && 137853dbc27eSBob Peterson test_bit(HIF_HOLDER, &ip->i_iopen_gh.gh_iflags)) { 137953dbc27eSBob Peterson if (!gfs2_upgrade_iopen_glock(inode)) { 138053dbc27eSBob Peterson gfs2_holder_uninit(&ip->i_iopen_gh); 138153dbc27eSBob Peterson return SHOULD_NOT_DELETE_DINODE; 138253dbc27eSBob Peterson } 138353dbc27eSBob Peterson } 138453dbc27eSBob Peterson return SHOULD_DELETE_DINODE; 138553dbc27eSBob Peterson } 138653dbc27eSBob Peterson 138753dbc27eSBob Peterson /** 13886e7e9a50SBob Peterson * evict_unlinked_inode - delete the pieces of an unlinked evicted inode 13896e7e9a50SBob Peterson * @inode: The inode to evict 13906e7e9a50SBob Peterson */ 13916e7e9a50SBob Peterson static int evict_unlinked_inode(struct inode *inode) 13926e7e9a50SBob Peterson { 13936e7e9a50SBob Peterson struct gfs2_inode *ip = GFS2_I(inode); 13946e7e9a50SBob Peterson int ret; 13956e7e9a50SBob Peterson 13966e7e9a50SBob Peterson if (S_ISDIR(inode->i_mode) && 13976e7e9a50SBob Peterson (ip->i_diskflags & GFS2_DIF_EXHASH)) { 13986e7e9a50SBob Peterson ret = gfs2_dir_exhash_dealloc(ip); 13996e7e9a50SBob Peterson if (ret) 14006e7e9a50SBob Peterson goto out; 14016e7e9a50SBob Peterson } 14026e7e9a50SBob Peterson 14036e7e9a50SBob Peterson if (ip->i_eattr) { 14046e7e9a50SBob Peterson ret = gfs2_ea_dealloc(ip); 14056e7e9a50SBob Peterson if (ret) 14066e7e9a50SBob Peterson goto out; 14076e7e9a50SBob Peterson } 14086e7e9a50SBob Peterson 14096e7e9a50SBob Peterson if (!gfs2_is_stuffed(ip)) { 14106e7e9a50SBob Peterson ret = gfs2_file_dealloc(ip); 14116e7e9a50SBob Peterson if (ret) 14126e7e9a50SBob Peterson goto out; 14136e7e9a50SBob Peterson } 14146e7e9a50SBob Peterson 14156e7e9a50SBob Peterson /* We're about to clear the bitmap for the dinode, but as soon as we 14166e7e9a50SBob Peterson do, gfs2_create_inode can create another inode at the same block 14176e7e9a50SBob Peterson location and try to set gl_object again. We clear gl_object here so 14186e7e9a50SBob Peterson that subsequent inode creates don't see an old gl_object. */ 14196e7e9a50SBob Peterson glock_clear_object(ip->i_gl, ip); 14206e7e9a50SBob Peterson ret = gfs2_dinode_dealloc(ip); 14216e7e9a50SBob Peterson gfs2_inode_remember_delete(ip->i_gl, ip->i_no_formal_ino); 14226e7e9a50SBob Peterson out: 14236e7e9a50SBob Peterson return ret; 14246e7e9a50SBob Peterson } 14256e7e9a50SBob Peterson 1426d90be6abSBob Peterson /* 1427d90be6abSBob Peterson * evict_linked_inode - evict an inode whose dinode has not been unlinked 1428d90be6abSBob Peterson * @inode: The inode to evict 1429d90be6abSBob Peterson */ 1430d90be6abSBob Peterson static int evict_linked_inode(struct inode *inode) 1431d90be6abSBob Peterson { 1432d90be6abSBob Peterson struct super_block *sb = inode->i_sb; 1433d90be6abSBob Peterson struct gfs2_sbd *sdp = sb->s_fs_info; 1434d90be6abSBob Peterson struct gfs2_inode *ip = GFS2_I(inode); 1435d90be6abSBob Peterson struct address_space *metamapping; 1436d90be6abSBob Peterson int ret; 1437d90be6abSBob Peterson 1438d90be6abSBob Peterson gfs2_log_flush(sdp, ip->i_gl, GFS2_LOG_HEAD_FLUSH_NORMAL | 1439d90be6abSBob Peterson GFS2_LFC_EVICT_INODE); 1440d90be6abSBob Peterson metamapping = gfs2_glock2aspace(ip->i_gl); 1441d90be6abSBob Peterson if (test_bit(GLF_DIRTY, &ip->i_gl->gl_flags)) { 1442d90be6abSBob Peterson filemap_fdatawrite(metamapping); 1443d90be6abSBob Peterson filemap_fdatawait(metamapping); 1444d90be6abSBob Peterson } 1445d90be6abSBob Peterson write_inode_now(inode, 1); 1446d90be6abSBob Peterson gfs2_ail_flush(ip->i_gl, 0); 1447d90be6abSBob Peterson 1448d90be6abSBob Peterson ret = gfs2_trans_begin(sdp, 0, sdp->sd_jdesc->jd_blocks); 1449d90be6abSBob Peterson if (ret) 1450d90be6abSBob Peterson return ret; 1451d90be6abSBob Peterson 1452d90be6abSBob Peterson /* Needs to be done before glock release & also in a transaction */ 1453d90be6abSBob Peterson truncate_inode_pages(&inode->i_data, 0); 1454d90be6abSBob Peterson truncate_inode_pages(metamapping, 0); 1455d90be6abSBob Peterson gfs2_trans_end(sdp); 1456d90be6abSBob Peterson return 0; 1457d90be6abSBob Peterson } 1458d90be6abSBob Peterson 14596e7e9a50SBob Peterson /** 1460380f7c65SSteven Whitehouse * gfs2_evict_inode - Remove an inode from cache 1461380f7c65SSteven Whitehouse * @inode: The inode to evict 1462380f7c65SSteven Whitehouse * 1463380f7c65SSteven Whitehouse * There are three cases to consider: 1464380f7c65SSteven Whitehouse * 1. i_nlink == 0, we are final opener (and must deallocate) 1465380f7c65SSteven Whitehouse * 2. i_nlink == 0, we are not the final opener (and cannot deallocate) 1466380f7c65SSteven Whitehouse * 3. i_nlink > 0 1467380f7c65SSteven Whitehouse * 1468380f7c65SSteven Whitehouse * If the fs is read only, then we have to treat all cases as per #3 1469380f7c65SSteven Whitehouse * since we are unable to do any deallocation. The inode will be 1470380f7c65SSteven Whitehouse * deallocated by the next read/write node to attempt an allocation 1471380f7c65SSteven Whitehouse * in the same resource group 1472380f7c65SSteven Whitehouse * 14739e6e0a12SSteven Whitehouse * We have to (at the moment) hold the inodes main lock to cover 14749e6e0a12SSteven Whitehouse * the gap between unlocking the shared lock on the iopen lock and 14759e6e0a12SSteven Whitehouse * taking the exclusive lock. I'd rather do a shared -> exclusive 14769e6e0a12SSteven Whitehouse * conversion on the iopen lock, but we can change that later. This 14779e6e0a12SSteven Whitehouse * is safe, just less efficient. 14789e6e0a12SSteven Whitehouse */ 14799e6e0a12SSteven Whitehouse 1480d5c1515cSAl Viro static void gfs2_evict_inode(struct inode *inode) 14819e6e0a12SSteven Whitehouse { 1482001e8e8dSSteven Whitehouse struct super_block *sb = inode->i_sb; 1483001e8e8dSSteven Whitehouse struct gfs2_sbd *sdp = sb->s_fs_info; 14849e6e0a12SSteven Whitehouse struct gfs2_inode *ip = GFS2_I(inode); 14859e6e0a12SSteven Whitehouse struct gfs2_holder gh; 148623d828fcSBob Peterson int ret; 14879e6e0a12SSteven Whitehouse 148805978803SAbhi Das if (test_bit(GIF_FREE_VFS_INODE, &ip->i_flags)) { 148905978803SAbhi Das clear_inode(inode); 149005978803SAbhi Das return; 149105978803SAbhi Das } 149205978803SAbhi Das 1493bc98a42cSDavid Howells if (inode->i_nlink || sb_rdonly(sb)) 1494d5c1515cSAl Viro goto out; 1495d5c1515cSAl Viro 1496e0b62e21SAndreas Gruenbacher gfs2_holder_mark_uninitialized(&gh); 149753dbc27eSBob Peterson ret = evict_should_delete(inode, &gh); 149853dbc27eSBob Peterson if (ret == SHOULD_DEFER_EVICTION) 14998c7b9262SAndreas Gruenbacher goto out; 15000a0d9f55SBob Peterson if (ret == SHOULD_DELETE_DINODE) 15016e7e9a50SBob Peterson ret = evict_unlinked_inode(inode); 15020a0d9f55SBob Peterson else 1503d90be6abSBob Peterson ret = evict_linked_inode(inode); 15049e6e0a12SSteven Whitehouse 1505a097dc7eSBob Peterson if (gfs2_rs_active(&ip->i_res)) 1506a097dc7eSBob Peterson gfs2_rs_deltree(&ip->i_res); 15078e2e0047SBob Peterson 1508240c6235SBob Peterson if (gfs2_holder_initialized(&gh)) { 1509240c6235SBob Peterson glock_clear_object(ip->i_gl, ip); 15109e6e0a12SSteven Whitehouse gfs2_glock_dq_uninit(&gh); 1511240c6235SBob Peterson } 151223d828fcSBob Peterson if (ret && ret != GLR_TRYFAILED && ret != -EROFS) 151323d828fcSBob Peterson fs_warn(sdp, "gfs2_evict_inode: %d\n", ret); 15149e6e0a12SSteven Whitehouse out: 151591b0abe3SJohannes Weiner truncate_inode_pages_final(&inode->i_data); 15162fba46a0SBob Peterson if (ip->i_qadata) 15172fba46a0SBob Peterson gfs2_assert_warn(sdp, ip->i_qadata->qa_ref == 0); 15181595548fSAndreas Gruenbacher gfs2_rs_delete(ip, NULL); 151945138990SSteven Whitehouse gfs2_ordered_del_inode(ip); 1520dbd5768fSJan Kara clear_inode(inode); 152117d539f0SSteven Whitehouse gfs2_dir_hash_inval(ip); 152240e7e86eSAndreas Gruenbacher if (ip->i_gl) { 1523df3d87bdSBob Peterson glock_clear_object(ip->i_gl, ip); 15244fd1a579SAndreas Gruenbacher wait_on_bit_io(&ip->i_flags, GIF_GLOP_PENDING, TASK_UNINTERRUPTIBLE); 152529687a2aSSteven Whitehouse gfs2_glock_add_to_lru(ip->i_gl); 152671c1b213SAndreas Gruenbacher gfs2_glock_put_eventually(ip->i_gl); 1527d5c1515cSAl Viro ip->i_gl = NULL; 152840e7e86eSAndreas Gruenbacher } 15296df9f9a2SAndreas Gruenbacher if (gfs2_holder_initialized(&ip->i_iopen_gh)) { 153071c1b213SAndreas Gruenbacher struct gfs2_glock *gl = ip->i_iopen_gh.gh_gl; 153171c1b213SAndreas Gruenbacher 153271c1b213SAndreas Gruenbacher glock_clear_object(gl, ip); 153340e7e86eSAndreas Gruenbacher if (test_bit(HIF_HOLDER, &ip->i_iopen_gh.gh_iflags)) { 1534a6a4d98bSBob Peterson ip->i_iopen_gh.gh_flags |= GL_NOCACHE; 153540e7e86eSAndreas Gruenbacher gfs2_glock_dq(&ip->i_iopen_gh); 153640e7e86eSAndreas Gruenbacher } 153771c1b213SAndreas Gruenbacher gfs2_glock_hold(gl); 153840e7e86eSAndreas Gruenbacher gfs2_holder_uninit(&ip->i_iopen_gh); 153971c1b213SAndreas Gruenbacher gfs2_glock_put_eventually(gl); 1540d5c1515cSAl Viro } 15419e6e0a12SSteven Whitehouse } 15429e6e0a12SSteven Whitehouse 15439e6e0a12SSteven Whitehouse static struct inode *gfs2_alloc_inode(struct super_block *sb) 15449e6e0a12SSteven Whitehouse { 15459e6e0a12SSteven Whitehouse struct gfs2_inode *ip; 15469e6e0a12SSteven Whitehouse 15479e6e0a12SSteven Whitehouse ip = kmem_cache_alloc(gfs2_inode_cachep, GFP_KERNEL); 1548d4031259SAndreas Gruenbacher if (!ip) 1549d4031259SAndreas Gruenbacher return NULL; 15509e6e0a12SSteven Whitehouse ip->i_flags = 0; 15519e6e0a12SSteven Whitehouse ip->i_gl = NULL; 155240e7e86eSAndreas Gruenbacher gfs2_holder_mark_uninitialized(&ip->i_iopen_gh); 1553a097dc7eSBob Peterson memset(&ip->i_res, 0, sizeof(ip->i_res)); 1554a097dc7eSBob Peterson RB_CLEAR_NODE(&ip->i_res.rs_node); 1555c8d57703SAndreas Gruenbacher ip->i_rahead = 0; 15569e6e0a12SSteven Whitehouse return &ip->i_inode; 15579e6e0a12SSteven Whitehouse } 15589e6e0a12SSteven Whitehouse 1559784494e1SAl Viro static void gfs2_free_inode(struct inode *inode) 1560fa0d7e3dSNick Piggin { 1561784494e1SAl Viro kmem_cache_free(gfs2_inode_cachep, GFS2_I(inode)); 15629e6e0a12SSteven Whitehouse } 15639e6e0a12SSteven Whitehouse 15649e6e0a12SSteven Whitehouse const struct super_operations gfs2_super_ops = { 15659e6e0a12SSteven Whitehouse .alloc_inode = gfs2_alloc_inode, 1566784494e1SAl Viro .free_inode = gfs2_free_inode, 15679e6e0a12SSteven Whitehouse .write_inode = gfs2_write_inode, 1568ab9bbda0SSteven Whitehouse .dirty_inode = gfs2_dirty_inode, 1569d5c1515cSAl Viro .evict_inode = gfs2_evict_inode, 15709e6e0a12SSteven Whitehouse .put_super = gfs2_put_super, 15719e6e0a12SSteven Whitehouse .sync_fs = gfs2_sync_fs, 15722e60d768SBenjamin Marzinski .freeze_super = gfs2_freeze, 15732e60d768SBenjamin Marzinski .thaw_super = gfs2_unfreeze, 15749e6e0a12SSteven Whitehouse .statfs = gfs2_statfs, 15759e6e0a12SSteven Whitehouse .drop_inode = gfs2_drop_inode, 15769e6e0a12SSteven Whitehouse .show_options = gfs2_show_options, 15779e6e0a12SSteven Whitehouse }; 15789e6e0a12SSteven Whitehouse 1579