man(1): change default pager to "less -s"

[asomers]

Summary

man(1): change default pager to "less -s"

Finally, a pager from the nineties.

[asomers]

Someone pointed out on the mailing list that if I modify man(1), I should also modify every other command with a builtin pager. I'll do that.

[asomers]

Additionally change the defaults for mandoc, apropos, ftp, mail, msgs,
mergemaster, and freebsd-update. And change the default PAGER variable in
/usr/share/skel, /root, and tools/tools/nanobsd.

head/UPDATING

nvme_ctrlr_disable(struct nvme_controller *ctrlr)
         }
         if (rdy == 0) {
                 /* EN == 1, wait for  RDY == 1 or timeout & fail */
                 err = nvme_ctrlr_wait_for_ready(ctrlr, 1);
                 if (err != 0)
                         return (err);
         }
 
-        cc &= ~NVME_CC_REG_EN_MASK;
+        cc &= ~NVMEM(NVME_CC_REG_EN);
         nvme_mmio_write_4(ctrlr, cc, cc);
 
         /*
          * A few drives have firmware bugs that freeze the drive if we access
          * the mmio too soon after we disable.
          */
         if (ctrlr->quirks & QUIRK_DELAY_B4_CHK_RDY)
                 pause("nvmeR", MSEC_2_TICKS(B4_CHK_RDY_DELAY_MS));
nvme_pt_done(void *arg, const struct nvme_completion *cpl)
         struct nvme_pt_command *pt = arg;
         struct mtx *mtx = pt->driver_lock;
         uint16_t status;
 
         bzero(&pt->cpl, sizeof(pt->cpl));
         pt->cpl.cdw0 = cpl->cdw0;
 
         status = cpl->status;
