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 85b3b94faaSDavid Teigland list_for_each_entry(jd, head, jd_list) { 86736b2f77SAndreas Gruenbacher if (jd->jd_jid == jid) 87b3b94faaSDavid Teigland return jd; 88b3b94faaSDavid Teigland } 89736b2f77SAndreas Gruenbacher return NULL; 90736b2f77SAndreas Gruenbacher } 91b3b94faaSDavid Teigland 92b3b94faaSDavid Teigland struct gfs2_jdesc *gfs2_jdesc_find(struct gfs2_sbd *sdp, unsigned int jid) 93b3b94faaSDavid Teigland { 94b3b94faaSDavid Teigland struct gfs2_jdesc *jd; 95b3b94faaSDavid Teigland 96b3b94faaSDavid Teigland spin_lock(&sdp->sd_jindex_spin); 97b3b94faaSDavid Teigland jd = jdesc_find_i(&sdp->sd_jindex_list, jid); 98b3b94faaSDavid Teigland spin_unlock(&sdp->sd_jindex_spin); 99b3b94faaSDavid Teigland 100b3b94faaSDavid Teigland return jd; 101b3b94faaSDavid Teigland } 102b3b94faaSDavid Teigland 103b3b94faaSDavid Teigland int gfs2_jdesc_check(struct gfs2_jdesc *jd) 104b3b94faaSDavid Teigland { 105feaa7bbaSSteven Whitehouse struct gfs2_inode *ip = GFS2_I(jd->jd_inode); 106feaa7bbaSSteven Whitehouse struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode); 107a2e0f799SSteven Whitehouse u64 size = i_size_read(jd->jd_inode); 108b3b94faaSDavid Teigland 10947a9a527SFabian Frederick if (gfs2_check_internal_file_size(jd->jd_inode, 8 << 20, BIT(30))) 110b3b94faaSDavid Teigland return -EIO; 111b3b94faaSDavid Teigland 112a2e0f799SSteven Whitehouse jd->jd_blocks = size >> sdp->sd_sb.sb_bsize_shift; 113a2e0f799SSteven Whitehouse 114a2e0f799SSteven Whitehouse if (gfs2_write_alloc_required(ip, 0, size)) { 115b3b94faaSDavid Teigland gfs2_consist_inode(ip); 116461cb419SBob Peterson return -EIO; 117b3b94faaSDavid Teigland } 118b3b94faaSDavid Teigland 119461cb419SBob Peterson return 0; 120b3b94faaSDavid Teigland } 121b3b94faaSDavid Teigland 1228ad151c2SSteven Whitehouse static int init_threads(struct gfs2_sbd *sdp) 1238ad151c2SSteven Whitehouse { 1248ad151c2SSteven Whitehouse struct task_struct *p; 1258ad151c2SSteven Whitehouse int error = 0; 1268ad151c2SSteven Whitehouse 1278ad151c2SSteven Whitehouse p = kthread_run(gfs2_logd, sdp, "gfs2_logd"); 1288ad151c2SSteven Whitehouse if (IS_ERR(p)) { 1298ad151c2SSteven Whitehouse error = PTR_ERR(p); 1308ad151c2SSteven Whitehouse fs_err(sdp, "can't start logd thread: %d\n", error); 1318ad151c2SSteven Whitehouse return error; 1328ad151c2SSteven Whitehouse } 1338ad151c2SSteven Whitehouse sdp->sd_logd_process = p; 1348ad151c2SSteven Whitehouse 1358ad151c2SSteven Whitehouse p = kthread_run(gfs2_quotad, sdp, "gfs2_quotad"); 1368ad151c2SSteven Whitehouse if (IS_ERR(p)) { 1378ad151c2SSteven Whitehouse error = PTR_ERR(p); 1388ad151c2SSteven Whitehouse fs_err(sdp, "can't start quotad thread: %d\n", error); 1398ad151c2SSteven Whitehouse goto fail; 1408ad151c2SSteven Whitehouse } 1418ad151c2SSteven Whitehouse sdp->sd_quotad_process = p; 1428ad151c2SSteven Whitehouse return 0; 1438ad151c2SSteven Whitehouse 1448ad151c2SSteven Whitehouse fail: 1458ad151c2SSteven Whitehouse kthread_stop(sdp->sd_logd_process); 1465b3a9f34SBob Peterson sdp->sd_logd_process = NULL; 1478ad151c2SSteven Whitehouse return error; 1488ad151c2SSteven Whitehouse } 1498ad151c2SSteven Whitehouse 150b3b94faaSDavid Teigland /** 151b3b94faaSDavid Teigland * gfs2_make_fs_rw - Turn a Read-Only FS into a Read-Write one 152b3b94faaSDavid Teigland * @sdp: the filesystem 153b3b94faaSDavid Teigland * 154b3b94faaSDavid Teigland * Returns: errno 155b3b94faaSDavid Teigland */ 156b3b94faaSDavid Teigland 157b3b94faaSDavid Teigland int gfs2_make_fs_rw(struct gfs2_sbd *sdp) 158b3b94faaSDavid Teigland { 159feaa7bbaSSteven Whitehouse struct gfs2_inode *ip = GFS2_I(sdp->sd_jdesc->jd_inode); 1605c676f6dSSteven Whitehouse struct gfs2_glock *j_gl = ip->i_gl; 16155167622SAl Viro struct gfs2_log_header_host head; 162b3b94faaSDavid Teigland int error; 163b3b94faaSDavid Teigland 1648ad151c2SSteven Whitehouse error = init_threads(sdp); 165b3b94faaSDavid Teigland if (error) 166b3b94faaSDavid Teigland return error; 167b3b94faaSDavid Teigland 1681a14d3a6SSteven Whitehouse j_gl->gl_ops->go_inval(j_gl, DIO_METADATA); 169601ef0d5SBob Peterson if (gfs2_withdrawn(sdp)) { 170601ef0d5SBob Peterson error = -EIO; 171601ef0d5SBob Peterson goto fail; 172601ef0d5SBob Peterson } 173b3b94faaSDavid Teigland 174f4686c26SAbhi Das error = gfs2_find_jhead(sdp->sd_jdesc, &head, false); 175601ef0d5SBob Peterson if (error || gfs2_withdrawn(sdp)) 176b3b94faaSDavid Teigland goto fail; 177b3b94faaSDavid Teigland 178b3b94faaSDavid Teigland if (!(head.lh_flags & GFS2_LOG_HEAD_UNMOUNT)) { 179b3b94faaSDavid Teigland gfs2_consist(sdp); 180b3b94faaSDavid Teigland error = -EIO; 181b3b94faaSDavid Teigland goto fail; 182b3b94faaSDavid Teigland } 183b3b94faaSDavid Teigland 184b3b94faaSDavid Teigland /* Initialize some head of the log stuff */ 185b3b94faaSDavid Teigland sdp->sd_log_sequence = head.lh_sequence + 1; 186b3b94faaSDavid Teigland gfs2_log_pointers_init(sdp, head.lh_blkno); 187b3b94faaSDavid Teigland 188b3b94faaSDavid Teigland error = gfs2_quota_init(sdp); 189601ef0d5SBob Peterson if (error || gfs2_withdrawn(sdp)) 190a91ea69fSSteven Whitehouse goto fail; 191b3b94faaSDavid Teigland 192b3b94faaSDavid Teigland set_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags); 193b3b94faaSDavid Teigland 194b3b94faaSDavid Teigland return 0; 195b3b94faaSDavid Teigland 196b3b94faaSDavid Teigland fail: 1975b3a9f34SBob Peterson if (sdp->sd_quotad_process) 1988ad151c2SSteven Whitehouse kthread_stop(sdp->sd_quotad_process); 1995b3a9f34SBob Peterson sdp->sd_quotad_process = NULL; 2005b3a9f34SBob Peterson if (sdp->sd_logd_process) 2018ad151c2SSteven Whitehouse kthread_stop(sdp->sd_logd_process); 2025b3a9f34SBob Peterson sdp->sd_logd_process = NULL; 203b3b94faaSDavid Teigland return error; 204b3b94faaSDavid Teigland } 205b3b94faaSDavid Teigland 2061946f70aSBenjamin Marzinski void gfs2_statfs_change_in(struct gfs2_statfs_change_host *sc, const void *buf) 207bb8d8a6fSSteven Whitehouse { 208bb8d8a6fSSteven Whitehouse const struct gfs2_statfs_change *str = buf; 209bb8d8a6fSSteven Whitehouse 210bb8d8a6fSSteven Whitehouse sc->sc_total = be64_to_cpu(str->sc_total); 211bb8d8a6fSSteven Whitehouse sc->sc_free = be64_to_cpu(str->sc_free); 212bb8d8a6fSSteven Whitehouse sc->sc_dinodes = be64_to_cpu(str->sc_dinodes); 213bb8d8a6fSSteven Whitehouse } 214bb8d8a6fSSteven Whitehouse 21573092698SAbhi Das void gfs2_statfs_change_out(const struct gfs2_statfs_change_host *sc, void *buf) 216bb8d8a6fSSteven Whitehouse { 217bb8d8a6fSSteven Whitehouse struct gfs2_statfs_change *str = buf; 218bb8d8a6fSSteven Whitehouse 219bb8d8a6fSSteven Whitehouse str->sc_total = cpu_to_be64(sc->sc_total); 220bb8d8a6fSSteven Whitehouse str->sc_free = cpu_to_be64(sc->sc_free); 221bb8d8a6fSSteven Whitehouse str->sc_dinodes = cpu_to_be64(sc->sc_dinodes); 222bb8d8a6fSSteven Whitehouse } 223bb8d8a6fSSteven Whitehouse 224b3b94faaSDavid Teigland int gfs2_statfs_init(struct gfs2_sbd *sdp) 225b3b94faaSDavid Teigland { 226feaa7bbaSSteven Whitehouse struct gfs2_inode *m_ip = GFS2_I(sdp->sd_statfs_inode); 227bd209cc0SAl Viro struct gfs2_statfs_change_host *m_sc = &sdp->sd_statfs_master; 228feaa7bbaSSteven Whitehouse struct gfs2_inode *l_ip = GFS2_I(sdp->sd_sc_inode); 229bd209cc0SAl Viro struct gfs2_statfs_change_host *l_sc = &sdp->sd_statfs_local; 230b3b94faaSDavid Teigland struct buffer_head *m_bh, *l_bh; 231b3b94faaSDavid Teigland struct gfs2_holder gh; 232b3b94faaSDavid Teigland int error; 233b3b94faaSDavid Teigland 234b3b94faaSDavid Teigland error = gfs2_glock_nq_init(m_ip->i_gl, LM_ST_EXCLUSIVE, GL_NOCACHE, 235b3b94faaSDavid Teigland &gh); 236b3b94faaSDavid Teigland if (error) 237b3b94faaSDavid Teigland return error; 238b3b94faaSDavid Teigland 239b3b94faaSDavid Teigland error = gfs2_meta_inode_buffer(m_ip, &m_bh); 240b3b94faaSDavid Teigland if (error) 241b3b94faaSDavid Teigland goto out; 242b3b94faaSDavid Teigland 243b3b94faaSDavid Teigland if (sdp->sd_args.ar_spectator) { 244b3b94faaSDavid Teigland spin_lock(&sdp->sd_statfs_spin); 245b3b94faaSDavid Teigland gfs2_statfs_change_in(m_sc, m_bh->b_data + 246b3b94faaSDavid Teigland sizeof(struct gfs2_dinode)); 247b3b94faaSDavid Teigland spin_unlock(&sdp->sd_statfs_spin); 248b3b94faaSDavid Teigland } else { 249b3b94faaSDavid Teigland error = gfs2_meta_inode_buffer(l_ip, &l_bh); 250b3b94faaSDavid Teigland if (error) 251b3b94faaSDavid Teigland goto out_m_bh; 252b3b94faaSDavid Teigland 253b3b94faaSDavid Teigland spin_lock(&sdp->sd_statfs_spin); 254b3b94faaSDavid Teigland gfs2_statfs_change_in(m_sc, m_bh->b_data + 255b3b94faaSDavid Teigland sizeof(struct gfs2_dinode)); 256b3b94faaSDavid Teigland gfs2_statfs_change_in(l_sc, l_bh->b_data + 257b3b94faaSDavid Teigland sizeof(struct gfs2_dinode)); 258b3b94faaSDavid Teigland spin_unlock(&sdp->sd_statfs_spin); 259b3b94faaSDavid Teigland 260b3b94faaSDavid Teigland brelse(l_bh); 261b3b94faaSDavid Teigland } 262b3b94faaSDavid Teigland 263b3b94faaSDavid Teigland out_m_bh: 264b3b94faaSDavid Teigland brelse(m_bh); 265b3b94faaSDavid Teigland out: 266b3b94faaSDavid Teigland gfs2_glock_dq_uninit(&gh); 267b3b94faaSDavid Teigland return 0; 268b3b94faaSDavid Teigland } 269b3b94faaSDavid Teigland 270cd915493SSteven Whitehouse void gfs2_statfs_change(struct gfs2_sbd *sdp, s64 total, s64 free, 271cd915493SSteven Whitehouse s64 dinodes) 272b3b94faaSDavid Teigland { 273feaa7bbaSSteven Whitehouse struct gfs2_inode *l_ip = GFS2_I(sdp->sd_sc_inode); 274bd209cc0SAl Viro struct gfs2_statfs_change_host *l_sc = &sdp->sd_statfs_local; 2753d3c10f2SBenjamin Marzinski struct gfs2_statfs_change_host *m_sc = &sdp->sd_statfs_master; 276b3b94faaSDavid Teigland struct buffer_head *l_bh; 277c14f5735SBenjamin Marzinski s64 x, y; 278c14f5735SBenjamin Marzinski int need_sync = 0; 279b3b94faaSDavid Teigland int error; 280b3b94faaSDavid Teigland 281b3b94faaSDavid Teigland error = gfs2_meta_inode_buffer(l_ip, &l_bh); 282b3b94faaSDavid Teigland if (error) 283b3b94faaSDavid Teigland return; 284b3b94faaSDavid Teigland 285350a9b0aSSteven Whitehouse gfs2_trans_add_meta(l_ip->i_gl, l_bh); 286b3b94faaSDavid Teigland 287b3b94faaSDavid Teigland spin_lock(&sdp->sd_statfs_spin); 288b3b94faaSDavid Teigland l_sc->sc_total += total; 289b3b94faaSDavid Teigland l_sc->sc_free += free; 290b3b94faaSDavid Teigland l_sc->sc_dinodes += dinodes; 291907b9bceSSteven Whitehouse gfs2_statfs_change_out(l_sc, l_bh->b_data + sizeof(struct gfs2_dinode)); 292c14f5735SBenjamin Marzinski if (sdp->sd_args.ar_statfs_percent) { 293c14f5735SBenjamin Marzinski x = 100 * l_sc->sc_free; 294c14f5735SBenjamin Marzinski y = m_sc->sc_free * sdp->sd_args.ar_statfs_percent; 295c14f5735SBenjamin Marzinski if (x >= y || x <= -y) 296c14f5735SBenjamin Marzinski need_sync = 1; 297c14f5735SBenjamin Marzinski } 298b3b94faaSDavid Teigland spin_unlock(&sdp->sd_statfs_spin); 299b3b94faaSDavid Teigland 300b3b94faaSDavid Teigland brelse(l_bh); 301c14f5735SBenjamin Marzinski if (need_sync) 3023d3c10f2SBenjamin Marzinski gfs2_wake_up_statfs(sdp); 303b3b94faaSDavid Teigland } 304b3b94faaSDavid Teigland 3051946f70aSBenjamin Marzinski void update_statfs(struct gfs2_sbd *sdp, struct buffer_head *m_bh, 3061946f70aSBenjamin Marzinski struct buffer_head *l_bh) 3071946f70aSBenjamin Marzinski { 3081946f70aSBenjamin Marzinski struct gfs2_inode *m_ip = GFS2_I(sdp->sd_statfs_inode); 3091946f70aSBenjamin Marzinski struct gfs2_inode *l_ip = GFS2_I(sdp->sd_sc_inode); 3101946f70aSBenjamin Marzinski struct gfs2_statfs_change_host *m_sc = &sdp->sd_statfs_master; 3111946f70aSBenjamin Marzinski struct gfs2_statfs_change_host *l_sc = &sdp->sd_statfs_local; 3121946f70aSBenjamin Marzinski 313350a9b0aSSteven Whitehouse gfs2_trans_add_meta(l_ip->i_gl, l_bh); 314901c6c66SBob Peterson gfs2_trans_add_meta(m_ip->i_gl, m_bh); 3151946f70aSBenjamin Marzinski 3161946f70aSBenjamin Marzinski spin_lock(&sdp->sd_statfs_spin); 3171946f70aSBenjamin Marzinski m_sc->sc_total += l_sc->sc_total; 3181946f70aSBenjamin Marzinski m_sc->sc_free += l_sc->sc_free; 3191946f70aSBenjamin Marzinski m_sc->sc_dinodes += l_sc->sc_dinodes; 3201946f70aSBenjamin Marzinski memset(l_sc, 0, sizeof(struct gfs2_statfs_change)); 3211946f70aSBenjamin Marzinski memset(l_bh->b_data + sizeof(struct gfs2_dinode), 3221946f70aSBenjamin Marzinski 0, sizeof(struct gfs2_statfs_change)); 3231946f70aSBenjamin Marzinski gfs2_statfs_change_out(m_sc, m_bh->b_data + sizeof(struct gfs2_dinode)); 324901c6c66SBob Peterson spin_unlock(&sdp->sd_statfs_spin); 3251946f70aSBenjamin Marzinski } 3261946f70aSBenjamin Marzinski 3278c42d637SSteven Whitehouse int gfs2_statfs_sync(struct super_block *sb, int type) 328b3b94faaSDavid Teigland { 3298c42d637SSteven Whitehouse struct gfs2_sbd *sdp = sb->s_fs_info; 330feaa7bbaSSteven Whitehouse struct gfs2_inode *m_ip = GFS2_I(sdp->sd_statfs_inode); 331feaa7bbaSSteven Whitehouse struct gfs2_inode *l_ip = GFS2_I(sdp->sd_sc_inode); 332bd209cc0SAl Viro struct gfs2_statfs_change_host *m_sc = &sdp->sd_statfs_master; 333bd209cc0SAl Viro struct gfs2_statfs_change_host *l_sc = &sdp->sd_statfs_local; 334b3b94faaSDavid Teigland struct gfs2_holder gh; 335b3b94faaSDavid Teigland struct buffer_head *m_bh, *l_bh; 336b3b94faaSDavid Teigland int error; 337b3b94faaSDavid Teigland 338b3b94faaSDavid Teigland error = gfs2_glock_nq_init(m_ip->i_gl, LM_ST_EXCLUSIVE, GL_NOCACHE, 339b3b94faaSDavid Teigland &gh); 340b3b94faaSDavid Teigland if (error) 3412e60d768SBenjamin Marzinski goto out; 342b3b94faaSDavid Teigland 343b3b94faaSDavid Teigland error = gfs2_meta_inode_buffer(m_ip, &m_bh); 344b3b94faaSDavid Teigland if (error) 3452e60d768SBenjamin Marzinski goto out_unlock; 346b3b94faaSDavid Teigland 347b3b94faaSDavid Teigland spin_lock(&sdp->sd_statfs_spin); 348b3b94faaSDavid Teigland gfs2_statfs_change_in(m_sc, m_bh->b_data + 349b3b94faaSDavid Teigland sizeof(struct gfs2_dinode)); 350b3b94faaSDavid Teigland if (!l_sc->sc_total && !l_sc->sc_free && !l_sc->sc_dinodes) { 351b3b94faaSDavid Teigland spin_unlock(&sdp->sd_statfs_spin); 352b3b94faaSDavid Teigland goto out_bh; 353b3b94faaSDavid Teigland } 354b3b94faaSDavid Teigland spin_unlock(&sdp->sd_statfs_spin); 355b3b94faaSDavid Teigland 356b3b94faaSDavid Teigland error = gfs2_meta_inode_buffer(l_ip, &l_bh); 357b3b94faaSDavid Teigland if (error) 358b3b94faaSDavid Teigland goto out_bh; 359b3b94faaSDavid Teigland 360b3b94faaSDavid Teigland error = gfs2_trans_begin(sdp, 2 * RES_DINODE, 0); 361b3b94faaSDavid Teigland if (error) 362b3b94faaSDavid Teigland goto out_bh2; 363b3b94faaSDavid Teigland 3641946f70aSBenjamin Marzinski update_statfs(sdp, m_bh, l_bh); 3653d3c10f2SBenjamin Marzinski sdp->sd_statfs_force_sync = 0; 366b3b94faaSDavid Teigland 367b3b94faaSDavid Teigland gfs2_trans_end(sdp); 368b3b94faaSDavid Teigland 369b3b94faaSDavid Teigland out_bh2: 370b3b94faaSDavid Teigland brelse(l_bh); 371b3b94faaSDavid Teigland out_bh: 372b3b94faaSDavid Teigland brelse(m_bh); 3732e60d768SBenjamin Marzinski out_unlock: 374b3b94faaSDavid Teigland gfs2_glock_dq_uninit(&gh); 3752e60d768SBenjamin Marzinski out: 376b3b94faaSDavid Teigland return error; 377b3b94faaSDavid Teigland } 378b3b94faaSDavid Teigland 379b3b94faaSDavid Teigland struct lfcc { 380b3b94faaSDavid Teigland struct list_head list; 381b3b94faaSDavid Teigland struct gfs2_holder gh; 382b3b94faaSDavid Teigland }; 383b3b94faaSDavid Teigland 384b3b94faaSDavid Teigland /** 385b3b94faaSDavid Teigland * gfs2_lock_fs_check_clean - Stop all writes to the FS and check that all 386b3b94faaSDavid Teigland * journals are clean 387b3b94faaSDavid Teigland * @sdp: the file system 388b3b94faaSDavid Teigland * @state: the state to put the transaction lock into 389b3b94faaSDavid Teigland * @t_gh: the hold on the transaction lock 390b3b94faaSDavid Teigland * 391b3b94faaSDavid Teigland * Returns: errno 392b3b94faaSDavid Teigland */ 393b3b94faaSDavid Teigland 39452b1cdcbSBob Peterson static int gfs2_lock_fs_check_clean(struct gfs2_sbd *sdp) 395b3b94faaSDavid Teigland { 3965c676f6dSSteven Whitehouse struct gfs2_inode *ip; 397b3b94faaSDavid Teigland struct gfs2_jdesc *jd; 398b3b94faaSDavid Teigland struct lfcc *lfcc; 399b3b94faaSDavid Teigland LIST_HEAD(list); 40055167622SAl Viro struct gfs2_log_header_host lh; 401b3b94faaSDavid Teigland int error; 402b3b94faaSDavid Teigland 403b3b94faaSDavid Teigland list_for_each_entry(jd, &sdp->sd_jindex_list, jd_list) { 404b3b94faaSDavid Teigland lfcc = kmalloc(sizeof(struct lfcc), GFP_KERNEL); 405b3b94faaSDavid Teigland if (!lfcc) { 406b3b94faaSDavid Teigland error = -ENOMEM; 407b3b94faaSDavid Teigland goto out; 408b3b94faaSDavid Teigland } 409feaa7bbaSSteven Whitehouse ip = GFS2_I(jd->jd_inode); 410feaa7bbaSSteven Whitehouse error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, 0, &lfcc->gh); 411b3b94faaSDavid Teigland if (error) { 412b3b94faaSDavid Teigland kfree(lfcc); 413b3b94faaSDavid Teigland goto out; 414b3b94faaSDavid Teigland } 415b3b94faaSDavid Teigland list_add(&lfcc->list, &list); 416b3b94faaSDavid Teigland } 417b3b94faaSDavid Teigland 41824972557SBenjamin Marzinski error = gfs2_glock_nq_init(sdp->sd_freeze_gl, LM_ST_EXCLUSIVE, 419c860f8ffSBob Peterson LM_FLAG_NOEXP, &sdp->sd_freeze_gh); 42052b1cdcbSBob Peterson if (error) 42152b1cdcbSBob Peterson goto out; 422b3b94faaSDavid Teigland 423b3b94faaSDavid Teigland list_for_each_entry(jd, &sdp->sd_jindex_list, jd_list) { 424b3b94faaSDavid Teigland error = gfs2_jdesc_check(jd); 425b3b94faaSDavid Teigland if (error) 426b3b94faaSDavid Teigland break; 427f4686c26SAbhi Das error = gfs2_find_jhead(jd, &lh, false); 428b3b94faaSDavid Teigland if (error) 429b3b94faaSDavid Teigland break; 430b3b94faaSDavid Teigland if (!(lh.lh_flags & GFS2_LOG_HEAD_UNMOUNT)) { 431b3b94faaSDavid Teigland error = -EBUSY; 432b3b94faaSDavid Teigland break; 433b3b94faaSDavid Teigland } 434b3b94faaSDavid Teigland } 435b3b94faaSDavid Teigland 436b3b94faaSDavid Teigland if (error) 437c77b52c0SBob Peterson gfs2_freeze_unlock(&sdp->sd_freeze_gh); 438b3b94faaSDavid Teigland 439b3b94faaSDavid Teigland out: 440b3b94faaSDavid Teigland while (!list_empty(&list)) { 441969183bcSAndreas Gruenbacher lfcc = list_first_entry(&list, struct lfcc, list); 442b3b94faaSDavid Teigland list_del(&lfcc->list); 443b3b94faaSDavid Teigland gfs2_glock_dq_uninit(&lfcc->gh); 444b3b94faaSDavid Teigland kfree(lfcc); 445b3b94faaSDavid Teigland } 446b3b94faaSDavid Teigland return error; 447b3b94faaSDavid Teigland } 448b3b94faaSDavid Teigland 4499eed04cdSSteven Whitehouse void gfs2_dinode_out(const struct gfs2_inode *ip, void *buf) 4509eed04cdSSteven Whitehouse { 4519eed04cdSSteven Whitehouse struct gfs2_dinode *str = buf; 4529eed04cdSSteven Whitehouse 4539eed04cdSSteven Whitehouse str->di_header.mh_magic = cpu_to_be32(GFS2_MAGIC); 4549eed04cdSSteven Whitehouse str->di_header.mh_type = cpu_to_be32(GFS2_METATYPE_DI); 4559eed04cdSSteven Whitehouse str->di_header.mh_format = cpu_to_be32(GFS2_FORMAT_DI); 4569eed04cdSSteven Whitehouse str->di_num.no_addr = cpu_to_be64(ip->i_no_addr); 4579eed04cdSSteven Whitehouse str->di_num.no_formal_ino = cpu_to_be64(ip->i_no_formal_ino); 4589eed04cdSSteven Whitehouse str->di_mode = cpu_to_be32(ip->i_inode.i_mode); 459d0546426SEric W. Biederman str->di_uid = cpu_to_be32(i_uid_read(&ip->i_inode)); 460d0546426SEric W. Biederman str->di_gid = cpu_to_be32(i_gid_read(&ip->i_inode)); 4619eed04cdSSteven Whitehouse str->di_nlink = cpu_to_be32(ip->i_inode.i_nlink); 4629eed04cdSSteven Whitehouse str->di_size = cpu_to_be64(i_size_read(&ip->i_inode)); 4639eed04cdSSteven Whitehouse str->di_blocks = cpu_to_be64(gfs2_get_inode_blocks(&ip->i_inode)); 4649eed04cdSSteven Whitehouse str->di_atime = cpu_to_be64(ip->i_inode.i_atime.tv_sec); 4659eed04cdSSteven Whitehouse str->di_mtime = cpu_to_be64(ip->i_inode.i_mtime.tv_sec); 4669eed04cdSSteven Whitehouse str->di_ctime = cpu_to_be64(ip->i_inode.i_ctime.tv_sec); 4679eed04cdSSteven Whitehouse 4689eed04cdSSteven Whitehouse str->di_goal_meta = cpu_to_be64(ip->i_goal); 4699eed04cdSSteven Whitehouse str->di_goal_data = cpu_to_be64(ip->i_goal); 4709eed04cdSSteven Whitehouse str->di_generation = cpu_to_be64(ip->i_generation); 4719eed04cdSSteven Whitehouse 4729eed04cdSSteven Whitehouse str->di_flags = cpu_to_be32(ip->i_diskflags); 4739eed04cdSSteven Whitehouse str->di_height = cpu_to_be16(ip->i_height); 4749eed04cdSSteven Whitehouse str->di_payload_format = cpu_to_be32(S_ISDIR(ip->i_inode.i_mode) && 4759eed04cdSSteven Whitehouse !(ip->i_diskflags & GFS2_DIF_EXHASH) ? 4769eed04cdSSteven Whitehouse GFS2_FORMAT_DE : 0); 4779eed04cdSSteven Whitehouse str->di_depth = cpu_to_be16(ip->i_depth); 4789eed04cdSSteven Whitehouse str->di_entries = cpu_to_be32(ip->i_entries); 4799eed04cdSSteven Whitehouse 4809eed04cdSSteven Whitehouse str->di_eattr = cpu_to_be64(ip->i_eattr); 4819eed04cdSSteven Whitehouse str->di_atime_nsec = cpu_to_be32(ip->i_inode.i_atime.tv_nsec); 4829eed04cdSSteven Whitehouse str->di_mtime_nsec = cpu_to_be32(ip->i_inode.i_mtime.tv_nsec); 4839eed04cdSSteven Whitehouse str->di_ctime_nsec = cpu_to_be32(ip->i_inode.i_ctime.tv_nsec); 4849eed04cdSSteven Whitehouse } 4859e6e0a12SSteven Whitehouse 4869e6e0a12SSteven Whitehouse /** 4879e6e0a12SSteven Whitehouse * gfs2_write_inode - Make sure the inode is stable on the disk 4889e6e0a12SSteven Whitehouse * @inode: The inode 4891027efaaSSteven Whitehouse * @wbc: The writeback control structure 4909e6e0a12SSteven Whitehouse * 4919e6e0a12SSteven Whitehouse * Returns: errno 4929e6e0a12SSteven Whitehouse */ 4939e6e0a12SSteven Whitehouse 494a9185b41SChristoph Hellwig static int gfs2_write_inode(struct inode *inode, struct writeback_control *wbc) 4959e6e0a12SSteven Whitehouse { 4969e6e0a12SSteven Whitehouse struct gfs2_inode *ip = GFS2_I(inode); 4979e6e0a12SSteven Whitehouse struct gfs2_sbd *sdp = GFS2_SB(inode); 4981027efaaSSteven Whitehouse struct address_space *metamapping = gfs2_glock2aspace(ip->i_gl); 499de1414a6SChristoph Hellwig struct backing_dev_info *bdi = inode_to_bdi(metamapping->host); 500ab9bbda0SSteven Whitehouse int ret = 0; 501adbc3ddfSBob Peterson bool flush_all = (wbc->sync_mode == WB_SYNC_ALL || gfs2_is_jdata(ip)); 5029e6e0a12SSteven Whitehouse 503adbc3ddfSBob Peterson if (flush_all) 504c1696fb8SBob Peterson gfs2_log_flush(GFS2_SB(inode), ip->i_gl, 505805c0907SBob Peterson GFS2_LOG_HEAD_FLUSH_NORMAL | 506805c0907SBob Peterson GFS2_LFC_WRITE_INODE); 507a88a341aSTejun Heo if (bdi->wb.dirty_exceeded) 5084667a0ecSSteven Whitehouse gfs2_ail1_flush(sdp, wbc); 5091d4ec642SSteven Whitehouse else 5101d4ec642SSteven Whitehouse filemap_fdatawrite(metamapping); 511adbc3ddfSBob Peterson if (flush_all) 5121027efaaSSteven Whitehouse ret = filemap_fdatawait(metamapping); 5131027efaaSSteven Whitehouse if (ret) 5141027efaaSSteven Whitehouse mark_inode_dirty_sync(inode); 515957a7acdSAbhi Das else { 516957a7acdSAbhi Das spin_lock(&inode->i_lock); 517957a7acdSAbhi Das if (!(inode->i_flags & I_DIRTY)) 518957a7acdSAbhi Das gfs2_ordered_del_inode(ip); 519957a7acdSAbhi Das spin_unlock(&inode->i_lock); 520957a7acdSAbhi Das } 5219e6e0a12SSteven Whitehouse return ret; 5229e6e0a12SSteven Whitehouse } 5239e6e0a12SSteven Whitehouse 5249e6e0a12SSteven Whitehouse /** 525ab9bbda0SSteven Whitehouse * gfs2_dirty_inode - check for atime updates 526ab9bbda0SSteven Whitehouse * @inode: The inode in question 527ab9bbda0SSteven Whitehouse * @flags: The type of dirty 528ab9bbda0SSteven Whitehouse * 529ab9bbda0SSteven Whitehouse * Unfortunately it can be called under any combination of inode 530ab9bbda0SSteven Whitehouse * glock and transaction lock, so we have to check carefully. 531ab9bbda0SSteven Whitehouse * 532ab9bbda0SSteven Whitehouse * At the moment this deals only with atime - it should be possible 533ab9bbda0SSteven Whitehouse * to expand that role in future, once a review of the locking has 534ab9bbda0SSteven Whitehouse * been carried out. 535ab9bbda0SSteven Whitehouse */ 536ab9bbda0SSteven Whitehouse 537ab9bbda0SSteven Whitehouse static void gfs2_dirty_inode(struct inode *inode, int flags) 538ab9bbda0SSteven Whitehouse { 539ab9bbda0SSteven Whitehouse struct gfs2_inode *ip = GFS2_I(inode); 540ab9bbda0SSteven Whitehouse struct gfs2_sbd *sdp = GFS2_SB(inode); 541ab9bbda0SSteven Whitehouse struct buffer_head *bh; 542ab9bbda0SSteven Whitehouse struct gfs2_holder gh; 543ab9bbda0SSteven Whitehouse int need_unlock = 0; 544ab9bbda0SSteven Whitehouse int need_endtrans = 0; 545ab9bbda0SSteven Whitehouse int ret; 546ab9bbda0SSteven Whitehouse 547eb43e660SBob Peterson if (unlikely(gfs2_withdrawn(sdp))) 5480d1c7ae9SBob Peterson return; 549ab9bbda0SSteven Whitehouse if (!gfs2_glock_is_locked_by_me(ip->i_gl)) { 550ab9bbda0SSteven Whitehouse ret = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh); 551ab9bbda0SSteven Whitehouse if (ret) { 552ab9bbda0SSteven Whitehouse fs_err(sdp, "dirty_inode: glock %d\n", ret); 553e28c02b9SBob Peterson gfs2_dump_glock(NULL, ip->i_gl, true); 554ab9bbda0SSteven Whitehouse return; 555ab9bbda0SSteven Whitehouse } 556ab9bbda0SSteven Whitehouse need_unlock = 1; 5573d162688SBenjamin Marzinski } else if (WARN_ON_ONCE(ip->i_gl->gl_state != LM_ST_EXCLUSIVE)) 5583d162688SBenjamin Marzinski return; 559ab9bbda0SSteven Whitehouse 560ab9bbda0SSteven Whitehouse if (current->journal_info == NULL) { 561ab9bbda0SSteven Whitehouse ret = gfs2_trans_begin(sdp, RES_DINODE, 0); 562ab9bbda0SSteven Whitehouse if (ret) { 563ab9bbda0SSteven Whitehouse fs_err(sdp, "dirty_inode: gfs2_trans_begin %d\n", ret); 564ab9bbda0SSteven Whitehouse goto out; 565ab9bbda0SSteven Whitehouse } 566ab9bbda0SSteven Whitehouse need_endtrans = 1; 567ab9bbda0SSteven Whitehouse } 568ab9bbda0SSteven Whitehouse 569ab9bbda0SSteven Whitehouse ret = gfs2_meta_inode_buffer(ip, &bh); 570ab9bbda0SSteven Whitehouse if (ret == 0) { 571350a9b0aSSteven Whitehouse gfs2_trans_add_meta(ip->i_gl, bh); 572ab9bbda0SSteven Whitehouse gfs2_dinode_out(ip, bh->b_data); 573ab9bbda0SSteven Whitehouse brelse(bh); 574ab9bbda0SSteven Whitehouse } 575ab9bbda0SSteven Whitehouse 576ab9bbda0SSteven Whitehouse if (need_endtrans) 577ab9bbda0SSteven Whitehouse gfs2_trans_end(sdp); 578ab9bbda0SSteven Whitehouse out: 579ab9bbda0SSteven Whitehouse if (need_unlock) 580ab9bbda0SSteven Whitehouse gfs2_glock_dq_uninit(&gh); 581ab9bbda0SSteven Whitehouse } 582ab9bbda0SSteven Whitehouse 583ab9bbda0SSteven Whitehouse /** 5849e6e0a12SSteven Whitehouse * gfs2_make_fs_ro - Turn a Read-Write FS into a Read-Only one 5859e6e0a12SSteven Whitehouse * @sdp: the filesystem 5869e6e0a12SSteven Whitehouse * 5879e6e0a12SSteven Whitehouse * Returns: errno 5889e6e0a12SSteven Whitehouse */ 5899e6e0a12SSteven Whitehouse 590*eb602521SYang Li void gfs2_make_fs_ro(struct gfs2_sbd *sdp) 5919e6e0a12SSteven Whitehouse { 592601ef0d5SBob Peterson int log_write_allowed = test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags); 5939e6e0a12SSteven Whitehouse 594a0e3cc65SAndreas Gruenbacher gfs2_flush_delete_work(sdp); 595601ef0d5SBob Peterson if (!log_write_allowed && current == sdp->sd_quotad_process) 596601ef0d5SBob Peterson fs_warn(sdp, "The quotad daemon is withdrawing.\n"); 597601ef0d5SBob Peterson else if (sdp->sd_quotad_process) 5988ad151c2SSteven Whitehouse kthread_stop(sdp->sd_quotad_process); 5995b3a9f34SBob Peterson sdp->sd_quotad_process = NULL; 600601ef0d5SBob Peterson 601601ef0d5SBob Peterson if (!log_write_allowed && current == sdp->sd_logd_process) 602601ef0d5SBob Peterson fs_warn(sdp, "The logd daemon is withdrawing.\n"); 603601ef0d5SBob Peterson else if (sdp->sd_logd_process) 6048ad151c2SSteven Whitehouse kthread_stop(sdp->sd_logd_process); 6055b3a9f34SBob Peterson sdp->sd_logd_process = NULL; 6068ad151c2SSteven Whitehouse 607601ef0d5SBob Peterson if (log_write_allowed) { 608ceed1723SJan Kara gfs2_quota_sync(sdp->sd_vfs, 0); 6098c42d637SSteven Whitehouse gfs2_statfs_sync(sdp->sd_vfs, 0); 6109e6e0a12SSteven Whitehouse 611805c0907SBob Peterson gfs2_log_flush(sdp, NULL, GFS2_LOG_HEAD_FLUSH_SHUTDOWN | 612805c0907SBob Peterson GFS2_LFC_MAKE_FS_RO); 613f3708fb5SAndreas Gruenbacher wait_event_timeout(sdp->sd_log_waitq, 614f3708fb5SAndreas Gruenbacher gfs2_log_is_empty(sdp), 615f3708fb5SAndreas Gruenbacher HZ * 5); 616f3708fb5SAndreas Gruenbacher gfs2_assert_warn(sdp, gfs2_log_is_empty(sdp)); 617601ef0d5SBob Peterson } else { 618f3708fb5SAndreas Gruenbacher wait_event_timeout(sdp->sd_log_waitq, 619f3708fb5SAndreas Gruenbacher gfs2_log_is_empty(sdp), 620601ef0d5SBob Peterson HZ * 5); 621601ef0d5SBob Peterson } 6229e6e0a12SSteven Whitehouse gfs2_quota_cleanup(sdp); 6239e6e0a12SSteven Whitehouse 624601ef0d5SBob Peterson if (!log_write_allowed) 625601ef0d5SBob Peterson sdp->sd_vfs->s_flags |= SB_RDONLY; 6269e6e0a12SSteven Whitehouse } 6279e6e0a12SSteven Whitehouse 6289e6e0a12SSteven Whitehouse /** 6299e6e0a12SSteven Whitehouse * gfs2_put_super - Unmount the filesystem 6309e6e0a12SSteven Whitehouse * @sb: The VFS superblock 6319e6e0a12SSteven Whitehouse * 6329e6e0a12SSteven Whitehouse */ 6339e6e0a12SSteven Whitehouse 6349e6e0a12SSteven Whitehouse static void gfs2_put_super(struct super_block *sb) 6359e6e0a12SSteven Whitehouse { 6369e6e0a12SSteven Whitehouse struct gfs2_sbd *sdp = sb->s_fs_info; 6379e6e0a12SSteven Whitehouse struct gfs2_jdesc *jd; 6389e6e0a12SSteven Whitehouse 6399e6e0a12SSteven Whitehouse /* No more recovery requests */ 6409e6e0a12SSteven Whitehouse set_bit(SDF_NORECOVERY, &sdp->sd_flags); 6419e6e0a12SSteven Whitehouse smp_mb(); 6429e6e0a12SSteven Whitehouse 6439e6e0a12SSteven Whitehouse /* Wait on outstanding recovery */ 6449e6e0a12SSteven Whitehouse restart: 6459e6e0a12SSteven Whitehouse spin_lock(&sdp->sd_jindex_spin); 6469e6e0a12SSteven Whitehouse list_for_each_entry(jd, &sdp->sd_jindex_list, jd_list) { 6479e6e0a12SSteven Whitehouse if (!test_bit(JDF_RECOVERY, &jd->jd_flags)) 6489e6e0a12SSteven Whitehouse continue; 6499e6e0a12SSteven Whitehouse spin_unlock(&sdp->sd_jindex_spin); 6509e6e0a12SSteven Whitehouse wait_on_bit(&jd->jd_flags, JDF_RECOVERY, 65174316201SNeilBrown TASK_UNINTERRUPTIBLE); 6529e6e0a12SSteven Whitehouse goto restart; 6539e6e0a12SSteven Whitehouse } 6549e6e0a12SSteven Whitehouse spin_unlock(&sdp->sd_jindex_spin); 6559e6e0a12SSteven Whitehouse 656bc98a42cSDavid Howells if (!sb_rdonly(sb)) { 657*eb602521SYang Li gfs2_make_fs_ro(sdp); 6589e6e0a12SSteven Whitehouse } 6595a61ae14SAndreas Gruenbacher WARN_ON(gfs2_withdrawing(sdp)); 6605a61ae14SAndreas Gruenbacher 6619e6e0a12SSteven Whitehouse /* At this point, we're through modifying the disk */ 6629e6e0a12SSteven Whitehouse 6639e6e0a12SSteven Whitehouse /* Release stuff */ 6649e6e0a12SSteven Whitehouse 6659e6e0a12SSteven Whitehouse iput(sdp->sd_jindex); 6669e6e0a12SSteven Whitehouse iput(sdp->sd_statfs_inode); 6679e6e0a12SSteven Whitehouse iput(sdp->sd_rindex); 6689e6e0a12SSteven Whitehouse iput(sdp->sd_quota_inode); 6699e6e0a12SSteven Whitehouse 6709e6e0a12SSteven Whitehouse gfs2_glock_put(sdp->sd_rename_gl); 67124972557SBenjamin Marzinski gfs2_glock_put(sdp->sd_freeze_gl); 6729e6e0a12SSteven Whitehouse 6739e6e0a12SSteven Whitehouse if (!sdp->sd_args.ar_spectator) { 674601ef0d5SBob Peterson if (gfs2_holder_initialized(&sdp->sd_journal_gh)) 6759e6e0a12SSteven Whitehouse gfs2_glock_dq_uninit(&sdp->sd_journal_gh); 676601ef0d5SBob Peterson if (gfs2_holder_initialized(&sdp->sd_jinode_gh)) 6779e6e0a12SSteven Whitehouse gfs2_glock_dq_uninit(&sdp->sd_jinode_gh); 6789e6e0a12SSteven Whitehouse gfs2_glock_dq_uninit(&sdp->sd_sc_gh); 6799e6e0a12SSteven Whitehouse gfs2_glock_dq_uninit(&sdp->sd_qc_gh); 68097fd734bSAbhi Das free_local_statfs_inodes(sdp); 6819e6e0a12SSteven Whitehouse iput(sdp->sd_qc_inode); 6829e6e0a12SSteven Whitehouse } 6839e6e0a12SSteven Whitehouse 6849e6e0a12SSteven Whitehouse gfs2_glock_dq_uninit(&sdp->sd_live_gh); 6859e6e0a12SSteven Whitehouse gfs2_clear_rgrpd(sdp); 6869e6e0a12SSteven Whitehouse gfs2_jindex_free(sdp); 6879e6e0a12SSteven Whitehouse /* Take apart glock structures and buffer lists */ 6889e6e0a12SSteven Whitehouse gfs2_gl_hash_clear(sdp); 689a9dd945cSBob Peterson truncate_inode_pages_final(&sdp->sd_aspace); 690b2fb7dabSBob Peterson gfs2_delete_debugfs_file(sdp); 6919e6e0a12SSteven Whitehouse /* Unmount the locking protocol */ 6929e6e0a12SSteven Whitehouse gfs2_lm_unmount(sdp); 6939e6e0a12SSteven Whitehouse 6949e6e0a12SSteven Whitehouse /* At this point, we're through participating in the lockspace */ 6959e6e0a12SSteven Whitehouse gfs2_sys_fs_del(sdp); 696c2a04b02SJamie Iles free_sbd(sdp); 6979e6e0a12SSteven Whitehouse } 6989e6e0a12SSteven Whitehouse 6999e6e0a12SSteven Whitehouse /** 7009e6e0a12SSteven Whitehouse * gfs2_sync_fs - sync the filesystem 7019e6e0a12SSteven Whitehouse * @sb: the superblock 7029e6e0a12SSteven Whitehouse * 7039e6e0a12SSteven Whitehouse * Flushes the log to disk. 7049e6e0a12SSteven Whitehouse */ 7059e6e0a12SSteven Whitehouse 7069e6e0a12SSteven Whitehouse static int gfs2_sync_fs(struct super_block *sb, int wait) 7079e6e0a12SSteven Whitehouse { 7081027efaaSSteven Whitehouse struct gfs2_sbd *sdp = sb->s_fs_info; 709a1177825SJan Kara 710a1177825SJan Kara gfs2_quota_sync(sb, -1); 711942b0cddSBob Peterson if (wait) 712805c0907SBob Peterson gfs2_log_flush(sdp, NULL, GFS2_LOG_HEAD_FLUSH_NORMAL | 713805c0907SBob Peterson GFS2_LFC_SYNC_FS); 714942b0cddSBob Peterson return sdp->sd_log_error; 7159e6e0a12SSteven Whitehouse } 7169e6e0a12SSteven Whitehouse 7172e60d768SBenjamin Marzinski void gfs2_freeze_func(struct work_struct *work) 7182e60d768SBenjamin Marzinski { 7192e60d768SBenjamin Marzinski int error; 7202e60d768SBenjamin Marzinski struct gfs2_holder freeze_gh; 7212e60d768SBenjamin Marzinski struct gfs2_sbd *sdp = container_of(work, struct gfs2_sbd, sd_freeze_work); 7222e60d768SBenjamin Marzinski struct super_block *sb = sdp->sd_vfs; 7232e60d768SBenjamin Marzinski 7242e60d768SBenjamin Marzinski atomic_inc(&sb->s_active); 725c77b52c0SBob Peterson error = gfs2_freeze_lock(sdp, &freeze_gh, 0); 7262e60d768SBenjamin Marzinski if (error) { 7272e60d768SBenjamin Marzinski gfs2_assert_withdraw(sdp, 0); 7288f918219SAbhi Das } else { 7292e60d768SBenjamin Marzinski atomic_set(&sdp->sd_freeze_state, SFS_UNFROZEN); 7302e60d768SBenjamin Marzinski error = thaw_super(sb); 7312e60d768SBenjamin Marzinski if (error) { 732f29e62eeSBob Peterson fs_info(sdp, "GFS2: couldn't thaw filesystem: %d\n", 7332e60d768SBenjamin Marzinski error); 7342e60d768SBenjamin Marzinski gfs2_assert_withdraw(sdp, 0); 7352e60d768SBenjamin Marzinski } 736c77b52c0SBob Peterson gfs2_freeze_unlock(&freeze_gh); 7372e60d768SBenjamin Marzinski } 7382e60d768SBenjamin Marzinski deactivate_super(sb); 7398f918219SAbhi Das clear_bit_unlock(SDF_FS_FROZEN, &sdp->sd_flags); 7408f918219SAbhi Das wake_up_bit(&sdp->sd_flags, SDF_FS_FROZEN); 7412e60d768SBenjamin Marzinski return; 7422e60d768SBenjamin Marzinski } 7432e60d768SBenjamin Marzinski 7449e6e0a12SSteven Whitehouse /** 7459e6e0a12SSteven Whitehouse * gfs2_freeze - prevent further writes to the filesystem 7469e6e0a12SSteven Whitehouse * @sb: the VFS structure for the filesystem 7479e6e0a12SSteven Whitehouse * 7489e6e0a12SSteven Whitehouse */ 7499e6e0a12SSteven Whitehouse 7509e6e0a12SSteven Whitehouse static int gfs2_freeze(struct super_block *sb) 7519e6e0a12SSteven Whitehouse { 7529e6e0a12SSteven Whitehouse struct gfs2_sbd *sdp = sb->s_fs_info; 7532e60d768SBenjamin Marzinski int error = 0; 7549e6e0a12SSteven Whitehouse 7552e60d768SBenjamin Marzinski mutex_lock(&sdp->sd_freeze_mutex); 7562e60d768SBenjamin Marzinski if (atomic_read(&sdp->sd_freeze_state) != SFS_UNFROZEN) 7572e60d768SBenjamin Marzinski goto out; 7582e60d768SBenjamin Marzinski 75960528afaSBob Peterson for (;;) { 760eb43e660SBob Peterson if (gfs2_withdrawn(sdp)) { 7612e60d768SBenjamin Marzinski error = -EINVAL; 7622e60d768SBenjamin Marzinski goto out; 7632e60d768SBenjamin Marzinski } 7649e6e0a12SSteven Whitehouse 76552b1cdcbSBob Peterson error = gfs2_lock_fs_check_clean(sdp); 7669e6e0a12SSteven Whitehouse if (!error) 7679e6e0a12SSteven Whitehouse break; 7689e6e0a12SSteven Whitehouse 76955317f5bSBob Peterson if (error == -EBUSY) 7709e6e0a12SSteven Whitehouse fs_err(sdp, "waiting for recovery before freeze\n"); 77152b1cdcbSBob Peterson else if (error == -EIO) { 77252b1cdcbSBob Peterson fs_err(sdp, "Fatal IO error: cannot freeze gfs2 due " 77352b1cdcbSBob Peterson "to recovery error.\n"); 77452b1cdcbSBob Peterson goto out; 77552b1cdcbSBob Peterson } else { 7769e6e0a12SSteven Whitehouse fs_err(sdp, "error freezing FS: %d\n", error); 77752b1cdcbSBob Peterson } 7789e6e0a12SSteven Whitehouse fs_err(sdp, "retrying...\n"); 7799e6e0a12SSteven Whitehouse msleep(1000); 7809e6e0a12SSteven Whitehouse } 7818f918219SAbhi Das set_bit(SDF_FS_FROZEN, &sdp->sd_flags); 7822e60d768SBenjamin Marzinski out: 7832e60d768SBenjamin Marzinski mutex_unlock(&sdp->sd_freeze_mutex); 7842e60d768SBenjamin Marzinski return error; 7859e6e0a12SSteven Whitehouse } 7869e6e0a12SSteven Whitehouse 7879e6e0a12SSteven Whitehouse /** 7889e6e0a12SSteven Whitehouse * gfs2_unfreeze - reallow writes to the filesystem 7899e6e0a12SSteven Whitehouse * @sb: the VFS structure for the filesystem 7909e6e0a12SSteven Whitehouse * 7919e6e0a12SSteven Whitehouse */ 7929e6e0a12SSteven Whitehouse 7939e6e0a12SSteven Whitehouse static int gfs2_unfreeze(struct super_block *sb) 7949e6e0a12SSteven Whitehouse { 795d564053fSSteven Whitehouse struct gfs2_sbd *sdp = sb->s_fs_info; 796d564053fSSteven Whitehouse 7972e60d768SBenjamin Marzinski mutex_lock(&sdp->sd_freeze_mutex); 7982e60d768SBenjamin Marzinski if (atomic_read(&sdp->sd_freeze_state) != SFS_FROZEN || 7996df9f9a2SAndreas Gruenbacher !gfs2_holder_initialized(&sdp->sd_freeze_gh)) { 8002e60d768SBenjamin Marzinski mutex_unlock(&sdp->sd_freeze_mutex); 8012e60d768SBenjamin Marzinski return 0; 8022e60d768SBenjamin Marzinski } 8032e60d768SBenjamin Marzinski 804c77b52c0SBob Peterson gfs2_freeze_unlock(&sdp->sd_freeze_gh); 8052e60d768SBenjamin Marzinski mutex_unlock(&sdp->sd_freeze_mutex); 8068f918219SAbhi Das return wait_on_bit(&sdp->sd_flags, SDF_FS_FROZEN, TASK_INTERRUPTIBLE); 8079e6e0a12SSteven Whitehouse } 8089e6e0a12SSteven Whitehouse 8099e6e0a12SSteven Whitehouse /** 8109e6e0a12SSteven Whitehouse * statfs_fill - fill in the sg for a given RG 8119e6e0a12SSteven Whitehouse * @rgd: the RG 8129e6e0a12SSteven Whitehouse * @sc: the sc structure 8139e6e0a12SSteven Whitehouse * 8149e6e0a12SSteven Whitehouse * Returns: 0 on success, -ESTALE if the LVB is invalid 8159e6e0a12SSteven Whitehouse */ 8169e6e0a12SSteven Whitehouse 8179e6e0a12SSteven Whitehouse static int statfs_slow_fill(struct gfs2_rgrpd *rgd, 8189e6e0a12SSteven Whitehouse struct gfs2_statfs_change_host *sc) 8199e6e0a12SSteven Whitehouse { 8209e6e0a12SSteven Whitehouse gfs2_rgrp_verify(rgd); 8219e6e0a12SSteven Whitehouse sc->sc_total += rgd->rd_data; 8229e6e0a12SSteven Whitehouse sc->sc_free += rgd->rd_free; 8239e6e0a12SSteven Whitehouse sc->sc_dinodes += rgd->rd_dinodes; 8249e6e0a12SSteven Whitehouse return 0; 8259e6e0a12SSteven Whitehouse } 8269e6e0a12SSteven Whitehouse 8279e6e0a12SSteven Whitehouse /** 8289e6e0a12SSteven Whitehouse * gfs2_statfs_slow - Stat a filesystem using asynchronous locking 8299e6e0a12SSteven Whitehouse * @sdp: the filesystem 8309e6e0a12SSteven Whitehouse * @sc: the sc info that will be returned 8319e6e0a12SSteven Whitehouse * 8329e6e0a12SSteven Whitehouse * Any error (other than a signal) will cause this routine to fall back 8339e6e0a12SSteven Whitehouse * to the synchronous version. 8349e6e0a12SSteven Whitehouse * 8359e6e0a12SSteven Whitehouse * FIXME: This really shouldn't busy wait like this. 8369e6e0a12SSteven Whitehouse * 8379e6e0a12SSteven Whitehouse * Returns: errno 8389e6e0a12SSteven Whitehouse */ 8399e6e0a12SSteven Whitehouse 8409e6e0a12SSteven Whitehouse static int gfs2_statfs_slow(struct gfs2_sbd *sdp, struct gfs2_statfs_change_host *sc) 8419e6e0a12SSteven Whitehouse { 8429e6e0a12SSteven Whitehouse struct gfs2_rgrpd *rgd_next; 8439e6e0a12SSteven Whitehouse struct gfs2_holder *gha, *gh; 8449e6e0a12SSteven Whitehouse unsigned int slots = 64; 8459e6e0a12SSteven Whitehouse unsigned int x; 8469e6e0a12SSteven Whitehouse int done; 8479e6e0a12SSteven Whitehouse int error = 0, err; 8489e6e0a12SSteven Whitehouse 8499e6e0a12SSteven Whitehouse memset(sc, 0, sizeof(struct gfs2_statfs_change_host)); 8506da2ec56SKees Cook gha = kmalloc_array(slots, sizeof(struct gfs2_holder), GFP_KERNEL); 8519e6e0a12SSteven Whitehouse if (!gha) 8529e6e0a12SSteven Whitehouse return -ENOMEM; 8536df9f9a2SAndreas Gruenbacher for (x = 0; x < slots; x++) 8546df9f9a2SAndreas Gruenbacher gfs2_holder_mark_uninitialized(gha + x); 8559e6e0a12SSteven Whitehouse 8569e6e0a12SSteven Whitehouse rgd_next = gfs2_rgrpd_get_first(sdp); 8579e6e0a12SSteven Whitehouse 8589e6e0a12SSteven Whitehouse for (;;) { 8599e6e0a12SSteven Whitehouse done = 1; 8609e6e0a12SSteven Whitehouse 8619e6e0a12SSteven Whitehouse for (x = 0; x < slots; x++) { 8629e6e0a12SSteven Whitehouse gh = gha + x; 8639e6e0a12SSteven Whitehouse 8646df9f9a2SAndreas Gruenbacher if (gfs2_holder_initialized(gh) && gfs2_glock_poll(gh)) { 8659e6e0a12SSteven Whitehouse err = gfs2_glock_wait(gh); 8669e6e0a12SSteven Whitehouse if (err) { 8679e6e0a12SSteven Whitehouse gfs2_holder_uninit(gh); 8689e6e0a12SSteven Whitehouse error = err; 8699e6e0a12SSteven Whitehouse } else { 8706f6597baSAndreas Gruenbacher if (!error) { 8716f6597baSAndreas Gruenbacher struct gfs2_rgrpd *rgd = 8726f6597baSAndreas Gruenbacher gfs2_glock2rgrp(gh->gh_gl); 8736f6597baSAndreas Gruenbacher 8746f6597baSAndreas Gruenbacher error = statfs_slow_fill(rgd, sc); 8756f6597baSAndreas Gruenbacher } 8769e6e0a12SSteven Whitehouse gfs2_glock_dq_uninit(gh); 8779e6e0a12SSteven Whitehouse } 8789e6e0a12SSteven Whitehouse } 8799e6e0a12SSteven Whitehouse 8806df9f9a2SAndreas Gruenbacher if (gfs2_holder_initialized(gh)) 8819e6e0a12SSteven Whitehouse done = 0; 8829e6e0a12SSteven Whitehouse else if (rgd_next && !error) { 8839e6e0a12SSteven Whitehouse error = gfs2_glock_nq_init(rgd_next->rd_gl, 8849e6e0a12SSteven Whitehouse LM_ST_SHARED, 8859e6e0a12SSteven Whitehouse GL_ASYNC, 8869e6e0a12SSteven Whitehouse gh); 8879e6e0a12SSteven Whitehouse rgd_next = gfs2_rgrpd_get_next(rgd_next); 8889e6e0a12SSteven Whitehouse done = 0; 8899e6e0a12SSteven Whitehouse } 8909e6e0a12SSteven Whitehouse 8919e6e0a12SSteven Whitehouse if (signal_pending(current)) 8929e6e0a12SSteven Whitehouse error = -ERESTARTSYS; 8939e6e0a12SSteven Whitehouse } 8949e6e0a12SSteven Whitehouse 8959e6e0a12SSteven Whitehouse if (done) 8969e6e0a12SSteven Whitehouse break; 8979e6e0a12SSteven Whitehouse 8989e6e0a12SSteven Whitehouse yield(); 8999e6e0a12SSteven Whitehouse } 9009e6e0a12SSteven Whitehouse 9019e6e0a12SSteven Whitehouse kfree(gha); 9029e6e0a12SSteven Whitehouse return error; 9039e6e0a12SSteven Whitehouse } 9049e6e0a12SSteven Whitehouse 9059e6e0a12SSteven Whitehouse /** 9069e6e0a12SSteven Whitehouse * gfs2_statfs_i - Do a statfs 9079e6e0a12SSteven Whitehouse * @sdp: the filesystem 9089e6e0a12SSteven Whitehouse * @sg: the sg structure 9099e6e0a12SSteven Whitehouse * 9109e6e0a12SSteven Whitehouse * Returns: errno 9119e6e0a12SSteven Whitehouse */ 9129e6e0a12SSteven Whitehouse 9139e6e0a12SSteven Whitehouse static int gfs2_statfs_i(struct gfs2_sbd *sdp, struct gfs2_statfs_change_host *sc) 9149e6e0a12SSteven Whitehouse { 9159e6e0a12SSteven Whitehouse struct gfs2_statfs_change_host *m_sc = &sdp->sd_statfs_master; 9169e6e0a12SSteven Whitehouse struct gfs2_statfs_change_host *l_sc = &sdp->sd_statfs_local; 9179e6e0a12SSteven Whitehouse 9189e6e0a12SSteven Whitehouse spin_lock(&sdp->sd_statfs_spin); 9199e6e0a12SSteven Whitehouse 9209e6e0a12SSteven Whitehouse *sc = *m_sc; 9219e6e0a12SSteven Whitehouse sc->sc_total += l_sc->sc_total; 9229e6e0a12SSteven Whitehouse sc->sc_free += l_sc->sc_free; 9239e6e0a12SSteven Whitehouse sc->sc_dinodes += l_sc->sc_dinodes; 9249e6e0a12SSteven Whitehouse 9259e6e0a12SSteven Whitehouse spin_unlock(&sdp->sd_statfs_spin); 9269e6e0a12SSteven Whitehouse 9279e6e0a12SSteven Whitehouse if (sc->sc_free < 0) 9289e6e0a12SSteven Whitehouse sc->sc_free = 0; 9299e6e0a12SSteven Whitehouse if (sc->sc_free > sc->sc_total) 9309e6e0a12SSteven Whitehouse sc->sc_free = sc->sc_total; 9319e6e0a12SSteven Whitehouse if (sc->sc_dinodes < 0) 9329e6e0a12SSteven Whitehouse sc->sc_dinodes = 0; 9339e6e0a12SSteven Whitehouse 9349e6e0a12SSteven Whitehouse return 0; 9359e6e0a12SSteven Whitehouse } 9369e6e0a12SSteven Whitehouse 9379e6e0a12SSteven Whitehouse /** 9389e6e0a12SSteven Whitehouse * gfs2_statfs - Gather and return stats about the filesystem 9399e6e0a12SSteven Whitehouse * @sb: The superblock 9409e6e0a12SSteven Whitehouse * @statfsbuf: The buffer 9419e6e0a12SSteven Whitehouse * 9429e6e0a12SSteven Whitehouse * Returns: 0 on success or error code 9439e6e0a12SSteven Whitehouse */ 9449e6e0a12SSteven Whitehouse 9459e6e0a12SSteven Whitehouse static int gfs2_statfs(struct dentry *dentry, struct kstatfs *buf) 9469e6e0a12SSteven Whitehouse { 947fc64005cSAl Viro struct super_block *sb = dentry->d_sb; 9489e6e0a12SSteven Whitehouse struct gfs2_sbd *sdp = sb->s_fs_info; 9499e6e0a12SSteven Whitehouse struct gfs2_statfs_change_host sc; 9509e6e0a12SSteven Whitehouse int error; 9519e6e0a12SSteven Whitehouse 9528339ee54SSteven Whitehouse error = gfs2_rindex_update(sdp); 9538339ee54SSteven Whitehouse if (error) 9548339ee54SSteven Whitehouse return error; 9558339ee54SSteven Whitehouse 9569e6e0a12SSteven Whitehouse if (gfs2_tune_get(sdp, gt_statfs_slow)) 9579e6e0a12SSteven Whitehouse error = gfs2_statfs_slow(sdp, &sc); 9589e6e0a12SSteven Whitehouse else 9599e6e0a12SSteven Whitehouse error = gfs2_statfs_i(sdp, &sc); 9609e6e0a12SSteven Whitehouse 9619e6e0a12SSteven Whitehouse if (error) 9629e6e0a12SSteven Whitehouse return error; 9639e6e0a12SSteven Whitehouse 9649e6e0a12SSteven Whitehouse buf->f_type = GFS2_MAGIC; 9659e6e0a12SSteven Whitehouse buf->f_bsize = sdp->sd_sb.sb_bsize; 9669e6e0a12SSteven Whitehouse buf->f_blocks = sc.sc_total; 9679e6e0a12SSteven Whitehouse buf->f_bfree = sc.sc_free; 9689e6e0a12SSteven Whitehouse buf->f_bavail = sc.sc_free; 9699e6e0a12SSteven Whitehouse buf->f_files = sc.sc_dinodes + sc.sc_free; 9709e6e0a12SSteven Whitehouse buf->f_ffree = sc.sc_free; 9719e6e0a12SSteven Whitehouse buf->f_namelen = GFS2_FNAMESIZE; 9729e6e0a12SSteven Whitehouse 9739e6e0a12SSteven Whitehouse return 0; 9749e6e0a12SSteven Whitehouse } 9759e6e0a12SSteven Whitehouse 9769e6e0a12SSteven Whitehouse /** 9779e6e0a12SSteven Whitehouse * gfs2_drop_inode - Drop an inode (test for remote unlink) 9789e6e0a12SSteven Whitehouse * @inode: The inode to drop 9799e6e0a12SSteven Whitehouse * 98061b91cfdSAndreas Gruenbacher * If we've received a callback on an iopen lock then it's because a 9819e6e0a12SSteven Whitehouse * remote node tried to deallocate the inode but failed due to this node 9829e6e0a12SSteven Whitehouse * still having the inode open. Here we mark the link count zero 9839e6e0a12SSteven Whitehouse * since we know that it must have reached zero if the GLF_DEMOTE flag 9849e6e0a12SSteven Whitehouse * is set on the iopen glock. If we didn't do a disk read since the 9859e6e0a12SSteven Whitehouse * remote node removed the final link then we might otherwise miss 9869e6e0a12SSteven Whitehouse * this event. This check ensures that this node will deallocate the 9879e6e0a12SSteven Whitehouse * inode's blocks, or alternatively pass the baton on to another 9889e6e0a12SSteven Whitehouse * node for later deallocation. 9899e6e0a12SSteven Whitehouse */ 9909e6e0a12SSteven Whitehouse 99145321ac5SAl Viro static int gfs2_drop_inode(struct inode *inode) 9929e6e0a12SSteven Whitehouse { 9939e6e0a12SSteven Whitehouse struct gfs2_inode *ip = GFS2_I(inode); 9949e6e0a12SSteven Whitehouse 9956df9f9a2SAndreas Gruenbacher if (!test_bit(GIF_FREE_VFS_INODE, &ip->i_flags) && 9966df9f9a2SAndreas Gruenbacher inode->i_nlink && 9976df9f9a2SAndreas Gruenbacher gfs2_holder_initialized(&ip->i_iopen_gh)) { 9989e6e0a12SSteven Whitehouse struct gfs2_glock *gl = ip->i_iopen_gh.gh_gl; 9996df9f9a2SAndreas Gruenbacher if (test_bit(GLF_DEMOTE, &gl->gl_flags)) 10009e6e0a12SSteven Whitehouse clear_nlink(inode); 10019e6e0a12SSteven Whitehouse } 10026a1c8f6dSAndreas Gruenbacher 10036a1c8f6dSAndreas Gruenbacher /* 10046a1c8f6dSAndreas Gruenbacher * When under memory pressure when an inode's link count has dropped to 10056a1c8f6dSAndreas Gruenbacher * zero, defer deleting the inode to the delete workqueue. This avoids 10066a1c8f6dSAndreas Gruenbacher * calling into DLM under memory pressure, which can deadlock. 10076a1c8f6dSAndreas Gruenbacher */ 10086a1c8f6dSAndreas Gruenbacher if (!inode->i_nlink && 10096a1c8f6dSAndreas Gruenbacher unlikely(current->flags & PF_MEMALLOC) && 10106a1c8f6dSAndreas Gruenbacher gfs2_holder_initialized(&ip->i_iopen_gh)) { 10116a1c8f6dSAndreas Gruenbacher struct gfs2_glock *gl = ip->i_iopen_gh.gh_gl; 10126a1c8f6dSAndreas Gruenbacher 10136a1c8f6dSAndreas Gruenbacher gfs2_glock_hold(gl); 1014a0e3cc65SAndreas Gruenbacher if (!gfs2_queue_delete_work(gl, 0)) 10156a1c8f6dSAndreas Gruenbacher gfs2_glock_queue_put(gl); 10166a1c8f6dSAndreas Gruenbacher return false; 10176a1c8f6dSAndreas Gruenbacher } 10186a1c8f6dSAndreas Gruenbacher 101945321ac5SAl Viro return generic_drop_inode(inode); 10209e6e0a12SSteven Whitehouse } 10219e6e0a12SSteven Whitehouse 10229e6e0a12SSteven Whitehouse static int is_ancestor(const struct dentry *d1, const struct dentry *d2) 10239e6e0a12SSteven Whitehouse { 10249e6e0a12SSteven Whitehouse do { 10259e6e0a12SSteven Whitehouse if (d1 == d2) 10269e6e0a12SSteven Whitehouse return 1; 10279e6e0a12SSteven Whitehouse d1 = d1->d_parent; 10289e6e0a12SSteven Whitehouse } while (!IS_ROOT(d1)); 10299e6e0a12SSteven Whitehouse return 0; 10309e6e0a12SSteven Whitehouse } 10319e6e0a12SSteven Whitehouse 10329e6e0a12SSteven Whitehouse /** 10339e6e0a12SSteven Whitehouse * gfs2_show_options - Show mount options for /proc/mounts 10349e6e0a12SSteven Whitehouse * @s: seq_file structure 103534c80b1dSAl Viro * @root: root of this (sub)tree 10369e6e0a12SSteven Whitehouse * 10379e6e0a12SSteven Whitehouse * Returns: 0 on success or error code 10389e6e0a12SSteven Whitehouse */ 10399e6e0a12SSteven Whitehouse 104034c80b1dSAl Viro static int gfs2_show_options(struct seq_file *s, struct dentry *root) 10419e6e0a12SSteven Whitehouse { 104234c80b1dSAl Viro struct gfs2_sbd *sdp = root->d_sb->s_fs_info; 10439e6e0a12SSteven Whitehouse struct gfs2_args *args = &sdp->sd_args; 10443d3c10f2SBenjamin Marzinski int val; 10459e6e0a12SSteven Whitehouse 104634c80b1dSAl Viro if (is_ancestor(root, sdp->sd_master_dir)) 1047eaebdedcSFabian Frederick seq_puts(s, ",meta"); 10489e6e0a12SSteven Whitehouse if (args->ar_lockproto[0]) 1049a068acf2SKees Cook seq_show_option(s, "lockproto", args->ar_lockproto); 10509e6e0a12SSteven Whitehouse if (args->ar_locktable[0]) 1051a068acf2SKees Cook seq_show_option(s, "locktable", args->ar_locktable); 10529e6e0a12SSteven Whitehouse if (args->ar_hostdata[0]) 1053a068acf2SKees Cook seq_show_option(s, "hostdata", args->ar_hostdata); 10549e6e0a12SSteven Whitehouse if (args->ar_spectator) 1055eaebdedcSFabian Frederick seq_puts(s, ",spectator"); 10569e6e0a12SSteven Whitehouse if (args->ar_localflocks) 1057eaebdedcSFabian Frederick seq_puts(s, ",localflocks"); 10589e6e0a12SSteven Whitehouse if (args->ar_debug) 1059eaebdedcSFabian Frederick seq_puts(s, ",debug"); 10609e6e0a12SSteven Whitehouse if (args->ar_posix_acl) 1061eaebdedcSFabian Frederick seq_puts(s, ",acl"); 10629e6e0a12SSteven Whitehouse if (args->ar_quota != GFS2_QUOTA_DEFAULT) { 10639e6e0a12SSteven Whitehouse char *state; 10649e6e0a12SSteven Whitehouse switch (args->ar_quota) { 10659e6e0a12SSteven Whitehouse case GFS2_QUOTA_OFF: 10669e6e0a12SSteven Whitehouse state = "off"; 10679e6e0a12SSteven Whitehouse break; 10689e6e0a12SSteven Whitehouse case GFS2_QUOTA_ACCOUNT: 10699e6e0a12SSteven Whitehouse state = "account"; 10709e6e0a12SSteven Whitehouse break; 10719e6e0a12SSteven Whitehouse case GFS2_QUOTA_ON: 10729e6e0a12SSteven Whitehouse state = "on"; 10739e6e0a12SSteven Whitehouse break; 10749e6e0a12SSteven Whitehouse default: 10759e6e0a12SSteven Whitehouse state = "unknown"; 10769e6e0a12SSteven Whitehouse break; 10779e6e0a12SSteven Whitehouse } 10789e6e0a12SSteven Whitehouse seq_printf(s, ",quota=%s", state); 10799e6e0a12SSteven Whitehouse } 10809e6e0a12SSteven Whitehouse if (args->ar_suiddir) 1081eaebdedcSFabian Frederick seq_puts(s, ",suiddir"); 10829e6e0a12SSteven Whitehouse if (args->ar_data != GFS2_DATA_DEFAULT) { 10839e6e0a12SSteven Whitehouse char *state; 10849e6e0a12SSteven Whitehouse switch (args->ar_data) { 10859e6e0a12SSteven Whitehouse case GFS2_DATA_WRITEBACK: 10869e6e0a12SSteven Whitehouse state = "writeback"; 10879e6e0a12SSteven Whitehouse break; 10889e6e0a12SSteven Whitehouse case GFS2_DATA_ORDERED: 10899e6e0a12SSteven Whitehouse state = "ordered"; 10909e6e0a12SSteven Whitehouse break; 10919e6e0a12SSteven Whitehouse default: 10929e6e0a12SSteven Whitehouse state = "unknown"; 10939e6e0a12SSteven Whitehouse break; 10949e6e0a12SSteven Whitehouse } 10959e6e0a12SSteven Whitehouse seq_printf(s, ",data=%s", state); 10969e6e0a12SSteven Whitehouse } 10979e6e0a12SSteven Whitehouse if (args->ar_discard) 1098eaebdedcSFabian Frederick seq_puts(s, ",discard"); 10995e687eacSBenjamin Marzinski val = sdp->sd_tune.gt_logd_secs; 11005e687eacSBenjamin Marzinski if (val != 30) 11013d3c10f2SBenjamin Marzinski seq_printf(s, ",commit=%d", val); 11023d3c10f2SBenjamin Marzinski val = sdp->sd_tune.gt_statfs_quantum; 11033d3c10f2SBenjamin Marzinski if (val != 30) 11043d3c10f2SBenjamin Marzinski seq_printf(s, ",statfs_quantum=%d", val); 11052b9731e8SSteven Whitehouse else if (sdp->sd_tune.gt_statfs_slow) 11062b9731e8SSteven Whitehouse seq_puts(s, ",statfs_quantum=0"); 11073d3c10f2SBenjamin Marzinski val = sdp->sd_tune.gt_quota_quantum; 11083d3c10f2SBenjamin Marzinski if (val != 60) 11093d3c10f2SBenjamin Marzinski seq_printf(s, ",quota_quantum=%d", val); 11103d3c10f2SBenjamin Marzinski if (args->ar_statfs_percent) 11113d3c10f2SBenjamin Marzinski seq_printf(s, ",statfs_percent=%d", args->ar_statfs_percent); 1112d34843d0SBob Peterson if (args->ar_errors != GFS2_ERRORS_DEFAULT) { 1113d34843d0SBob Peterson const char *state; 1114d34843d0SBob Peterson 1115d34843d0SBob Peterson switch (args->ar_errors) { 1116d34843d0SBob Peterson case GFS2_ERRORS_WITHDRAW: 1117d34843d0SBob Peterson state = "withdraw"; 1118d34843d0SBob Peterson break; 1119d34843d0SBob Peterson case GFS2_ERRORS_PANIC: 1120d34843d0SBob Peterson state = "panic"; 1121d34843d0SBob Peterson break; 1122d34843d0SBob Peterson default: 1123d34843d0SBob Peterson state = "unknown"; 1124d34843d0SBob Peterson break; 1125d34843d0SBob Peterson } 1126d34843d0SBob Peterson seq_printf(s, ",errors=%s", state); 1127d34843d0SBob Peterson } 1128cdcfde62SSteven Whitehouse if (test_bit(SDF_NOBARRIERS, &sdp->sd_flags)) 1129eaebdedcSFabian Frederick seq_puts(s, ",nobarrier"); 1130913a71d2SSteven Whitehouse if (test_bit(SDF_DEMOTE, &sdp->sd_flags)) 1131eaebdedcSFabian Frederick seq_puts(s, ",demote_interface_used"); 113290306c41SBenjamin Marzinski if (args->ar_rgrplvb) 1133eaebdedcSFabian Frederick seq_puts(s, ",rgrplvb"); 1134471f3db2SBenjamin Marzinski if (args->ar_loccookie) 1135471f3db2SBenjamin Marzinski seq_puts(s, ",loccookie"); 11369e6e0a12SSteven Whitehouse return 0; 11379e6e0a12SSteven Whitehouse } 11389e6e0a12SSteven Whitehouse 1139f42ab085SSteven Whitehouse static void gfs2_final_release_pages(struct gfs2_inode *ip) 1140f42ab085SSteven Whitehouse { 1141f42ab085SSteven Whitehouse struct inode *inode = &ip->i_inode; 1142f42ab085SSteven Whitehouse struct gfs2_glock *gl = ip->i_gl; 1143f42ab085SSteven Whitehouse 1144f42ab085SSteven Whitehouse truncate_inode_pages(gfs2_glock2aspace(ip->i_gl), 0); 1145f42ab085SSteven Whitehouse truncate_inode_pages(&inode->i_data, 0); 1146f42ab085SSteven Whitehouse 1147638803d4SBob Peterson if (atomic_read(&gl->gl_revokes) == 0) { 1148f42ab085SSteven Whitehouse clear_bit(GLF_LFLUSH, &gl->gl_flags); 1149f42ab085SSteven Whitehouse clear_bit(GLF_DIRTY, &gl->gl_flags); 1150f42ab085SSteven Whitehouse } 1151f42ab085SSteven Whitehouse } 1152f42ab085SSteven Whitehouse 1153f42ab085SSteven Whitehouse static int gfs2_dinode_dealloc(struct gfs2_inode *ip) 1154f42ab085SSteven Whitehouse { 1155f42ab085SSteven Whitehouse struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode); 1156f42ab085SSteven Whitehouse struct gfs2_rgrpd *rgd; 1157564e12b1SBob Peterson struct gfs2_holder gh; 1158f42ab085SSteven Whitehouse int error; 1159f42ab085SSteven Whitehouse 1160f42ab085SSteven Whitehouse if (gfs2_get_inode_blocks(&ip->i_inode) != 1) { 116194fb763bSSteven Whitehouse gfs2_consist_inode(ip); 1162f42ab085SSteven Whitehouse return -EIO; 1163f42ab085SSteven Whitehouse } 1164f42ab085SSteven Whitehouse 11658e2e0047SBob Peterson error = gfs2_rindex_update(sdp); 11668e2e0047SBob Peterson if (error) 11678e2e0047SBob Peterson return error; 1168f42ab085SSteven Whitehouse 1169f4108a60SEric W. Biederman error = gfs2_quota_hold(ip, NO_UID_QUOTA_CHANGE, NO_GID_QUOTA_CHANGE); 1170f42ab085SSteven Whitehouse if (error) 11715407e242SBob Peterson return error; 1172f42ab085SSteven Whitehouse 117366fc061bSSteven Whitehouse rgd = gfs2_blk2rgrpd(sdp, ip->i_no_addr, 1); 1174f42ab085SSteven Whitehouse if (!rgd) { 1175f42ab085SSteven Whitehouse gfs2_consist_inode(ip); 1176f42ab085SSteven Whitehouse error = -EIO; 11778339ee54SSteven Whitehouse goto out_qs; 1178f42ab085SSteven Whitehouse } 1179f42ab085SSteven Whitehouse 11804fc7ec31SBob Peterson error = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_EXCLUSIVE, 11814fc7ec31SBob Peterson LM_FLAG_NODE_SCOPE, &gh); 1182f42ab085SSteven Whitehouse if (error) 11838339ee54SSteven Whitehouse goto out_qs; 1184f42ab085SSteven Whitehouse 11854667a0ecSSteven Whitehouse error = gfs2_trans_begin(sdp, RES_RG_BIT + RES_STATFS + RES_QUOTA, 11864667a0ecSSteven Whitehouse sdp->sd_jdesc->jd_blocks); 1187f42ab085SSteven Whitehouse if (error) 1188f42ab085SSteven Whitehouse goto out_rg_gunlock; 1189f42ab085SSteven Whitehouse 1190f42ab085SSteven Whitehouse gfs2_free_di(rgd, ip); 1191f42ab085SSteven Whitehouse 1192f42ab085SSteven Whitehouse gfs2_final_release_pages(ip); 1193f42ab085SSteven Whitehouse 1194f42ab085SSteven Whitehouse gfs2_trans_end(sdp); 1195f42ab085SSteven Whitehouse 1196f42ab085SSteven Whitehouse out_rg_gunlock: 1197564e12b1SBob Peterson gfs2_glock_dq_uninit(&gh); 1198f42ab085SSteven Whitehouse out_qs: 1199f42ab085SSteven Whitehouse gfs2_quota_unhold(ip); 1200f42ab085SSteven Whitehouse return error; 1201f42ab085SSteven Whitehouse } 1202f42ab085SSteven Whitehouse 1203380f7c65SSteven Whitehouse /** 120471c1b213SAndreas Gruenbacher * gfs2_glock_put_eventually 120571c1b213SAndreas Gruenbacher * @gl: The glock to put 120671c1b213SAndreas Gruenbacher * 120771c1b213SAndreas Gruenbacher * When under memory pressure, trigger a deferred glock put to make sure we 120871c1b213SAndreas Gruenbacher * won't call into DLM and deadlock. Otherwise, put the glock directly. 120971c1b213SAndreas Gruenbacher */ 121071c1b213SAndreas Gruenbacher 121171c1b213SAndreas Gruenbacher static void gfs2_glock_put_eventually(struct gfs2_glock *gl) 121271c1b213SAndreas Gruenbacher { 121371c1b213SAndreas Gruenbacher if (current->flags & PF_MEMALLOC) 121471c1b213SAndreas Gruenbacher gfs2_glock_queue_put(gl); 121571c1b213SAndreas Gruenbacher else 121671c1b213SAndreas Gruenbacher gfs2_glock_put(gl); 121771c1b213SAndreas Gruenbacher } 121871c1b213SAndreas Gruenbacher 12199e73330fSAndreas Gruenbacher static bool gfs2_upgrade_iopen_glock(struct inode *inode) 12209e73330fSAndreas Gruenbacher { 12219e73330fSAndreas Gruenbacher struct gfs2_inode *ip = GFS2_I(inode); 12229e73330fSAndreas Gruenbacher struct gfs2_sbd *sdp = GFS2_SB(inode); 12239e73330fSAndreas Gruenbacher struct gfs2_holder *gh = &ip->i_iopen_gh; 12249e73330fSAndreas Gruenbacher long timeout = 5 * HZ; 12259e73330fSAndreas Gruenbacher int error; 12269e73330fSAndreas Gruenbacher 12279e73330fSAndreas Gruenbacher gh->gh_flags |= GL_NOCACHE; 12289e73330fSAndreas Gruenbacher gfs2_glock_dq_wait(gh); 12299e73330fSAndreas Gruenbacher 12309e73330fSAndreas Gruenbacher /* 12319e73330fSAndreas Gruenbacher * If there are no other lock holders, we'll get the lock immediately. 12329e73330fSAndreas Gruenbacher * Otherwise, the other nodes holding the lock will be notified about 12339e73330fSAndreas Gruenbacher * our locking request. If they don't have the inode open, they'll 12349e8990deSAndreas Gruenbacher * evict the cached inode and release the lock. Otherwise, if they 12359e8990deSAndreas Gruenbacher * poke the inode glock, we'll take this as an indication that they 12369e8990deSAndreas Gruenbacher * still need the iopen glock and that they'll take care of deleting 12379e8990deSAndreas Gruenbacher * the inode when they're done. As a last resort, if another node 12389e8990deSAndreas Gruenbacher * keeps holding the iopen glock without showing any activity on the 12399e8990deSAndreas Gruenbacher * inode glock, we'll eventually time out. 12409e73330fSAndreas Gruenbacher * 12419e73330fSAndreas Gruenbacher * Note that we're passing the LM_FLAG_TRY_1CB flag to the first 12429e73330fSAndreas Gruenbacher * locking request as an optimization to notify lock holders as soon as 12439e73330fSAndreas Gruenbacher * possible. Without that flag, they'd be notified implicitly by the 12449e73330fSAndreas Gruenbacher * second locking request. 12459e73330fSAndreas Gruenbacher */ 12469e73330fSAndreas Gruenbacher 12479e73330fSAndreas Gruenbacher gfs2_holder_reinit(LM_ST_EXCLUSIVE, LM_FLAG_TRY_1CB | GL_NOCACHE, gh); 12489e73330fSAndreas Gruenbacher error = gfs2_glock_nq(gh); 12499e73330fSAndreas Gruenbacher if (error != GLR_TRYFAILED) 12509e73330fSAndreas Gruenbacher return !error; 12519e73330fSAndreas Gruenbacher 12529e73330fSAndreas Gruenbacher gfs2_holder_reinit(LM_ST_EXCLUSIVE, GL_ASYNC | GL_NOCACHE, gh); 12539e73330fSAndreas Gruenbacher error = gfs2_glock_nq(gh); 12549e73330fSAndreas Gruenbacher if (error) 12559e73330fSAndreas Gruenbacher return false; 12569e73330fSAndreas Gruenbacher 12579e73330fSAndreas Gruenbacher timeout = wait_event_interruptible_timeout(sdp->sd_async_glock_wait, 12589e8990deSAndreas Gruenbacher !test_bit(HIF_WAIT, &gh->gh_iflags) || 12599e8990deSAndreas Gruenbacher test_bit(GLF_DEMOTE, &ip->i_gl->gl_flags), 12609e73330fSAndreas Gruenbacher timeout); 12619e73330fSAndreas Gruenbacher if (!test_bit(HIF_HOLDER, &gh->gh_iflags)) { 12629e73330fSAndreas Gruenbacher gfs2_glock_dq(gh); 12639e73330fSAndreas Gruenbacher return false; 12649e73330fSAndreas Gruenbacher } 12659e73330fSAndreas Gruenbacher return true; 12669e73330fSAndreas Gruenbacher } 12679e73330fSAndreas Gruenbacher 126871c1b213SAndreas Gruenbacher /** 126953dbc27eSBob Peterson * evict_should_delete - determine whether the inode is eligible for deletion 127053dbc27eSBob Peterson * @inode: The inode to evict 127153dbc27eSBob Peterson * 127253dbc27eSBob Peterson * This function determines whether the evicted inode is eligible to be deleted 127353dbc27eSBob Peterson * and locks the inode glock. 127453dbc27eSBob Peterson * 127553dbc27eSBob Peterson * Returns: the fate of the dinode 127653dbc27eSBob Peterson */ 127753dbc27eSBob Peterson static enum dinode_demise evict_should_delete(struct inode *inode, 127853dbc27eSBob Peterson struct gfs2_holder *gh) 127953dbc27eSBob Peterson { 128053dbc27eSBob Peterson struct gfs2_inode *ip = GFS2_I(inode); 128153dbc27eSBob Peterson struct super_block *sb = inode->i_sb; 128253dbc27eSBob Peterson struct gfs2_sbd *sdp = sb->s_fs_info; 128353dbc27eSBob Peterson int ret; 128453dbc27eSBob Peterson 128553dbc27eSBob Peterson if (test_bit(GIF_ALLOC_FAILED, &ip->i_flags)) { 128653dbc27eSBob Peterson BUG_ON(!gfs2_glock_is_locked_by_me(ip->i_gl)); 128753dbc27eSBob Peterson goto should_delete; 128853dbc27eSBob Peterson } 128953dbc27eSBob Peterson 129053dbc27eSBob Peterson if (test_bit(GIF_DEFERRED_DELETE, &ip->i_flags)) 129153dbc27eSBob Peterson return SHOULD_DEFER_EVICTION; 129253dbc27eSBob Peterson 129353dbc27eSBob Peterson /* Deletes should never happen under memory pressure anymore. */ 129453dbc27eSBob Peterson if (WARN_ON_ONCE(current->flags & PF_MEMALLOC)) 129553dbc27eSBob Peterson return SHOULD_DEFER_EVICTION; 129653dbc27eSBob Peterson 129753dbc27eSBob Peterson /* Must not read inode block until block type has been verified */ 129853dbc27eSBob Peterson ret = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, GL_SKIP, gh); 129953dbc27eSBob Peterson if (unlikely(ret)) { 130053dbc27eSBob Peterson glock_clear_object(ip->i_iopen_gh.gh_gl, ip); 130153dbc27eSBob Peterson ip->i_iopen_gh.gh_flags |= GL_NOCACHE; 130253dbc27eSBob Peterson gfs2_glock_dq_uninit(&ip->i_iopen_gh); 130353dbc27eSBob Peterson return SHOULD_DEFER_EVICTION; 130453dbc27eSBob Peterson } 130553dbc27eSBob Peterson 130653dbc27eSBob Peterson if (gfs2_inode_already_deleted(ip->i_gl, ip->i_no_formal_ino)) 130753dbc27eSBob Peterson return SHOULD_NOT_DELETE_DINODE; 130853dbc27eSBob Peterson ret = gfs2_check_blk_type(sdp, ip->i_no_addr, GFS2_BLKST_UNLINKED); 130953dbc27eSBob Peterson if (ret) 131053dbc27eSBob Peterson return SHOULD_NOT_DELETE_DINODE; 131153dbc27eSBob Peterson 131253dbc27eSBob Peterson if (test_bit(GIF_INVALID, &ip->i_flags)) { 131353dbc27eSBob Peterson ret = gfs2_inode_refresh(ip); 131453dbc27eSBob Peterson if (ret) 131553dbc27eSBob Peterson return SHOULD_NOT_DELETE_DINODE; 131653dbc27eSBob Peterson } 131753dbc27eSBob Peterson 131853dbc27eSBob Peterson /* 131953dbc27eSBob Peterson * The inode may have been recreated in the meantime. 132053dbc27eSBob Peterson */ 132153dbc27eSBob Peterson if (inode->i_nlink) 132253dbc27eSBob Peterson return SHOULD_NOT_DELETE_DINODE; 132353dbc27eSBob Peterson 132453dbc27eSBob Peterson should_delete: 132553dbc27eSBob Peterson if (gfs2_holder_initialized(&ip->i_iopen_gh) && 132653dbc27eSBob Peterson test_bit(HIF_HOLDER, &ip->i_iopen_gh.gh_iflags)) { 132753dbc27eSBob Peterson if (!gfs2_upgrade_iopen_glock(inode)) { 132853dbc27eSBob Peterson gfs2_holder_uninit(&ip->i_iopen_gh); 132953dbc27eSBob Peterson return SHOULD_NOT_DELETE_DINODE; 133053dbc27eSBob Peterson } 133153dbc27eSBob Peterson } 133253dbc27eSBob Peterson return SHOULD_DELETE_DINODE; 133353dbc27eSBob Peterson } 133453dbc27eSBob Peterson 133553dbc27eSBob Peterson /** 13366e7e9a50SBob Peterson * evict_unlinked_inode - delete the pieces of an unlinked evicted inode 13376e7e9a50SBob Peterson * @inode: The inode to evict 13386e7e9a50SBob Peterson */ 13396e7e9a50SBob Peterson static int evict_unlinked_inode(struct inode *inode) 13406e7e9a50SBob Peterson { 13416e7e9a50SBob Peterson struct gfs2_inode *ip = GFS2_I(inode); 13426e7e9a50SBob Peterson int ret; 13436e7e9a50SBob Peterson 13446e7e9a50SBob Peterson if (S_ISDIR(inode->i_mode) && 13456e7e9a50SBob Peterson (ip->i_diskflags & GFS2_DIF_EXHASH)) { 13466e7e9a50SBob Peterson ret = gfs2_dir_exhash_dealloc(ip); 13476e7e9a50SBob Peterson if (ret) 13486e7e9a50SBob Peterson goto out; 13496e7e9a50SBob Peterson } 13506e7e9a50SBob Peterson 13516e7e9a50SBob Peterson if (ip->i_eattr) { 13526e7e9a50SBob Peterson ret = gfs2_ea_dealloc(ip); 13536e7e9a50SBob Peterson if (ret) 13546e7e9a50SBob Peterson goto out; 13556e7e9a50SBob Peterson } 13566e7e9a50SBob Peterson 13576e7e9a50SBob Peterson if (!gfs2_is_stuffed(ip)) { 13586e7e9a50SBob Peterson ret = gfs2_file_dealloc(ip); 13596e7e9a50SBob Peterson if (ret) 13606e7e9a50SBob Peterson goto out; 13616e7e9a50SBob Peterson } 13626e7e9a50SBob Peterson 13636e7e9a50SBob Peterson /* We're about to clear the bitmap for the dinode, but as soon as we 13646e7e9a50SBob Peterson do, gfs2_create_inode can create another inode at the same block 13656e7e9a50SBob Peterson location and try to set gl_object again. We clear gl_object here so 13666e7e9a50SBob Peterson that subsequent inode creates don't see an old gl_object. */ 13676e7e9a50SBob Peterson glock_clear_object(ip->i_gl, ip); 13686e7e9a50SBob Peterson ret = gfs2_dinode_dealloc(ip); 13696e7e9a50SBob Peterson gfs2_inode_remember_delete(ip->i_gl, ip->i_no_formal_ino); 13706e7e9a50SBob Peterson out: 13716e7e9a50SBob Peterson return ret; 13726e7e9a50SBob Peterson } 13736e7e9a50SBob Peterson 1374d90be6abSBob Peterson /* 1375d90be6abSBob Peterson * evict_linked_inode - evict an inode whose dinode has not been unlinked 1376d90be6abSBob Peterson * @inode: The inode to evict 1377d90be6abSBob Peterson */ 1378d90be6abSBob Peterson static int evict_linked_inode(struct inode *inode) 1379d90be6abSBob Peterson { 1380d90be6abSBob Peterson struct super_block *sb = inode->i_sb; 1381d90be6abSBob Peterson struct gfs2_sbd *sdp = sb->s_fs_info; 1382d90be6abSBob Peterson struct gfs2_inode *ip = GFS2_I(inode); 1383d90be6abSBob Peterson struct address_space *metamapping; 1384d90be6abSBob Peterson int ret; 1385d90be6abSBob Peterson 1386d90be6abSBob Peterson gfs2_log_flush(sdp, ip->i_gl, GFS2_LOG_HEAD_FLUSH_NORMAL | 1387d90be6abSBob Peterson GFS2_LFC_EVICT_INODE); 1388d90be6abSBob Peterson metamapping = gfs2_glock2aspace(ip->i_gl); 1389d90be6abSBob Peterson if (test_bit(GLF_DIRTY, &ip->i_gl->gl_flags)) { 1390d90be6abSBob Peterson filemap_fdatawrite(metamapping); 1391d90be6abSBob Peterson filemap_fdatawait(metamapping); 1392d90be6abSBob Peterson } 1393d90be6abSBob Peterson write_inode_now(inode, 1); 1394d90be6abSBob Peterson gfs2_ail_flush(ip->i_gl, 0); 1395d90be6abSBob Peterson 1396d90be6abSBob Peterson ret = gfs2_trans_begin(sdp, 0, sdp->sd_jdesc->jd_blocks); 1397d90be6abSBob Peterson if (ret) 1398d90be6abSBob Peterson return ret; 1399d90be6abSBob Peterson 1400d90be6abSBob Peterson /* Needs to be done before glock release & also in a transaction */ 1401d90be6abSBob Peterson truncate_inode_pages(&inode->i_data, 0); 1402d90be6abSBob Peterson truncate_inode_pages(metamapping, 0); 1403d90be6abSBob Peterson gfs2_trans_end(sdp); 1404d90be6abSBob Peterson return 0; 1405d90be6abSBob Peterson } 1406d90be6abSBob Peterson 14076e7e9a50SBob Peterson /** 1408380f7c65SSteven Whitehouse * gfs2_evict_inode - Remove an inode from cache 1409380f7c65SSteven Whitehouse * @inode: The inode to evict 1410380f7c65SSteven Whitehouse * 1411380f7c65SSteven Whitehouse * There are three cases to consider: 1412380f7c65SSteven Whitehouse * 1. i_nlink == 0, we are final opener (and must deallocate) 1413380f7c65SSteven Whitehouse * 2. i_nlink == 0, we are not the final opener (and cannot deallocate) 1414380f7c65SSteven Whitehouse * 3. i_nlink > 0 1415380f7c65SSteven Whitehouse * 1416380f7c65SSteven Whitehouse * If the fs is read only, then we have to treat all cases as per #3 1417380f7c65SSteven Whitehouse * since we are unable to do any deallocation. The inode will be 1418380f7c65SSteven Whitehouse * deallocated by the next read/write node to attempt an allocation 1419380f7c65SSteven Whitehouse * in the same resource group 1420380f7c65SSteven Whitehouse * 14219e6e0a12SSteven Whitehouse * We have to (at the moment) hold the inodes main lock to cover 14229e6e0a12SSteven Whitehouse * the gap between unlocking the shared lock on the iopen lock and 14239e6e0a12SSteven Whitehouse * taking the exclusive lock. I'd rather do a shared -> exclusive 14249e6e0a12SSteven Whitehouse * conversion on the iopen lock, but we can change that later. This 14259e6e0a12SSteven Whitehouse * is safe, just less efficient. 14269e6e0a12SSteven Whitehouse */ 14279e6e0a12SSteven Whitehouse 1428d5c1515cSAl Viro static void gfs2_evict_inode(struct inode *inode) 14299e6e0a12SSteven Whitehouse { 1430001e8e8dSSteven Whitehouse struct super_block *sb = inode->i_sb; 1431001e8e8dSSteven Whitehouse struct gfs2_sbd *sdp = sb->s_fs_info; 14329e6e0a12SSteven Whitehouse struct gfs2_inode *ip = GFS2_I(inode); 14339e6e0a12SSteven Whitehouse struct gfs2_holder gh; 143423d828fcSBob Peterson int ret; 14359e6e0a12SSteven Whitehouse 143605978803SAbhi Das if (test_bit(GIF_FREE_VFS_INODE, &ip->i_flags)) { 143705978803SAbhi Das clear_inode(inode); 143805978803SAbhi Das return; 143905978803SAbhi Das } 144005978803SAbhi Das 1441bc98a42cSDavid Howells if (inode->i_nlink || sb_rdonly(sb)) 1442d5c1515cSAl Viro goto out; 1443d5c1515cSAl Viro 1444e0b62e21SAndreas Gruenbacher gfs2_holder_mark_uninitialized(&gh); 144553dbc27eSBob Peterson ret = evict_should_delete(inode, &gh); 144653dbc27eSBob Peterson if (ret == SHOULD_DEFER_EVICTION) 14478c7b9262SAndreas Gruenbacher goto out; 14480a0d9f55SBob Peterson if (ret == SHOULD_DELETE_DINODE) 14496e7e9a50SBob Peterson ret = evict_unlinked_inode(inode); 14500a0d9f55SBob Peterson else 1451d90be6abSBob Peterson ret = evict_linked_inode(inode); 14529e6e0a12SSteven Whitehouse 1453a097dc7eSBob Peterson if (gfs2_rs_active(&ip->i_res)) 1454a097dc7eSBob Peterson gfs2_rs_deltree(&ip->i_res); 14558e2e0047SBob Peterson 1456240c6235SBob Peterson if (gfs2_holder_initialized(&gh)) { 1457240c6235SBob Peterson glock_clear_object(ip->i_gl, ip); 14589e6e0a12SSteven Whitehouse gfs2_glock_dq_uninit(&gh); 1459240c6235SBob Peterson } 146023d828fcSBob Peterson if (ret && ret != GLR_TRYFAILED && ret != -EROFS) 146123d828fcSBob Peterson fs_warn(sdp, "gfs2_evict_inode: %d\n", ret); 14629e6e0a12SSteven Whitehouse out: 146391b0abe3SJohannes Weiner truncate_inode_pages_final(&inode->i_data); 14642fba46a0SBob Peterson if (ip->i_qadata) 14652fba46a0SBob Peterson gfs2_assert_warn(sdp, ip->i_qadata->qa_ref == 0); 14661595548fSAndreas Gruenbacher gfs2_rs_delete(ip, NULL); 146745138990SSteven Whitehouse gfs2_ordered_del_inode(ip); 1468dbd5768fSJan Kara clear_inode(inode); 146917d539f0SSteven Whitehouse gfs2_dir_hash_inval(ip); 147040e7e86eSAndreas Gruenbacher if (ip->i_gl) { 1471df3d87bdSBob Peterson glock_clear_object(ip->i_gl, ip); 14724fd1a579SAndreas Gruenbacher wait_on_bit_io(&ip->i_flags, GIF_GLOP_PENDING, TASK_UNINTERRUPTIBLE); 147329687a2aSSteven Whitehouse gfs2_glock_add_to_lru(ip->i_gl); 147471c1b213SAndreas Gruenbacher gfs2_glock_put_eventually(ip->i_gl); 1475d5c1515cSAl Viro ip->i_gl = NULL; 147640e7e86eSAndreas Gruenbacher } 14776df9f9a2SAndreas Gruenbacher if (gfs2_holder_initialized(&ip->i_iopen_gh)) { 147871c1b213SAndreas Gruenbacher struct gfs2_glock *gl = ip->i_iopen_gh.gh_gl; 147971c1b213SAndreas Gruenbacher 148071c1b213SAndreas Gruenbacher glock_clear_object(gl, ip); 148140e7e86eSAndreas Gruenbacher if (test_bit(HIF_HOLDER, &ip->i_iopen_gh.gh_iflags)) { 1482a6a4d98bSBob Peterson ip->i_iopen_gh.gh_flags |= GL_NOCACHE; 148340e7e86eSAndreas Gruenbacher gfs2_glock_dq(&ip->i_iopen_gh); 148440e7e86eSAndreas Gruenbacher } 148571c1b213SAndreas Gruenbacher gfs2_glock_hold(gl); 148640e7e86eSAndreas Gruenbacher gfs2_holder_uninit(&ip->i_iopen_gh); 148771c1b213SAndreas Gruenbacher gfs2_glock_put_eventually(gl); 1488d5c1515cSAl Viro } 14899e6e0a12SSteven Whitehouse } 14909e6e0a12SSteven Whitehouse 14919e6e0a12SSteven Whitehouse static struct inode *gfs2_alloc_inode(struct super_block *sb) 14929e6e0a12SSteven Whitehouse { 14939e6e0a12SSteven Whitehouse struct gfs2_inode *ip; 14949e6e0a12SSteven Whitehouse 14959e6e0a12SSteven Whitehouse ip = kmem_cache_alloc(gfs2_inode_cachep, GFP_KERNEL); 1496d4031259SAndreas Gruenbacher if (!ip) 1497d4031259SAndreas Gruenbacher return NULL; 14989e6e0a12SSteven Whitehouse ip->i_flags = 0; 14999e6e0a12SSteven Whitehouse ip->i_gl = NULL; 150040e7e86eSAndreas Gruenbacher gfs2_holder_mark_uninitialized(&ip->i_iopen_gh); 1501a097dc7eSBob Peterson memset(&ip->i_res, 0, sizeof(ip->i_res)); 1502a097dc7eSBob Peterson RB_CLEAR_NODE(&ip->i_res.rs_node); 1503c8d57703SAndreas Gruenbacher ip->i_rahead = 0; 15049e6e0a12SSteven Whitehouse return &ip->i_inode; 15059e6e0a12SSteven Whitehouse } 15069e6e0a12SSteven Whitehouse 1507784494e1SAl Viro static void gfs2_free_inode(struct inode *inode) 1508fa0d7e3dSNick Piggin { 1509784494e1SAl Viro kmem_cache_free(gfs2_inode_cachep, GFS2_I(inode)); 15109e6e0a12SSteven Whitehouse } 15119e6e0a12SSteven Whitehouse 151297fd734bSAbhi Das extern void free_local_statfs_inodes(struct gfs2_sbd *sdp) 151397fd734bSAbhi Das { 151497fd734bSAbhi Das struct local_statfs_inode *lsi, *safe; 151597fd734bSAbhi Das 151697fd734bSAbhi Das /* Run through the statfs inodes list to iput and free memory */ 151797fd734bSAbhi Das list_for_each_entry_safe(lsi, safe, &sdp->sd_sc_inodes_list, si_list) { 151897fd734bSAbhi Das if (lsi->si_jid == sdp->sd_jdesc->jd_jid) 151997fd734bSAbhi Das sdp->sd_sc_inode = NULL; /* belongs to this node */ 152097fd734bSAbhi Das if (lsi->si_sc_inode) 152197fd734bSAbhi Das iput(lsi->si_sc_inode); 152297fd734bSAbhi Das list_del(&lsi->si_list); 152397fd734bSAbhi Das kfree(lsi); 152497fd734bSAbhi Das } 152597fd734bSAbhi Das } 152697fd734bSAbhi Das 152797fd734bSAbhi Das extern struct inode *find_local_statfs_inode(struct gfs2_sbd *sdp, 152897fd734bSAbhi Das unsigned int index) 152997fd734bSAbhi Das { 153097fd734bSAbhi Das struct local_statfs_inode *lsi; 153197fd734bSAbhi Das 153297fd734bSAbhi Das /* Return the local (per node) statfs inode in the 153397fd734bSAbhi Das * sdp->sd_sc_inodes_list corresponding to the 'index'. */ 153497fd734bSAbhi Das list_for_each_entry(lsi, &sdp->sd_sc_inodes_list, si_list) { 153597fd734bSAbhi Das if (lsi->si_jid == index) 153697fd734bSAbhi Das return lsi->si_sc_inode; 153797fd734bSAbhi Das } 153897fd734bSAbhi Das return NULL; 153997fd734bSAbhi Das } 154097fd734bSAbhi Das 15419e6e0a12SSteven Whitehouse const struct super_operations gfs2_super_ops = { 15429e6e0a12SSteven Whitehouse .alloc_inode = gfs2_alloc_inode, 1543784494e1SAl Viro .free_inode = gfs2_free_inode, 15449e6e0a12SSteven Whitehouse .write_inode = gfs2_write_inode, 1545ab9bbda0SSteven Whitehouse .dirty_inode = gfs2_dirty_inode, 1546d5c1515cSAl Viro .evict_inode = gfs2_evict_inode, 15479e6e0a12SSteven Whitehouse .put_super = gfs2_put_super, 15489e6e0a12SSteven Whitehouse .sync_fs = gfs2_sync_fs, 15492e60d768SBenjamin Marzinski .freeze_super = gfs2_freeze, 15502e60d768SBenjamin Marzinski .thaw_super = gfs2_unfreeze, 15519e6e0a12SSteven Whitehouse .statfs = gfs2_statfs, 15529e6e0a12SSteven Whitehouse .drop_inode = gfs2_drop_inode, 15539e6e0a12SSteven Whitehouse .show_options = gfs2_show_options, 15549e6e0a12SSteven Whitehouse }; 15559e6e0a12SSteven Whitehouse 1556