-        status &= ~NVME_STATUS_P_MASK;
+        status &= ~NVMEM(NVME_STATUS_P);
         pt->cpl.status = status;
 
         mtx_lock(mtx);
         pt->driver_lock = NULL;
         wakeup(pt);
         mtx_unlock(mtx);
 }
 

 void
 nvme_ctrlr_shutdown(struct nvme_controller *ctrlr)
 {
         uint32_t        cc;
         uint32_t        csts;
         int             timeout;
 
         cc = nvme_mmio_read_4(ctrlr, cc);
-        cc &= ~(NVME_CC_REG_SHN_MASK << NVME_CC_REG_SHN_SHIFT);
+        cc &= ~NVMEM(NVME_CC_REG_SHN);
         cc |= NVME_SHN_NORMAL << NVME_CC_REG_SHN_SHIFT;
         nvme_mmio_write_4(ctrlr, cc, cc);
 
         timeout = ticks + (ctrlr->cdata.rtd3e == 0 ? 5 * hz :
             ((uint64_t)ctrlr->cdata.rtd3e * hz + 999999) / 1000000);
         while (1) {
                 csts = nvme_mmio_read_4(ctrlr, csts);
                 if (csts == NVME_GONE)                /* Hot unplug. */

head/contrib/mdocml/apropos.1

nvme_ctrlr_disable(struct nvme_controller *ctrlr)
         }
         if (rdy == 0) {
                 /* EN == 1, wait for  RDY == 1 or timeout & fail */
                 err = nvme_ctrlr_wait_for_ready(ctrlr, 1);
                 if (err != 0)
                         return (err);
         }
 
-        cc &= ~NVME_CC_REG_EN_MASK;
+        cc &= ~NVMEM(NVME_CC_REG_EN);
         nvme_mmio_write_4(ctrlr, cc, cc);
 
         /*
          * A few drives have firmware bugs that freeze the drive if we access
          * the mmio too soon after we disable.
          */
         if (ctrlr->quirks & QUIRK_DELAY_B4_CHK_RDY)
                 pause("nvmeR", MSEC_2_TICKS(B4_CHK_RDY_DELAY_MS));
nvme_pt_done(void *arg, const struct nvme_completion *cpl)
         struct nvme_pt_command *pt = arg;
         struct mtx *mtx = pt->driver_lock;
         uint16_t status;
 
         bzero(&pt->cpl, sizeof(pt->cpl));
         pt->cpl.cdw0 = cpl->cdw0;
 
         status = cpl->status;
-        status &= ~NVME_STATUS_P_MASK;
+        status &= ~NVMEM(NVME_STATUS_P);
         pt->cpl.status = status;
 
         mtx_lock(mtx);
         pt->driver_lock = NULL;
         wakeup(pt);
         mtx_unlock(mtx);
 }
 

 void
 nvme_ctrlr_shutdown(struct nvme_controller *ctrlr)
 {
         uint32_t        cc;
         uint32_t        csts;
         int             timeout;
 
         cc = nvme_mmio_read_4(ctrlr, cc);
-        cc &= ~(NVME_CC_REG_SHN_MASK << NVME_CC_REG_SHN_SHIFT);
+        cc &= ~NVMEM(NVME_CC_REG_SHN);
         cc |= NVME_SHN_NORMAL << NVME_CC_REG_SHN_SHIFT;
         nvme_mmio_write_4(ctrlr, cc, cc);
 
         timeout = ticks + (ctrlr->cdata.rtd3e == 0 ? 5 * hz :
             ((uint64_t)ctrlr->cdata.rtd3e * hz + 999999) / 1000000);
         while (1) {
                 csts = nvme_mmio_read_4(ctrlr, csts);
                 if (csts == NVME_GONE)                /* Hot unplug. */

head/contrib/mdocml/main.c

nvme_ctrlr_disable(struct nvme_controller *ctrlr)
         }
         if (rdy == 0) {
                 /* EN == 1, wait for  RDY == 1 or timeout & fail */
                 err = nvme_ctrlr_wait_for_ready(ctrlr, 1);
                 if (err != 0)
                         return (err);
         }
 
-        cc &= ~NVME_CC_REG_EN_MASK;
+        cc &= ~NVMEM(NVME_CC_REG_EN);
         nvme_mmio_write_4(ctrlr, cc, cc);
 
         /*
          * A few drives have firmware bugs that freeze the drive if we access
          * the mmio too soon after we disable.
          */
         if (ctrlr->quirks & QUIRK_DELAY_B4_CHK_RDY)
                 pause("nvmeR", MSEC_2_TICKS(B4_CHK_RDY_DELAY_MS));
nvme_pt_done(void *arg, const struct nvme_completion *cpl)
         struct nvme_pt_command *pt = arg;
         struct mtx *mtx = pt->driver_lock;
         uint16_t status;
 
         bzero(&pt->cpl, sizeof(pt->cpl));
         pt->cpl.cdw0 = cpl->cdw0;
 
         status = cpl->status;
-        status &= ~NVME_STATUS_P_MASK;
+        status &= ~NVMEM(NVME_STATUS_P);
         pt->cpl.status = status;
 
         mtx_lock(mtx);
         pt->driver_lock = NULL;
         wakeup(pt);
         mtx_unlock(mtx);
 }
 

 void
 nvme_ctrlr_shutdown(struct nvme_controller *ctrlr)
 {
         uint32_t        cc;
         uint32_t        csts;
         int             timeout;
 
         cc = nvme_mmio_read_4(ctrlr, cc);
-        cc &= ~(NVME_CC_REG_SHN_MASK << NVME_CC_REG_SHN_SHIFT);
+        cc &= ~NVMEM(NVME_CC_REG_SHN);
         cc |= NVME_SHN_NORMAL << NVME_CC_REG_SHN_SHIFT;
         nvme_mmio_write_4(ctrlr, cc, cc);
 
         timeout = ticks + (ctrlr->cdata.rtd3e == 0 ? 5 * hz :
             ((uint64_t)ctrlr->cdata.rtd3e * hz + 999999) / 1000000);
         while (1) {
                 csts = nvme_mmio_read_4(ctrlr, csts);
                 if (csts == NVME_GONE)                /* Hot unplug. */

head/contrib/mdocml/man.1

nvme_ctrlr_disable(struct nvme_controller *ctrlr)
         }
         if (rdy == 0) {
                 /* EN == 1, wait for  RDY == 1 or timeout & fail */
                 err = nvme_ctrlr_wait_for_ready(ctrlr, 1);
                 if (err != 0)
                         return (err);
         }
 
-        cc &= ~NVME_CC_REG_EN_MASK;
+        cc &= ~NVMEM(NVME_CC_REG_EN);
         nvme_mmio_write_4(ctrlr, cc, cc);
 
         /*
          * A few drives have firmware bugs that freeze the drive if we access
          * the mmio too soon after we disable.
          */
         if (ctrlr->quirks & QUIRK_DELAY_B4_CHK_RDY)
                 pause("nvmeR", MSEC_2_TICKS(B4_CHK_RDY_DELAY_MS));
nvme_pt_done(void *arg, const struct nvme_completion *cpl)
         struct nvme_pt_command *pt = arg;
         struct mtx *mtx = pt->driver_lock;
         uint16_t status;
 
         bzero(&pt->cpl, sizeof(pt->cpl));
         pt->cpl.cdw0 = cpl->cdw0;
 
         status = cpl->status;
-        status &= ~NVME_STATUS_P_MASK;
+        status &= ~NVMEM(NVME_STATUS_P);
         pt->cpl.status = status;
 
         mtx_lock(mtx);
         pt->driver_lock = NULL;
         wakeup(pt);
         mtx_unlock(mtx);
 }
 

 void
 nvme_ctrlr_shutdown(struct nvme_controller *ctrlr)
 {
         uint32_t        cc;
         uint32_t        csts;
         int             timeout;
 
         cc = nvme_mmio_read_4(ctrlr, cc);
-        cc &= ~(NVME_CC_REG_SHN_MASK << NVME_CC_REG_SHN_SHIFT);
+        cc &= ~NVMEM(NVME_CC_REG_SHN);
         cc |= NVME_SHN_NORMAL << NVME_CC_REG_SHN_SHIFT;
         nvme_mmio_write_4(ctrlr, cc, cc);
 
         timeout = ticks + (ctrlr->cdata.rtd3e == 0 ? 5 * hz :
             ((uint64_t)ctrlr->cdata.rtd3e * hz + 999999) / 1000000);
         while (1) {
                 csts = nvme_mmio_read_4(ctrlr, csts);
                 if (csts == NVME_GONE)                /* Hot unplug. */